feat: with monitor

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/churn/Cargo.toml

@@ -4,6 +4,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+churn-domain.workspace = true
+
 anyhow.workspace = true
 tokio.workspace = true
 tracing.workspace = true

crates/churn/src/main.rs

@@ -1,5 +1,4 @@
-use std::net::SocketAddr;
-
+use churn_domain::{AgentEnrollReq, LeaseResp, ServerMonitorResp};
 use clap::{Parser, Subcommand};
 
 #[derive(Parser)]
@@ -11,10 +10,20 @@ struct Command {
 
 #[derive(Subcommand)]
 enum Commands {
+    Auth {
+        #[arg(env = "CHURN_SERVER", long)]
+        server: String,
+
+        #[arg(env = "CHURN_SERVER_TOKEN", long)]
+        server_token: String,
+    },
     Bootstrap {
         #[arg(env = "CHURN_AGENT", long)]
         agent: String,
 
+        #[arg(env = "CHURN_AGENT_NAME", long)]
+        agent_name: String,
+
         #[arg(env = "CHURN_SERVER", long)]
         server: String,
 
@@ -27,6 +36,13 @@ enum Commands {
         #[arg(env = "CHURN_AGENT", long)]
         agent: String,
     },
+    Monitor {
+        #[arg(env = "CHURN_SERVER", long)]
+        server: String,
+
+        #[arg(env = "CHURN_SERVER_TOKEN", long)]
+        server_token: String,
+    },
 }
 
 #[tokio::main]
@@ -46,9 +62,38 @@ async fn handle_command(cmd: Command) -> anyhow::Result<()> {
         match cmd {
             Commands::Bootstrap {
                 agent,
+                agent_name,
                 server,
-                server_token,
-            } => todo!(),
+                server_token: _,
+            } => {
+                tracing::info!("enrolling agent: {} for server: {}", agent, server);
+                let client = reqwest::Client::new();
+                let req = client.post(format!("{server}/agent/lease")).build()?;
+                let lease_resp = client.execute(req).await?;
+                let lease = lease_resp.json::<LeaseResp>().await?;
+
+                let req = client
+                    .post(format!("{agent}/enroll"))
+                    .json(&AgentEnrollReq {
+                        lease: lease.token,
+                        server,
+                        agent_name,
+                    })
+                    .build()?;
+                let lease_resp = client.execute(req).await?;
+                if !lease_resp.status().is_success() {
+                    if let Ok(text) = lease_resp.text().await {
+                        tracing::warn!(
+                            "could not enroll because agent server encoutered error: {}",
+                            text
+                        );
+                        anyhow::bail!("encountered error: {}", text);
+                    }
+                    anyhow::bail!("encountered error");
+                }
+
+                Ok(())
+            }
             Commands::Health { server, agent } => {
                 tracing::info!("connecting to server: {}", server);
                 reqwest::get(format!("{server}/ping")).await?;
@@ -58,6 +103,52 @@ async fn handle_command(cmd: Command) -> anyhow::Result<()> {
                 tracing::info!("connected to agent successfully");
                 Ok(())
             }
+            Commands::Auth {
+                server: _,
+                server_token: _,
+            } => todo!(),
+            Commands::Monitor {
+                server,
+                server_token,
+            } => {
+                tracing::info!("monitoring server: {}", server);
+
+                let mut cursor: Option<String> = None;
+                loop {
+                    tracing::info!("reading logs from server: {}", server);
+
+                    let resp = reqwest::get(format!(
+                        "{server}/logs{}",
+                        match &cursor {
+                            None => "".to_string(),
+                            Some(cursor) => format!("?cursor={}", cursor),
+                        }
+                    ))
+                    .await?;
+
+                    if !resp.status().is_success() {
+                        if let Ok(text) = resp.text().await {
+                            anyhow::bail!("encountered error: {}", text);
+                        }
+                        anyhow::bail!("encountered error");
+                    }
+
+                    match resp.json::<ServerMonitorResp>().await {
+                        Ok(resp) => {
+                            for line in resp.logs {
+                                tracing::info!("server: {}", line);
+                            }
+                            cursor = Some(resp.cursor);
+                        }
+                        Err(e) => {
+                            tracing::warn!("failed to call server (error={})", e);
+                        }
+                    }
+                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                }
+
+                Ok(())
+            }
         }
     } else {
         panic!("no command supplied")