initial commit

src/web.rs

@@ -0,0 +1,113 @@
+use std::{any::Any, clone, env, fmt::Display, sync::LazyLock};
+
+use actix_web::{
+    App, HttpResponse, HttpResponseBuilder, HttpServer, Responder, ResponseError, Result, get,
+    http::{self, StatusCode},
+    web,
+};
+use kube::{Api, Resource, api::ListParams, core::object::HasSpec};
+use serde::{Deserialize, Serialize};
+
+use crate::crds::GameServer;
+
+static SELF_ENDPOINT: LazyLock<String> =
+    LazyLock::new(|| env::var("SELF_ENDPOINT").expect("SELF_ENDPOINT is not specified"));
+
+#[derive(Clone, Debug, Serialize)]
+struct ResourceNameDescriptor {
+    name: String,
+    resource: String,
+}
+
+#[derive(Debug)]
+struct KubeError(kube::Error);
+
+impl Display for KubeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl ResponseError for KubeError {
+    fn status_code(&self) -> http::StatusCode {
+        StatusCode::INTERNAL_SERVER_ERROR
+    }
+
+    fn error_response(&self) -> HttpResponse<actix_web::body::BoxBody> {
+        HttpResponseBuilder::new(self.status_code()).body(self.0.to_string())
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct HashParam {
+    hash: Option<u64>,
+}
+
+#[get("/gameserver/discover")]
+async fn gameservers(kube_client: web::Data<kube::Client>) -> Result<impl Responder> {
+    let servers: Api<GameServer> = Api::all(kube_client.get_ref().clone());
+
+    let servers = servers
+        .list_metadata(&ListParams::default())
+        .await
+        .map_err(KubeError)?;
+
+    let list: Vec<_> = servers
+        .into_iter()
+        .map(|v| ResourceNameDescriptor {
+            name: v.metadata.name.clone().unwrap(),
+            resource: format!(
+                "{}/gameserver/{}",
+                &*SELF_ENDPOINT,
+                v.metadata.name.unwrap()
+            ),
+        })
+        .collect();
+
+    Ok(web::Json(list))
+}
+
+#[get("/gameserver/{game_name}")]
+async fn get_gameserver(
+    kube_client: web::Data<kube::Client>,
+    path: web::Path<(String)>,
+) -> Result<impl Responder> {
+    let (game_name) = path.into_inner();
+    let servers: Api<GameServer> = Api::all(kube_client.get_ref().clone());
+
+    let game_server = servers.get(&game_name).await.map_err(KubeError)?;
+    let game_server_spec = game_server.spec();
+
+    Ok(web::Json(game_server_spec.clone()))
+}
+
+#[get("/gameserver/{game_name}/auth_proxy")]
+async fn get_gameserver_proxy(
+    kube_client: web::Data<kube::Client>,
+    path: web::Path<String>,
+    param: web::Query<HashParam>,
+) -> Result<impl Responder> {
+    let game_name = path.into_inner();
+    let hash = param.0.hash.unwrap_or(0);
+    let servers: Api<GameServer> = Api::all(kube_client.get_ref().clone());
+
+    let game_server = servers.get(&game_name).await.map_err(KubeError)?;
+    let game_server_spec = game_server.spec();
+
+    Ok(web::Json(game_server_spec.clone()))
+}
+
+pub async fn start_webserver(kube_client: kube::Client) {
+    HttpServer::new(move || {
+        App::new()
+            .app_data(web::Data::new(kube_client.clone()))
+            .service(gameservers)
+            .service(get_gameserver)
+            .service(get_gameserver_proxy)
+    })
+    .bind(("127.0.0.1", 8080))
+    .expect("failed to start webserver")
+    .run()
+    .await
+    .expect("error occurred whilest running webserver");
+}