implement clone build / deployment repo

lib/helpers/src/docker.rs

@@ -208,7 +208,7 @@ pub async fn prune_images() -> Log {
 
 // NETWORKS
 
-pub async fn create_network(name: &str, driver: Option<&str>) -> Log {
+pub async fn create_network(name: &str, driver: Option<String>) -> Log {
     let driver = match driver {
         Some(driver) => format!(" -d {driver}"),
         None => String::new(),

lib/helpers/src/git.rs

@@ -1,42 +1,83 @@
+use std::{path::PathBuf, str::FromStr};
+
 use ::run_command::async_run_command;
+use anyhow::{anyhow, Context};
 use async_timing_util::unix_timestamp_ms;
-use types::{Build, Deployment, Log};
+use types::{Build, Deployment, GithubToken, Log};
+
+use crate::run_monitor_command;
 
 pub async fn clone_build_repo(
     Build {
-        name,
         repo,
         branch,
-        github_account,
         on_clone,
         ..
     }: &Build,
-) -> Log {
-    todo!()
+    destination: &str,
+    access_token: Option<GithubToken>,
+) -> anyhow::Result<Vec<Log>> {
+    let repo = repo.as_ref().ok_or(anyhow!("build has no repo attached"))?;
+    let clone_log = clone(repo, destination, branch, access_token).await;
+    let mut logs = vec![clone_log];
+    if let Some(command) = on_clone {
+        let mut path = PathBuf::from_str(destination)
+            .context("failed to parse destination path to pathbuf")?;
+        path.push(&command.path);
+        let on_clone_log = run_monitor_command(
+            "on clone",
+            format!("cd {} && {}", path.display(), command.command),
+        )
+        .await;
+        logs.push(on_clone_log);
+    }
+    Ok(logs)
 }
 
-pub async fn clone_deployment_repo(Deployment { .. }: &Deployment) -> Log {
-    todo!()
+pub async fn clone_deployment_repo(
+    Deployment {
+        repo,
+        branch,
+        on_clone,
+        .. 
+    }: &Deployment,
+    destination: &str,
+    access_token: Option<GithubToken>,
+) -> anyhow::Result<Vec<Log>> {
+    let repo = repo.as_ref().ok_or(anyhow!("build has no repo attached"))?;
+    let clone_log = clone(repo, destination, branch, access_token).await;
+    let mut logs = vec![clone_log];
+    if let Some(command) = on_clone {
+        let mut path = PathBuf::from_str(destination)
+            .context("failed to parse destination path to pathbuf")?;
+        path.push(&command.path);
+        let on_clone_log = run_monitor_command(
+            "on clone",
+            format!("cd {} && {}", path.display(), command.command),
+        )
+        .await;
+        logs.push(on_clone_log);
+    }
+    Ok(logs)
 }
 
 async fn clone(
     repo: &str,
     destination: &str,
-    branch: Option<String>,
-    access_token: Option<String>,
+    branch: &Option<String>,
+    access_token: Option<GithubToken>,
 ) -> Log {
     let _ = std::fs::remove_dir_all(destination);
     let access_token = match access_token {
-        Some(token) => {
-            format!("{token}@")
-        }
-        None => {
-            format!("")
-        }
+        Some(token) => format!("{token}@"),
+        None => String::new(),
+    };
+    let branch = match branch {
+        Some(branch) => format!(" -b {branch}"),
+        None => String::new(),
     };
-    let branch = branch.unwrap_or("main".to_string());
     let repo_url = format!("https://{access_token}github.com/{repo}.git");
-    let command = format!("git clone {repo_url} {destination} -b {branch}");
+    let command = format!("git clone {repo_url} {destination}{branch}");
     let start_ts = unix_timestamp_ms() as i64;
     let output = async_run_command(&command).await;
     let command = if access_token.len() > 0 {

lib/types/src/lib.rs

@@ -90,6 +90,12 @@ pub struct Deployment {
     pub is_core: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub build_id: Option<BuildId>,
+
+    // deployment repo related
+    pub repo: Option<String>,
+    pub branch: Option<String>,
+    pub github_account: Option<String>,
+    pub on_clone: Option<Command>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]

periphery/src/api/container.rs

@@ -53,5 +53,9 @@ pub fn router() -> Router {
                 Json(docker::deploy(&deployment).await)
             }),
         )
+        .route(
+            "/prune",
+            post(|| async { Json(docker::prune_containers().await) }),
+        )
         .layer(DockerClient::extension())
 }

periphery/src/api/mod.rs

@@ -3,12 +3,14 @@ use axum::{routing::get, Router};
 mod accounts;
 mod container;
 mod git;
+mod network;
 mod stats;
 
 pub fn router() -> Router {
     Router::new()
         .route("/accounts/:account_type", get(accounts::get_accounts))
         .nest("/container", container::router())
+        .nest("/network", network::router())
         .nest("/stats", stats::router())
         .nest("/git", git::router())
 }

periphery/src/api/network.rs

@@ -0,0 +1,29 @@
+use axum::{routing::post, Json, Router};
+use helpers::docker;
+use serde::Deserialize;
+
+#[derive(Deserialize, Clone)]
+pub struct NetworkReqBody {
+    name: String,
+    driver: Option<String>,
+}
+
+pub fn router() -> Router {
+    Router::new()
+        .route(
+            "/create",
+            post(|Json(body): Json<NetworkReqBody>| async move {
+                Json(docker::create_network(&body.name, body.driver).await)
+            }),
+        )
+        .route(
+            "/delete",
+            post(|Json(body): Json<NetworkReqBody>| async move {
+                Json(docker::delete_network(&body.name).await)
+            }),
+        )
+        .route(
+            "/prune",
+            post(|| async move { Json(docker::prune_networks().await) }),
+        )
+}