add follow option to log command

src/args.rs

@@ -36,6 +36,7 @@ pub enum HazeArgs {
     Clean,
     Logs {
         filter: Option<String>,
+        follow: bool,
         service: Option<LogService>,
         count: Option<usize>,
     },
@@ -168,15 +169,13 @@ impl HazeArgs {
             HazeCommand::Clean => Ok(HazeArgs::Clean),
             HazeCommand::Logs => {
                 let mut args = args.peekable();
+                let follow = args.next_if(|arg| arg.as_ref() == "-f").is_some();
                 let service = args
-                    .peek()
-                    .map(|s| s.as_ref())
-                    .and_then(LogService::from_type);
-                if service.is_some() {
-                    let _ = args.next();
-                }
+                    .next_if(|arg| LogService::from_type(arg.as_ref()).is_some())
+                    .and_then(|arg| LogService::from_type(arg.as_ref()));
                 Ok(HazeArgs::Logs {
                     filter,
+                    follow,
                     service,
                     count: args
                         .next()
@@ -312,4 +311,22 @@ fn test_arg_parse() {
             args: vec!["foo".into(), "bar".into()]
         }
     );
+    assert_eq!(
+        HazeArgs::parse(vec!["haze", "logs", "-f", "smb"].into_iter()).unwrap(),
+        HazeArgs::Logs {
+            filter: None,
+            follow: true,
+            service: Some(LogService::from_type("smb").unwrap()),
+            count: None,
+        }
+    );
+    assert_eq!(
+        HazeArgs::parse(vec!["haze", "asdasd", "logs", "smb", "123"].into_iter()).unwrap(),
+        HazeArgs::Logs {
+            filter: Some("asdasd".to_string()),
+            follow: false,
+            service: Some(LogService::from_type("smb").unwrap()),
+            count: Some(123),
+        }
+    );
 }

src/exec.rs

@@ -145,21 +145,28 @@ pub async fn exec<S1: AsRef<str>, S2: Into<String>>(
         .into())
 }
 
-pub async fn container_logs(docker: &Docker, container: &str, count: usize) -> Result<Vec<String>> {
-    let mut logs = Vec::new();
+pub async fn container_logs(
+    docker: &Docker,
+    mut std_out: impl Write,
+    container: &str,
+    count: usize,
+    follow: bool,
+) -> Result<()> {
     let mut stream = docker.logs::<String>(
         container,
         Some(LogsOptions {
             stdout: true,
             stderr: true,
+            follow,
             tail: format!("{}", count),
             ..Default::default()
         }),
     );
     while let Some(line) = stream.next().await {
-        logs.push(line.into_diagnostic()?.to_string());
+        let line = line.into_diagnostic()?.to_string();
+        write!(&mut std_out, "{}", line).into_diagnostic()?;
     }
-    Ok(logs)
+    Ok(())
 }
 
 pub struct ExitCode(i64);

src/main.rs

@@ -8,6 +8,7 @@ use crate::service::Service;
 use crate::service::ServiceTrait;
 use bollard::Docker;
 use miette::{IntoDiagnostic, Result, WrapErr};
+use std::io::stdout;
 
 mod args;
 mod cloud;
@@ -154,6 +155,7 @@ async fn main() -> Result<()> {
         }
         HazeArgs::Logs {
             filter,
+            follow,
             count,
             service,
         } => {
@@ -163,10 +165,7 @@ async fn main() -> Result<()> {
             } else {
                 cloud.id
             };
-            let logs = container_logs(&docker, &container, count.unwrap_or(20)).await?;
-            for log in logs {
-                print!("{}", log);
-            }
+            container_logs(&docker, stdout(), &container, count.unwrap_or(20), follow).await?;
         }
         HazeArgs::Exec {
             filter,