bevygap_server_plugin 0.3.1

Plugin for bevy gameservers for use with lightyear on edgegap
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

/// Plugin that fetches the context from the Edgegap API, which contains
/// information relevant to the deployment of this gameserver, such as its
/// location, public IP, and other metadata.
use crate::arbitrium_env::ArbitriumEnv;
use crate::bevy_tokio_tasks::TokioTasksRuntime;
use bevy::prelude::*;

#[derive(Event)]
pub(crate) struct ContextLoaded;

#[derive(Resource, Debug, Clone)]
pub struct ArbitriumContext {
    context: serde_json::Map<String, serde_json::Value>,
}

impl ArbitriumContext {
    pub fn location(&self) -> String {
        let location = self
            .context
            .get("location")
            .expect("Missing location key in context");
        let city = location.get("city").expect("Missing city key in context");
        let country = location
            .get("country")
            .expect("Missing country key in context");
        format!("{}, {}", city, country)
    }

    pub fn to_bytes(&self) -> Vec<u8> {
        serde_json::to_vec(&self.context).expect("Failed to serialize context to JSON")
    }

    pub fn sockets(&self) -> u32 {
        let serde_json::Value::Number(sockets) = self
            .context
            .get("sockets")
            .expect("Missing sockets key in context")
        else {
            panic!("Sockets is not a number!");
        };
        sockets.as_u64().expect("Sockets is not a number") as u32
    }

    pub fn top_level_string(&self, key: &str) -> String {
        self.context
            .get(key)
            .expect("Missing {str} key in context")
            .as_str()
            .expect("{str} is not a string")
            .to_string()
    }

    pub fn request_id(&self) -> String {
        self.top_level_string("request_id")
    }

    pub fn public_ip(&self) -> String {
        self.top_level_string("public_ip")
    }

    pub fn fqdn(&self) -> String {
        self.top_level_string("fqdn")
    }
}

/// Load context from the Edgegap API and insert into world resource.
async fn fetch_context_from_api(
    context_url: &str,
    context_token: &str,
) -> Result<ArbitriumContext, async_nats::Error> {
    let context_response = crate::http_client::get_context(context_url, context_token).await?;

    let serde_json::Value::Object(context_map) = context_response else {
        panic!("Context is not an object");
    };
    info!("Context fetched: {:?}", context_map);

    Ok(ArbitriumContext {
        context: context_map,
    })
}

pub fn fetch_context_on_nats_connected(
    _trigger: Trigger<crate::plugin::NatsConnected>,
    runtime: ResMut<TokioTasksRuntime>,
    arb_env: Res<ArbitriumEnv>,
) {
    let context_url = arb_env.context_url.clone();
    let context_token = arb_env.context_token.clone();
    info!("Fetching context: {context_url} ::::  {context_token}");

    runtime.spawn_background_task(|mut ctx| async move {
        let arb_context = fetch_context_from_api(&context_url, &context_token)
            .await
            // .expect("Failed to fetch context from Edgegap API");
            .unwrap_or_else(|_err| {
                error!("Failed to fetch context from Edgegap API: {_err}");
                panic!("Failed to fetch context");
                // // panic, or use a fake value:
                // warn!("Using fake context!");
                // let mut context = serde_json::Map::new();
                // context.insert("fake_data".into(), "lol".into());
                // context.insert("fqdn".into(), "rj.example.com".into());
                // ArbitriumContext { context }
            });
        info!("Got Context: {arb_context:?}");
        ctx.run_on_main_thread(move |ctx| {
            ctx.world.insert_resource(arb_context);
            ctx.world.trigger(ContextLoaded);
        })
        .await;
    });
}