Periphery config repo dir parse as PathBuf

lib/helpers/src/docker/build.rs

@@ -1,4 +1,4 @@
-use std::{path::PathBuf, str::FromStr};
+use std::path::PathBuf;
 
 use anyhow::{anyhow, Context};
 use types::{Build, DockerBuildArgs, EnvironmentVar, Log, Version};
@@ -22,7 +22,7 @@ pub async fn build(
         pre_build,
         ..
     }: &Build,
-    repo_dir: &str,
+    mut repo_dir: PathBuf,
     docker_token: Option<String>,
 ) -> anyhow::Result<Vec<Log>> {
     let mut logs = Vec::new();
@@ -37,28 +37,18 @@ pub async fn build(
     let using_account = docker_login(docker_account, &docker_token)
         .await
         .context("failed to login to docker")?;
-    let repo_dir = PathBuf::from_str(repo_dir)
-        .context(format!("invalid repo dir: {repo_dir}"))?
-        .join(&name);
-    let pull_logs = git::pull(
-        &repo_dir
-            .to_str()
-            .context(format!("invalid repo dir: {}", repo_dir.display()))?,
-        branch,
-        &None,
-    )
-    .await;
+    repo_dir.push(&name);
+    let pull_logs = git::pull(repo_dir.clone(), branch, &None).await;
     if !all_logs_success(&pull_logs) {
         logs.extend(pull_logs);
         return Ok(logs);
     }
     logs.extend(pull_logs);
     if let Some(command) = pre_build {
-        let mut repo_dir = repo_dir.clone();
-        repo_dir.push(&command.path);
+        let dir = repo_dir.join(&command.path);
         let pre_build_log = run_monitor_command(
             "pre build",
-            format!("cd {} && {}", repo_dir.display(), command.command),
+            format!("cd {} && {}", dir.display(), command.command),
         )
         .await;
         if !pre_build_log.success {
@@ -68,7 +58,6 @@ pub async fn build(
         logs.push(pre_build_log);
     }
     let build_dir = repo_dir.join(build_path);
-    let cd = build_dir.display();
     let dockerfile_path = match dockerfile_path {
         Some(dockerfile_path) => dockerfile_path.to_owned(),
         None => "Dockerfile".to_owned(),
@@ -82,7 +71,8 @@ pub async fn build(
         String::new()
     };
     let command = format!(
-        "cd {cd} && docker build {build_args}{image_tags} -f {dockerfile_path} .{docker_push}"
+        "cd {} && docker build {build_args}{image_tags} -f {dockerfile_path} .{docker_push}",
+        build_dir.display()
     );
     let build_log = run_monitor_command("docker build", command).await;
     logs.push(build_log);

lib/helpers/src/docker/container.rs

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use anyhow::{anyhow, Context};
 use run_command::async_run_command;
 use types::{
@@ -67,18 +69,23 @@ pub async fn stop_and_remove_container(container_name: &str) -> Log {
     run_monitor_command("docker stop and remove", command).await
 }
 
-pub async fn deploy(deployment: &Deployment, docker_token: &Option<String>) -> Log {
+pub async fn deploy(
+    deployment: &Deployment,
+    docker_token: &Option<String>,
+    repo_dir: PathBuf,
+) -> Log {
     if let Err(e) = docker_login(&deployment.docker_run_args.docker_account, docker_token).await {
         return Log::error("docker login", format!("{e:#?}"));
     }
     let _ = stop_and_remove_container(&to_monitor_name(&deployment.name)).await;
-    let command = docker_run_command(deployment);
+    let command = docker_run_command(deployment, repo_dir);
     run_monitor_command("docker run", command).await
 }
 
 pub fn docker_run_command(
     Deployment {
         name,
+        repo_mount,
         docker_run_args:
             DockerRunArgs {
                 image,
@@ -93,11 +100,22 @@ pub fn docker_run_command(
             },
         ..
     }: &Deployment,
+    mut repo_dir: PathBuf,
 ) -> String {
     let name = to_monitor_name(name);
     let container_user = parse_container_user(container_user);
     let ports = parse_conversions(ports, "-p");
-    let volumes = parse_conversions(volumes, "-v");
+    let mut volumes = volumes.to_owned();
+    if let Some(repo_mount) = repo_mount {
+        repo_dir.push(&name);
+        repo_dir.push(&repo_mount.local);
+        let repo_mount = Conversion {
+            local: repo_dir.display().to_string(),
+            container: repo_mount.container.clone(),
+        };
+        volumes.push(repo_mount);
+    }
+    let volumes = parse_conversions(&volumes, "-v");
     let network = parse_network(network);
     let restart = parse_restart(restart);
     let environment = parse_environment(environment);

lib/helpers/src/git.rs

@@ -1,4 +1,4 @@
-use std::{path::PathBuf, str::FromStr};
+use std::path::PathBuf;
 
 use ::run_command::async_run_command;
 use anyhow::anyhow;
@@ -43,12 +43,16 @@ impl From<&Build> for CloneArgs {
     }
 }
 
-pub async fn pull(path: &str, branch: &Option<String>, on_pull: &Option<Command>) -> Vec<Log> {
+pub async fn pull(
+    mut path: PathBuf,
+    branch: &Option<String>,
+    on_pull: &Option<Command>,
+) -> Vec<Log> {
     let branch = match branch {
         Some(branch) => branch.to_owned(),
         None => "main".to_string(),
     };
-    let command = format!("cd {path} && git pull origin {branch}");
+    let command = format!("cd {} && git pull origin {branch}", path.display());
     let mut logs = Vec::new();
     let pull_log = run_monitor_command("git pull", command).await;
     if !pull_log.success {
@@ -57,7 +61,6 @@ pub async fn pull(path: &str, branch: &Option<String>, on_pull: &Option<Command>
     }
     logs.push(pull_log);
     if let Some(on_pull) = on_pull {
-        let mut path = PathBuf::from_str(path).unwrap();
         path.push(&on_pull.path);
         let path = path.display().to_string();
         let on_pull_log = run_monitor_command(
@@ -72,7 +75,7 @@ pub async fn pull(path: &str, branch: &Option<String>, on_pull: &Option<Command>
 
 pub async fn clone_repo(
     clone_args: impl Into<CloneArgs>,
-    repo_dir: &str,
+    mut repo_dir: PathBuf,
     access_token: Option<GithubToken>,
 ) -> anyhow::Result<Vec<Log>> {
     let CloneArgs {
@@ -84,31 +87,28 @@ pub async fn clone_repo(
         ..
     } = clone_args.into();
     let repo = repo.as_ref().ok_or(anyhow!("build has no repo attached"))?;
-    let mut repo_dir = PathBuf::from_str(repo_dir)?;
     let name = to_monitor_name(&name);
     repo_dir.push(name);
     let destination = repo_dir.display().to_string();
     let clone_log = clone(repo, &destination, &branch, access_token).await;
     let mut logs = vec![clone_log];
     if let Some(command) = on_clone {
-        repo_dir.push(&command.path);
+        let on_clone_path = repo_dir.join(&command.path);
         let on_clone_log = run_monitor_command(
             "on clone",
-            format!("cd {} && {}", repo_dir.display(), command.command),
+            format!("cd {} && {}", on_clone_path.display(), command.command),
         )
         .await;
         logs.push(on_clone_log);
-        repo_dir.pop();
     }
     if let Some(command) = on_pull {
-        repo_dir.push(&command.path);
-        let on_clone_log = run_monitor_command(
-            "on clone",
-            format!("cd {} && {}", repo_dir.display(), command.command),
+        let on_pull_path = repo_dir.join(&command.path);
+        let on_pull_log = run_monitor_command(
+            "on pull",
+            format!("cd {} && {}", on_pull_path.display(), command.command),
         )
         .await;
-        logs.push(on_clone_log);
-        repo_dir.pop();
+        logs.push(on_pull_log);
     }
     Ok(logs)
 }

lib/types/src/config.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, net::IpAddr};
+use std::{collections::HashMap, net::IpAddr, path::PathBuf};
 
 use serde::{Deserialize, Serialize};
 
@@ -87,7 +87,7 @@ pub struct PeripheryConfig {
     #[serde(default = "default_periphery_port")]
     pub port: u16,
     #[serde(default = "default_repo_dir")]
-    pub repo_dir: String,
+    pub repo_dir: PathBuf,
     #[serde(default = "default_stats_refresh_interval")]
     pub stats_polling_rate: Timelength,
     #[serde(default)]
@@ -104,8 +104,8 @@ fn default_periphery_port() -> u16 {
     8000
 }
 
-fn default_repo_dir() -> String {
-    "/repos".to_string()
+fn default_repo_dir() -> PathBuf {
+    "/repos".parse().unwrap()
 }
 
 fn default_stats_refresh_interval() -> Timelength {

periphery/src/api/build.rs

@@ -41,7 +41,7 @@ async fn build_image(
         return Err(anyhow!("{PERIPHERY_BUILDER_BUSY}"));
     }
     let docker_token = get_docker_token(&build.docker_account, &config)?;
-    let logs = docker::build(&build, &config.repo_dir, docker_token).await?;
+    let logs = docker::build(&build, config.repo_dir.clone(), docker_token).await?;
     let mut lock = busy.lock().await;
     *lock = false;
     Ok(Json(logs))

periphery/src/api/container.rs

@@ -78,7 +78,9 @@ async fn deploy(
     Json(deployment): Json<Deployment>,
 ) -> Json<Log> {
     let log = match get_docker_token(&deployment.docker_run_args.docker_account, &config) {
-        Ok(docker_token) => docker::deploy(&deployment, &docker_token).await,
+        Ok(docker_token) => {
+            docker::deploy(&deployment, &docker_token, config.repo_dir.clone()).await
+        }
         Err(e) => Log::error("docker login", format!("{e:#?}")),
     };
     Json(log)

periphery/src/api/git.rs

@@ -1,5 +1,3 @@
-use std::{path::PathBuf, str::FromStr};
-
 use axum::{routing::post, Extension, Json, Router};
 use helpers::{
     git::{self, CloneArgs},
@@ -51,7 +49,7 @@ async fn clone_repo(
     Json(clone_args): Json<CloneArgs>,
 ) -> anyhow::Result<Json<Vec<Log>>> {
     let access_token = get_github_token(&clone_args.github_account, &config)?;
-    let logs = git::clone_repo(clone_args, &config.repo_dir, access_token).await?;
+    let logs = git::clone_repo(clone_args, config.repo_dir.clone(), access_token).await?;
     Ok(Json(logs))
 }
 
@@ -59,11 +57,8 @@ async fn delete_repo(
     Extension(config): PeripheryConfigExtension,
     Json(DeleteRepoBody { name }): Json<DeleteRepoBody>,
 ) -> anyhow::Result<Json<Log>> {
-    let mut repo_dir = PathBuf::from_str(&config.repo_dir)?;
     let name = to_monitor_name(&name);
-    repo_dir.push(&name);
-    let destination = repo_dir.display().to_string();
-    let deleted = std::fs::remove_dir_all(destination);
+    let deleted = std::fs::remove_dir_all(config.repo_dir.join(&name));
     let msg = match deleted {
         Ok(_) => format!("deleted repo {name}"),
         Err(_) => format!("no repo at {name} to delete"),
@@ -80,10 +75,7 @@ async fn pull_repo(
         on_pull,
     }): Json<PullBody>,
 ) -> anyhow::Result<Json<Vec<Log>>> {
-    let mut repo_dir = PathBuf::from_str(&config.repo_dir)?;
     let name = to_monitor_name(&name);
-    repo_dir.push(&name);
-    let path = repo_dir.display().to_string();
-    let logs = git::pull(&path, &branch, &on_pull).await;
+    let logs = git::pull(config.repo_dir.join(name), &branch, &on_pull).await;
     Ok(Json(logs))
 }