move cloud list into struct

src/cloud.rs

@@ -290,6 +290,86 @@ impl Cloud {
     pub async fn exec(&self, docker: &mut Docker, cmd: Vec<String>) -> Result<()> {
         exec_tty(docker, &self.id, "haze", cmd, vec![]).await
     }
+
+    pub async fn list(
+        docker: &mut Docker,
+        filter: Option<String>,
+        config: &HazeConfig,
+    ) -> Result<Vec<Cloud>> {
+        let containers = docker
+            .list_containers::<String>(Some(ListContainersOptions {
+                all: true,
+                ..Default::default()
+            }))
+            .await?;
+        let mut containers_by_id: HashMap<String, (Option<_>, Vec<_>)> = HashMap::new();
+        for container in containers {
+            let labels = container.labels.clone().unwrap_or_default();
+            if let Some(cloud_id) = labels.get("haze-cloud-id") {
+                if match filter.as_ref() {
+                    Some(filter) => cloud_id.contains(filter),
+                    None => true,
+                } {
+                    let mut entry = containers_by_id.entry(cloud_id.to_string()).or_default();
+                    if labels.get("haze-type").map(String::as_str) == Some("cloud") {
+                        entry.0 = Some(container);
+                    } else {
+                        entry.1.push(container)
+                    }
+                }
+            }
+        }
+
+        let mut sortable_containers: Vec<_> = containers_by_id
+            .into_iter()
+            .filter_map(|(id, (cloud, services))| {
+                let cloud = cloud?;
+                let network = id.clone();
+                let networks = cloud.network_settings?.networks?;
+                let network_info = networks.get(&network)?;
+                let workdir = config.work_dir.join(&id);
+                let labels = cloud.labels?;
+                let db = labels.get("haze-db")?.parse().ok()?;
+                let php = labels.get("haze-php")?.parse().ok()?;
+                let mut service_ids: Vec<String> = services
+                    .iter()
+                    .filter_map(|service| service.names.as_ref()?.first().map(String::clone))
+                    .collect();
+                service_ids.push(id.clone());
+                Some((
+                    cloud.created.unwrap_or_default(),
+                    Cloud {
+                        id,
+                        network,
+                        db,
+                        php,
+                        containers: service_ids,
+                        ip: network_info.ip_address.as_ref()?.parse().ok(),
+                        workdir,
+                    },
+                ))
+            })
+            .collect();
+
+        sortable_containers.sort_by(|a, b| a.0.cmp(&b.0).reverse());
+
+        Ok(sortable_containers
+            .into_iter()
+            .map(|(_created, cloud)| cloud)
+            .collect())
+    }
+
+    pub async fn get_by_filter(
+        docker: &mut Docker,
+        filter: Option<String>,
+        config: &HazeConfig,
+    ) -> Result<Cloud> {
+        Cloud::list(docker, filter, config)
+            .await?
+            .into_iter()
+            .next()
+            .ok_or(Report::msg("No clouds running matching filter"))
+    }
 }
 
 async fn setup_workdir(base: &Utf8Path, id: &str) -> Result<Utf8PathBuf> {
@@ -310,83 +390,3 @@ async fn setup_workdir(base: &Utf8Path, id: &str) -> Result<Utf8PathBuf> {
 
     Ok(workdir)
 }
-
-pub async fn list(
-    docker: &mut Docker,
-    filter: Option<String>,
-    config: &HazeConfig,
-) -> Result<Vec<Cloud>> {
-    let containers = docker
-        .list_containers::<String>(Some(ListContainersOptions {
-            all: true,
-            ..Default::default()
-        }))
-        .await?;
-    let mut containers_by_id: HashMap<String, (Option<_>, Vec<_>)> = HashMap::new();
-    for container in containers {
-        let labels = container.labels.clone().unwrap_or_default();
-        if let Some(cloud_id) = labels.get("haze-cloud-id") {
-            if match filter.as_ref() {
-                Some(filter) => cloud_id.contains(filter),
-                None => true,
-            } {
-                let mut entry = containers_by_id.entry(cloud_id.to_string()).or_default();
-                if labels.get("haze-type").map(String::as_str) == Some("cloud") {
-                    entry.0 = Some(container);
-                } else {
-                    entry.1.push(container)
-                }
-            }
-        }
-    }
-
-    let mut sortable_containers: Vec<_> = containers_by_id
-        .into_iter()
-        .filter_map(|(id, (cloud, services))| {
-            let cloud = cloud?;
-            let network = id.clone();
-            let networks = cloud.network_settings?.networks?;
-            let network_info = networks.get(&network)?;
-            let workdir = config.work_dir.join(&id);
-            let labels = cloud.labels?;
-            let db = labels.get("haze-db")?.parse().ok()?;
-            let php = labels.get("haze-php")?.parse().ok()?;
-            let mut service_ids: Vec<String> = services
-                .iter()
-                .filter_map(|service| service.names.as_ref()?.first().map(String::clone))
-                .collect();
-            service_ids.push(id.clone());
-            Some((
-                cloud.created.unwrap_or_default(),
-                Cloud {
-                    id,
-                    network,
-                    db,
-                    php,
-                    containers: service_ids,
-                    ip: network_info.ip_address.as_ref()?.parse().ok(),
-                    workdir,
-                },
-            ))
-        })
-        .collect();
-
-    sortable_containers.sort_by(|a, b| a.0.cmp(&b.0).reverse());
-
-    Ok(sortable_containers
-        .into_iter()
-        .map(|(_created, cloud)| cloud)
-        .collect())
-}
-
-pub async fn get_by_filter(
-    docker: &mut Docker,
-    filter: Option<String>,
-    config: &HazeConfig,
-) -> Result<Cloud> {
-    list(docker, filter, config)
-        .await?
-        .into_iter()
-        .next()
-        .ok_or(Report::msg("No clouds running matching filter"))
-}

src/main.rs

@@ -1,5 +1,5 @@
 use crate::args::{HazeArgs, HazeCommand};
-use crate::cloud::{get_by_filter, list, Cloud, CloudOptions};
+use crate::cloud::{Cloud, CloudOptions};
 use crate::config::HazeConfig;
 use bollard::Docker;
 use color_eyre::{eyre::WrapErr, Report, Result};
@@ -22,7 +22,7 @@ async fn main() -> Result<()> {
 
     match args.command {
         HazeCommand::Clean => {
-            let list = list(&mut docker, None, &config).await?;
+            let list = Cloud::list(&mut docker, None, &config).await?;
             for cloud in list {
                 if let Err(e) = cloud.destroy(&mut docker).await {
                     eprintln!("Error while removing cloud: {:#}", e);
@@ -30,7 +30,7 @@ async fn main() -> Result<()> {
             }
         }
         HazeCommand::List => {
-            let list = list(&mut docker, args.options.first().cloned(), &config).await?;
+            let list = Cloud::list(&mut docker, args.options.first().cloned(), &config).await?;
             for cloud in list {
                 if let Some(filter) = &args.id {
                     if !cloud.id.contains(filter.as_str()) {
@@ -63,18 +63,18 @@ async fn main() -> Result<()> {
             println!("http://{}", cloud.ip.unwrap());
         }
         HazeCommand::Stop => {
-            let cloud = get_by_filter(&mut docker, args.id, &config).await?;
+            let cloud = Cloud::get_by_filter(&mut docker, args.id, &config).await?;
             cloud.destroy(&mut docker).await?;
         }
         HazeCommand::Logs => {
-            let cloud = get_by_filter(&mut docker, args.id, &config).await?;
+            let cloud = Cloud::get_by_filter(&mut docker, args.id, &config).await?;
             let logs = cloud.logs(&mut docker).await?;
             for log in logs {
                 print!("{}", log);
             }
         }
         HazeCommand::Exec => {
-            let cloud = get_by_filter(&mut docker, args.id, &config).await?;
+            let cloud = Cloud::get_by_filter(&mut docker, args.id, &config).await?;
             cloud
                 .exec(
                     &mut docker,
@@ -87,17 +87,17 @@ async fn main() -> Result<()> {
                 .await?;
         }
         HazeCommand::Occ => {
-            let cloud = get_by_filter(&mut docker, args.id, &config).await?;
+            let cloud = Cloud::get_by_filter(&mut docker, args.id, &config).await?;
             let mut options = args.options;
             options.insert(0, "occ".to_string());
             cloud.exec(&mut docker, options).await?;
         }
         HazeCommand::Db => {
-            let cloud = get_by_filter(&mut docker, args.id, &config).await?;
+            let cloud = Cloud::get_by_filter(&mut docker, args.id, &config).await?;
             cloud.db.exec(&mut docker, &cloud.id).await?;
         }
         HazeCommand::Open => {
-            let cloud = get_by_filter(&mut docker, args.id, &config).await?;
+            let cloud = Cloud::get_by_filter(&mut docker, args.id, &config).await?;
             match cloud.ip {
                 Some(ip) => opener::open(format!("http://{}", ip))?,
                 None => eprintln!("{} is not running", cloud.id),