service logs

src/args.rs

@@ -1,4 +1,5 @@
 use crate::cloud::CloudOptions;
+use crate::service::Service;
 use color_eyre::{Report, Result};
 use parse_display::Display;
 use std::fmt::Display;
@@ -33,6 +34,7 @@ pub enum HazeArgs {
     Clean,
     Logs {
         filter: Option<String>,
+        service: Option<Service>,
         count: Option<usize>,
     },
     Open {
@@ -104,10 +106,22 @@ impl HazeArgs {
             }),
             HazeCommand::Db => Ok(HazeArgs::Db { filter }),
             HazeCommand::Clean => Ok(HazeArgs::Clean),
-            HazeCommand::Logs => Ok(HazeArgs::Logs {
+            HazeCommand::Logs => {
-                filter,
+                let mut args = args.peekable();
-                count: args.next().map(|arg| arg.as_ref().parse()).transpose()?,
+                let service = args
-            }),
+                    .peek()
+                    .map(|s| s.as_ref())
+                    .map(Service::from_type)
+                    .flatten();
+                if service.is_some() {
+                    let _ = args.next();
+                }
+                Ok(HazeArgs::Logs {
+                    filter,
+                    service,
+                    count: args.next().map(|arg| arg.as_ref().parse()).transpose()?,
+                })
+            }
             HazeCommand::Open => Ok(HazeArgs::Open { filter }),
         }
     }

src/cloud.rs

@@ -4,14 +4,13 @@ use crate::exec::{exec, exec_tty};
 use crate::mapping::default_mappings;
 use crate::php::PhpVersion;
 use crate::service::Service;
-use bollard::container::{ListContainersOptions, LogsOptions, RemoveContainerOptions};
+use bollard::container::{ListContainersOptions, RemoveContainerOptions};
 use bollard::models::ContainerState;
 use bollard::network::CreateNetworkOptions;
 use bollard::Docker;
 use camino::Utf8PathBuf;
 use color_eyre::{eyre::WrapErr, Report, Result};
 use futures_util::future::try_join_all;
-use futures_util::stream::StreamExt;
 use petname::petname;
 use std::collections::HashMap;
 use std::fmt::Display;
@@ -61,11 +60,11 @@ impl CloudOptions {
             }
         }
 
-        Ok(dbg!(CloudOptions {
+        Ok(CloudOptions {
             db: db.unwrap_or_default(),
             php: php.unwrap_or_default(),
             services,
-        }))
+        })
     }
 }
 
@@ -269,23 +268,6 @@ impl Cloud {
         Ok(())
     }
 
-    pub async fn logs(&self, docker: &mut Docker, count: usize) -> Result<Vec<String>> {
-        let mut logs = Vec::new();
-        let mut stream = docker.logs::<String>(
-            &self.id,
-            Some(LogsOptions {
-                stdout: true,
-                stderr: true,
-                tail: format!("{}", count),
-                ..Default::default()
-            }),
-        );
-        while let Some(line) = stream.next().await {
-            logs.push(line?.to_string());
-        }
-        Ok(logs)
-    }
-
     pub async fn exec<S: Into<String>>(
         &self,
         docker: &mut Docker,

src/exec.rs

@@ -1,3 +1,4 @@
+use bollard::container::LogsOptions;
 use bollard::exec::{CreateExecOptions, StartExecResults};
 use bollard::Docker;
 use color_eyre::{eyre::WrapErr, Result};
@@ -119,3 +120,20 @@ pub async fn exec<S1: AsRef<str>, S2: Into<String>>(
         .exit_code
         .unwrap_or_default())
 }
+
+pub async fn container_logs(docker: &Docker, container: &str, count: usize) -> Result<Vec<String>> {
+    let mut logs = Vec::new();
+    let mut stream = docker.logs::<String>(
+        container,
+        Some(LogsOptions {
+            stdout: true,
+            stderr: true,
+            tail: format!("{}", count),
+            ..Default::default()
+        }),
+    );
+    while let Some(line) = stream.next().await {
+        logs.push(line?.to_string());
+    }
+    Ok(logs)
+}

src/main.rs

@@ -1,6 +1,7 @@
 use crate::args::HazeArgs;
 use crate::cloud::Cloud;
 use crate::config::HazeConfig;
+use crate::exec::container_logs;
 use crate::service::Service;
 use bollard::Docker;
 use color_eyre::{eyre::WrapErr, Result};
@@ -94,9 +95,18 @@ async fn main() -> Result<()> {
             let cloud = Cloud::get_by_filter(&mut docker, filter, &config).await?;
             cloud.destroy(&mut docker).await?;
         }
-        HazeArgs::Logs { filter, count } => {
+        HazeArgs::Logs {
+            filter,
+            count,
+            service,
+        } => {
             let cloud = Cloud::get_by_filter(&mut docker, filter, &config).await?;
-            let logs = cloud.logs(&mut docker, count.unwrap_or(20)).await?;
+            let container = if let Some(service) = service {
+                service.container_name(&cloud.id)
+            } else {
+                cloud.id
+            };
+            let logs = container_logs(&docker, &container, count.unwrap_or(20)).await?;
             for log in logs {
                 print!("{}", log);
             }

src/service.rs

@@ -54,6 +54,12 @@ impl Service {
         .await
         .wrap_err("Timeout after 15 seconds")?
     }
+
+    pub fn container_name(&self, cloud_id: &str) -> String {
+        match self {
+            Service::ObjectStore(store) => store.container_name(cloud_id),
+        }
+    }
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -120,4 +126,8 @@ impl ObjectStore {
     async fn is_healthy(&self, _docker: &Docker, _cloud_id: &str) -> Result<bool> {
         Ok(true)
     }
+
+    fn container_name(&self, cloud_id: &str) -> String {
+        format!("{}-object", cloud_id)
+    }
 }