Major Grafana updates

Author: Kile

.github/workflows/api-test.yml

@@ -54,6 +54,8 @@ jobs:
 
       - name: Setup local cards
         run: "echo '[{\"id\": 0, \"name\": \"Name\", \"description\": \"One two\", \"image\": \"/image/image.png\", \"emoji\": \":pensive\", \"rank\": \"S\", \"limit\": 10, \"type\": \"monster\", \"available\": true}]' > cards.json"
+      - name: Make update.sh executable
+        run: chmod +x scripts/update.sh
       - name: Run clippy
         run: cargo clippy --all --all-features --tests -- -D warnings
         working-directory: api

alloy/config.alloy

@@ -0,0 +1,64 @@
+// ###############################
+// #### Metrics Configuration ####
+// ###############################
+
+// Host Cadvisor on the Docker socket to expose container metrics.
+prometheus.exporter.cadvisor "example" {
+  docker_host = "unix:///var/run/docker.sock"
+
+  storage_duration = "5m"
+}
+
+
+// Configure a prometheus.scrape component to collect cadvisor metrics.
+prometheus.scrape "scraper" {
+  targets    = prometheus.exporter.cadvisor.example.targets
+  forward_to = [ prometheus.remote_write.demo.receiver ]
+
+
+  scrape_interval = "10s"
+}
+
+// Configure a prometheus.remote_write component to send metrics to a Prometheus server.
+prometheus.remote_write "demo" {
+  endpoint {
+    url = "http://prometheus:9090/api/v1/write"
+  }
+}
+
+// ###############################
+// #### Logging Configuration ####
+// ###############################
+
+// Discover Docker containers and extract metadata.
+discovery.docker "linux" {
+  host = "unix:///var/run/docker.sock"
+}
+
+// Define a relabeling rule to create a service name from the container name.
+discovery.relabel "logs_integrations_docker" {
+      targets = []
+  
+      rule {
+          source_labels = ["__meta_docker_container_name"]
+          regex = "/(.*)"
+          target_label = "service_name"
+      }
+
+  }
+
+
+// Configure a loki.source.docker component to collect logs from Docker containers.
+loki.source.docker "default" {
+  host       = "unix:///var/run/docker.sock"
+  targets    = discovery.docker.linux.targets
+  labels     = {"platform" = "docker"}
+  relabel_rules = discovery.relabel.logs_integrations_docker.rules
+  forward_to = [loki.write.local.receiver]
+}
+
+loki.write "local" {
+  endpoint {
+    url = "http://loki:3100/loki/api/v1/push"
+  }
+}

api/Dockerfile

@@ -1,5 +1,5 @@
 # Use an official Rust runtime as a parent image
-FROM rust:1.78 AS base
+FROM rust:1.87 AS base
 
 ARG MYUID=1000
 ARG MYGID=1000
@@ -8,6 +8,7 @@ ARG MYGID=1000
 WORKDIR /app
 
 COPY api/ api/
+COPY scripts/ scripts/
 
 # This is mainly for reading the config.json
 WORKDIR /app/api

api/src/main.rs

@@ -15,6 +15,7 @@ use routes::commands::get_commands;
 use routes::diagnostics::get_diagnostics;
 use routes::image::image;
 use routes::stats::get_stats;
+use routes::update::{update, update_cors};
 use routes::vote::register_vote;
 
 use fairings::cors::Cors;
@@ -33,7 +34,9 @@ fn rocket() -> _ {
                 image,
                 get_diagnostics,
                 get_cards,
-                get_public_cards
+                get_public_cards,
+                update,
+                update_cors,
             ],
         )
         .attach(db::init())

api/src/routes/commands.rs

@@ -43,7 +43,7 @@ static CACHE: OnceCell<HashMap<String, Category>> = OnceCell::const_new();
 pub async fn get_commands() -> Result<Json<HashMap<String, Category>>, BadRequest<Json<Value>>> {
     let commands = CACHE
         .get_or_try_init(|| async {
-            let commands = make_request("commands", NoData {})
+            let commands = make_request("commands", NoData {}, 0_u8)
                 .await
                 .context("Failed to get commands")?;
             // Parse the commands into a HashMap using the defined structs and rocket

api/src/routes/common/utils.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use tokio::task;
-use zmq::{Context, REQ};
+use zmq::{Context, SocketType::DEALER};
 
 use rocket::response::status::BadRequest;
 use rocket::serde::json::Json;
@@ -27,9 +27,10 @@ pub struct NoData {}
 pub fn make_request_inner<'a, T: Serialize + Deserialize<'a>>(
     route: &str,
     data: T,
+    first_bit: u8,
 ) -> Result<String, zmq::Error> {
     let ctx = Context::new();
-    let socket = ctx.socket(REQ).unwrap();
+    let socket = ctx.socket(DEALER).unwrap();
 
     assert!(socket.set_linger(0).is_ok());
     // Omg this function...
@@ -53,6 +54,7 @@ pub fn make_request_inner<'a, T: Serialize + Deserialize<'a>>(
     // Get route from environment variable
     let address = std::env::var("ZMQ_ADDRESS").unwrap_or("tcp://0.0.0.0:3210".to_string());
     assert!(socket.connect(&address).is_ok());
+    assert!(socket.set_identity("api-client".as_bytes()).is_ok());
 
     let request_data = RequestData {
         route: route.to_owned(),
@@ -62,21 +64,25 @@ pub fn make_request_inner<'a, T: Serialize + Deserialize<'a>>(
     let mut msg = zmq::Message::new();
     let request_json = serde_json::to_string(&request_data).unwrap();
 
-    socket.send(request_json.as_bytes(), 0).unwrap();
-    let result = socket.recv(&mut msg, 0);
+    let mut data = vec![first_bit];
+    data.extend_from_slice(request_json.as_bytes());
+    socket.send("", zmq::SNDMORE)?; // delimiter
+    socket.send(data, 0)?;
+
+    socket.recv(&mut msg, 0)?; // Receive acknowledgment from the server
 
     // Close the socket
     assert!(socket.disconnect(&address).is_ok());
 
-    result?; // Return error if error (Rust is cool)
-    Ok(msg.as_str().unwrap().to_string())
+    Ok(msg.as_str().unwrap_or("").to_string())
 }
 
 pub async fn make_request<T: Serialize + std::marker::Send + Deserialize<'static> + 'static>(
     route: &'static str,
     data: T,
+    first_bit: u8,
 ) -> Result<String, zmq::Error> {
-    task::spawn_blocking(move || make_request_inner(route, data))
+    task::spawn_blocking(move || make_request_inner(route, data, first_bit))
         .await
         .unwrap()
 }

api/src/routes/diagnostics.rs

@@ -68,7 +68,7 @@ pub async fn get_diagnostics(
         None => insert(&mut formatted),
     };
     let start_time = SystemTime::now();
-    let res = make_request("heartbeat", NoData {}).await;
+    let res = make_request("heartbeat", NoData {}, 0_u8).await;
     let success = res.is_ok();
     let response_time = match success {
         true => Some(start_time.elapsed().unwrap().as_secs_f64() * 1000.0),

api/src/routes/mod.rs

@@ -4,4 +4,5 @@ pub mod common;
 pub mod diagnostics;
 pub mod image;
 pub mod stats;
+pub mod update;
 pub mod vote;

api/src/routes/stats.rs

@@ -15,7 +15,7 @@ pub struct Stats {
 
 #[get("/stats")]
 pub async fn get_stats() -> Result<Json<Stats>, BadRequest<Json<Value>>> {
-    let stats = make_request("stats", NoData {})
+    let stats = make_request("stats", NoData {}, 0_u8)
         .await
         .context("Failed to get stats")?;
     let stats: Stats = serde_json::from_str(&stats).unwrap();

api/src/routes/update.rs

@@ -0,0 +1,96 @@
+use super::common::keys::ApiKey;
+
+use serde_json::Value;
+
+use super::common::utils::{make_request, ResultExt};
+use rocket::response::status::BadRequest;
+use rocket::serde::json::Json;
+
+#[derive(FromFormField, Debug)]
+pub enum TestOption {
+    Pass,
+    Fail,
+}
+
+struct CommandResult {
+    exit_code: i32,
+    output: String,
+}
+
+async fn send_command_and_get_result(
+    command: String,
+    first_bit: u8,
+) -> Result<CommandResult, BadRequest<Json<Value>>> {
+    // List files in the directory
+    let response = make_request("update", command, first_bit)
+        .await
+        .context("Failed to get command output")?;
+
+    let exit_code = response
+        .split("\n")
+        .next()
+        .unwrap_or("EXIT_CODE=0")
+        .to_string();
+    let parsed_exit_code = exit_code
+        .split('=')
+        .nth(1)
+        .unwrap_or("0")
+        .parse::<i32>()
+        .unwrap_or(0);
+    let output = response
+        .split("\n")
+        .skip(1)
+        .collect::<Vec<&str>>()
+        .join("\n");
+
+    // Remove OUTPUT= prefix if it exists
+    let output = if let Some(stripped) = output.strip_prefix("OUTPUT=") {
+        stripped.to_string()
+    } else {
+        output
+    };
+
+    Ok(CommandResult {
+        exit_code: parsed_exit_code,
+        output,
+    })
+}
+
+#[post("/update?<force>&<test>")]
+pub async fn update(
+    _key: ApiKey,
+    force: Option<bool>,
+    test: Option<TestOption>,
+) -> Result<Json<Value>, BadRequest<Json<Value>>> {
+    // Runs a shell script which is in scripts/update.sh
+    let command = "scripts/update.sh".to_owned()
+        + match test {
+            Some(TestOption::Pass) => " --test-pass",
+            Some(TestOption::Fail) => " --test-fail",
+            None => "",
+        }
+        + if force.unwrap_or(false) {
+            " --force"
+        } else {
+            ""
+        };
+
+    let output = send_command_and_get_result(command, 1_u8).await?;
+
+    if output.exit_code != 0 {
+        return Err(BadRequest(Json(
+            serde_json::json!({"error": format!("Update script failed: {}", output.output)}),
+        )));
+    }
+
+    Ok(Json(
+        serde_json::json!({"status": format!("Success: {}", output.output)}),
+    ))
+}
+
+#[options("/update")] // Sucks I have to do this
+pub fn update_cors() -> Json<Value> {
+    Json(serde_json::json!({
+        "status": "CORS preflight request"
+    }))
+}