infrarust_server_manager 1.6.3

A Minecraft server manager that handles API monitoring and system commands
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

use async_trait::async_trait;
use std::collections::HashMap;
use std::sync::{Arc, RwLock};

use crate::ServerState;
use crate::api::{ApiProvider, ApiServerStatus};
use crate::error::ServerManagerError;

#[derive(Clone, Debug)]
pub struct MockApiProvider {
    server_states: Arc<RwLock<HashMap<String, ApiServerStatus>>>,
}

impl Default for MockApiProvider {
    fn default() -> Self {
        Self::new()
    }
}

impl MockApiProvider {
    pub fn new() -> Self {
        Self {
            server_states: Arc::new(RwLock::new(HashMap::new())),
        }
    }

    pub fn with_server(self, server_id: &str, status: ApiServerStatus) -> Self {
        self.server_states
            .write()
            .unwrap()
            .insert(server_id.to_string(), status);
        self
    }

    pub fn set_server_crashed(&self, server_id: &str) {
        let mut states = self.server_states.write().unwrap();
        if let Some(status) = states.get_mut(server_id) {
            status.is_running = false;
            status.is_crashed = true;
            status.status = ServerState::Crashed;
            status.error = Some("Server has crashed".to_string());
        }
    }

    pub fn set_server_running(&self, server_id: &str) {
        let mut states = self.server_states.write().unwrap();
        if let Some(status) = states.get_mut(server_id) {
            status.is_running = true;
            status.is_crashed = false;
            status.status = ServerState::Running;
            status.error = None;
        }
    }

    pub fn set_server_stopped(&self, server_id: &str) {
        let mut states = self.server_states.write().unwrap();
        if let Some(status) = states.get_mut(server_id) {
            status.is_running = false;
            status.is_crashed = false;
            status.status = ServerState::Stopped;
            status.error = None;
        }
    }
}

#[async_trait]
impl ApiProvider for MockApiProvider {
    async fn get_server_status(
        &self,
        server_id: &str,
    ) -> Result<ApiServerStatus, ServerManagerError> {
        let states = self.server_states.read().unwrap();
        match states.get(server_id) {
            Some(status) => Ok(status.clone()),
            None => Err(ServerManagerError::ApiError(format!(
                "Server {} not found",
                server_id
            ))),
        }
    }

    async fn start_server(&self, server_id: &str) -> Result<(), ServerManagerError> {
        let states = self.server_states.read().unwrap();
        if !states.contains_key(server_id) {
            return Err(ServerManagerError::ApiError(format!(
                "Server {} not found",
                server_id
            )));
        }
        drop(states);

        self.set_server_running(server_id);
        Ok(())
    }

    async fn stop_server(&self, server_id: &str) -> Result<(), ServerManagerError> {
        let states = self.server_states.read().unwrap();
        if !states.contains_key(server_id) {
            return Err(ServerManagerError::ApiError(format!(
                "Server {} not found",
                server_id
            )));
        }
        drop(states);

        self.set_server_stopped(server_id);
        Ok(())
    }
}