infrarust 1.6.1

A Rust universal Minecraft proxy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::sync::Arc;

use infrarust_config::provider::ProviderMessage;
use tokio::sync::{RwLock, mpsc::Sender};

use crate::{FilterRegistry, InfrarustConfig, cli::ShutdownController, server::manager::Manager};

use super::{
    actors::supervisor::ActorSupervisor, config::service::ConfigurationService,
    event::GatewayMessage,
};

use crate::server::gateway::Gateway;

pub struct SharedComponent {
    config: Arc<InfrarustConfig>,

    actor_supervisor: Arc<ActorSupervisor>,
    configuration_service: Arc<ConfigurationService>,
    filter_registry: Arc<FilterRegistry>,
    server_managers: Arc<Manager>,
    gateway: RwLock<Option<Arc<Gateway>>>,

    shutdown_controller: Arc<ShutdownController>,

    _gateway_sender: Sender<GatewayMessage>,
    provider_sender: Sender<ProviderMessage>,
}

impl std::fmt::Debug for SharedComponent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SharedComponent")
            .field("config", &self.config)
            .field("actor_supervisor", &self.actor_supervisor)
            .field("configuration_service", &self.configuration_service)
            .field("filter_registry", &self.filter_registry)
            .field("server_managers", &self.server_managers)
            .field("gateway", &"<Gateway>") // Skip to prevent circular reference
            .field("shutdown_controller", &self.shutdown_controller)
            .finish_non_exhaustive()
    }
}

#[allow(clippy::too_many_arguments)]
impl SharedComponent {
    pub fn new(
        config: Arc<InfrarustConfig>,
        actor_supervisor: Arc<ActorSupervisor>,
        configuration_service: Arc<ConfigurationService>,
        filter_registry: Arc<FilterRegistry>,
        shutdown_controller: Arc<ShutdownController>,
        gateway_sender: Sender<GatewayMessage>,
        provider_sender: Sender<ProviderMessage>,
        server_managers: Arc<Manager>,
    ) -> Self {
        Self {
            config,
            actor_supervisor,
            configuration_service,
            filter_registry,
            shutdown_controller,
            _gateway_sender: gateway_sender,
            provider_sender,
            server_managers,
            gateway: RwLock::new(None),
        }
    }

    pub(crate) fn config(&self) -> &InfrarustConfig {
        &self.config
    }

    pub(crate) fn actor_supervisor(&self) -> &ActorSupervisor {
        &self.actor_supervisor
    }

    pub(crate) fn actor_supervisor_arc(&self) -> Arc<ActorSupervisor> {
        Arc::clone(&self.actor_supervisor)
    }

    pub(crate) fn configuration_service(&self) -> &ConfigurationService {
        &self.configuration_service
    }

    pub(crate) fn configuration_service_arc(&self) -> Arc<ConfigurationService> {
        Arc::clone(&self.configuration_service)
    }

    pub(crate) fn filter_registry(&self) -> &FilterRegistry {
        &self.filter_registry
    }

    pub(crate) fn filter_registry_arc(&self) -> Arc<FilterRegistry> {
        Arc::clone(&self.filter_registry)
    }

    pub(crate) fn shutdown_controller(&self) -> &ShutdownController {
        &self.shutdown_controller
    }

    pub(crate) fn shutdown_controller_arc(&self) -> Arc<ShutdownController> {
        Arc::clone(&self.shutdown_controller)
    }

    pub(crate) fn _gateway_sender(&self) -> &Sender<GatewayMessage> {
        &self._gateway_sender
    }

    pub(crate) fn provider_sender(&self) -> &Sender<ProviderMessage> {
        &self.provider_sender
    }

    pub(crate) fn server_managers(&self) -> &Manager {
        &self.server_managers
    }

    pub async fn set_gateway(&self, gateway: Arc<Gateway>) {
        let mut lock = self.gateway.write().await;
        *lock = Some(gateway);
    }

    pub fn gateway(&self) -> Option<Arc<Gateway>> {
        self.gateway.try_read().ok()?.clone()
    }
}