chore: use one-shot for init

Author: queil

Cargo.lock

@@ -1,13 +1,12 @@
 [package]
 name = "rooz"
-version = "0.128.0"
+version = "0.129.0"
 edition = "2021"
 
 [dependencies]
 age = {version = "0.11.1", features = ["armor"] }
 base64 = "0.22.1"
 bollard = { version = "0.19.2" }
-#bollard = { git = "https://github.com/fussybeaver/bollard", rev = "e785084893d6763dfa1a9c7e283c7ee9adde11eb"}
 bollard-stubs = "1.49.0-rc.28.3.3"
 clap = { version = "4.5.16", features = ["derive", "env"] }
 clap_complete = "4.5.24"

Cargo.toml

@@ -11,7 +11,6 @@ use crate::{
 use base64::{engine::general_purpose, Engine as _};
 
 use bollard::{
-    container::LogOutput::{Console, StdErr, StdOut},
     errors::Error::{self, DockerResponseServerError},
     models::{
         ContainerCreateBody, ContainerCreateResponse, ContainerInspectResponse, ContainerState,
@@ -26,11 +25,7 @@ use bollard::{
 };
 
 use futures::{future, StreamExt};
-use std::{
-    collections::HashMap,
-    io::{stderr, stdout, Write},
-    time::Duration,
-};
+use std::{collections::HashMap, time::Duration};
 use tokio::time::{sleep, timeout};
 
 pub fn inject2(script: &str, name: &str, post_sleep: bool) -> Vec<String> {
@@ -291,7 +286,6 @@ impl<'a> ContainerApi<'a> {
             RunMode::Git => (None, None, Some(true), Some(true)),
             RunMode::OneShot => (None, None, None, Some(true)),
             RunMode::Sidecar => (None, None, None, None),
-            RunMode::Init => (None, None, None, None),
         };
 
         let host_config = HostConfig {
@@ -556,25 +550,4 @@ impl<'a> ContainerApi<'a> {
         let _ = tokio::time::timeout(std::time::Duration::from_secs(2), log_task).await;
         Ok(exit_code)
     }
-
-    pub async fn logs_to_stdout(&self, container_name: &str) -> Result<(), AnyError> {
-        let log_options = LogsOptions {
-            stdout: true,
-            follow: true,
-            ..Default::default()
-        };
-
-        let mut stream = self.client.logs(&container_name, Some(log_options));
-
-        while let Some(l) = stream.next().await {
-            match l {
-                Ok(Console { message: m }) => stdout().write_all(&m)?,
-                Ok(StdOut { message: m }) => stdout().write_all(&m)?,
-                Ok(StdErr { message: m }) => stderr().write_all(&m)?,
-                Ok(msg) => panic!("{}", msg),
-                Err(e) => panic!("{}", e),
-            };
-        }
-        Ok(())
-    }
 }

src/api/container.rs

@@ -26,8 +26,6 @@ impl CryptApi {
         }
     }
 
-
-
     pub fn encrypt(
         &self,
         plaintext: String,

src/api/crypt.rs

@@ -31,8 +31,7 @@ pub struct VolumeApi<'a> {
     pub container: &'a ContainerApi<'a>,
 }
 
-pub struct CryptApi {
-}
+pub struct CryptApi {}
 
 pub struct Api<'a> {
     pub exec: &'a ExecApi<'a>,

src/api/mod.rs

@@ -1,61 +1,19 @@
 use std::str::FromStr;
 
 use crate::{
-    api::{container, Api},
+    api::Api,
     cli::InitParams,
     config::config::SystemConfig,
     constants,
     model::{
-        types::{AnyError, RunMode, RunSpec, VolumeResult},
+        types::{AnyError, VolumeResult},
         volume::{RoozVolume, RoozVolumeRole},
     },
-    util::{id, labels::Labels, ssh},
+    util::ssh,
 };
 use age::secrecy::ExposeSecret;
-use bollard::models::MountTypeEnum::VOLUME;
-use bollard::service::Mount;
 
 impl<'a> Api<'a> {
-    async fn execute_init(
-        &self,
-        container_name: &str,
-        entrypoint: &str,
-        vol_name: &str,
-        vol_mount_path: &str,
-        image: &str,
-    ) -> Result<(), AnyError> {
-        let workspace_key = id::random_suffix("init");
-        let entrypoint = container::inject(entrypoint, "entrypoint.sh");
-        let labels = Labels::default();
-        let run_spec = RunSpec {
-            reason: "init",
-            image,
-            uid: constants::ROOT_UID,
-            work_dir: None,
-            container_name,
-            workspace_key: &workspace_key,
-            mounts: Some(vec![Mount {
-                typ: Some(VOLUME),
-                read_only: Some(false),
-                source: Some(vol_name.into()),
-                target: Some(vol_mount_path.into()),
-                ..Default::default()
-            }]),
-            entrypoint: Some(entrypoint.iter().map(String::as_str).collect()),
-            privileged: false,
-            force_recreate: false,
-            run_mode: RunMode::Init,
-            labels,
-            ..Default::default()
-        };
-
-        let result = self.container.create(run_spec).await?;
-        self.container.start(result.id()).await?;
-        self.container.logs_to_stdout(result.id()).await?;
-        self.container.remove(result.id(), true).await?;
-        Ok(())
-    }
-
     pub async fn init(&self, image: &str, uid: &str, spec: &InitParams) -> Result<(), AnyError> {
         let image_id = self.image.ensure(&image, false).await?.id;
 
@@ -106,14 +64,15 @@ impl<'a> Api<'a> {
                     &hostname, &uid,
                 );
 
-                self.execute_init(
-                    "rooz-init-ssh",
-                    &init_ssh,
-                    ssh::VOLUME_NAME,
-                    "/tmp/.ssh",
-                    &image_id,
-                )
-                .await?;
+                self.container
+                    .one_shot(
+                        "init",
+                        init_ssh,
+                        Some(vec![ssh::mount("/tmp/.ssh")]),
+                        None,
+                        Some(&image_id),
+                    )
+                    .await?;
             }
             VolumeResult::AlreadyExists => {
                 println!("Rooz has been already initialized. Use --force to reinitialize.")

src/cmd/init.rs

@@ -33,7 +33,9 @@ impl<'a> WorkspaceApi<'a> {
             cfg_builder.from_config(c);
         }
         cfg_builder.from_cli(cli_params, None);
-        self.config.decrypt(cfg_builder, &self.api.system_config.age_identity()?).await?;
+        self.config
+            .decrypt(cfg_builder, &self.api.system_config.age_identity()?)
+            .await?;
         cfg_builder.expand_vars()?;
 
         let cfg = RuntimeConfig::from(&*cfg_builder);

src/cmd/new.rs

@@ -115,7 +115,7 @@ async fn main() -> Result<(), AnyError> {
         client: &docker,
     };
 
-    let crypt_api = CryptApi { };
+    let crypt_api = CryptApi {};
 
     let git_api = GitApi { api: &rooz };
 
@@ -159,9 +159,7 @@ async fn main() -> Result<(), AnyError> {
                     None => Ok(()),
                 }?;
 
-            workspace
-                .new(&name, &work, config_source, false,)
-                .await?;
+            workspace.new(&name, &work, config_source, false).await?;
             println!(
                 "\nThe workspace is ready. Run 'rooz enter {}' to enter.",
                 name

src/main.rs

@@ -78,7 +78,6 @@ pub enum RunMode {
     Git,
     OneShot,
     Sidecar,
-    Init,
 }
 
 pub struct RunSpec<'a> {