allow exec in db

src/args.rs

@@ -22,6 +22,7 @@ pub enum HazeArgs {
     },
     Exec {
         filter: Option<String>,
+        service: Option<ExecService>,
         command: Vec<String>,
     },
     Occ {
@@ -43,6 +44,11 @@ pub enum HazeArgs {
     },
 }
 
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum ExecService {
+    Db,
+}
+
 impl HazeArgs {
     pub fn parse<I, S>(mut args: I) -> Result<HazeArgs>
     where
@@ -94,10 +100,24 @@ impl HazeArgs {
                 let args = args.map(S::into).collect();
                 Ok(HazeArgs::Test { options, args })
             }
-            HazeCommand::Exec => Ok(HazeArgs::Exec {
+            HazeCommand::Exec => {
-                filter,
+                let mut args = args.peekable();
-                command: args.map(S::into).collect(),
+
-            }),
+                let service = match args.peek() {
+                    Some(arg) if arg == "db" => {
+                        args.next();
+                        Some(ExecService::Db)
+                    }
+                    _ => None,
+                };
+
+                let command = args.map(S::into).collect();
+                Ok(HazeArgs::Exec {
+                    filter,
+                    service,
+                    command,
+                })
+            }
             HazeCommand::Occ => Ok(HazeArgs::Occ {
                 filter,
                 command: args.map(S::into).collect(),
@@ -209,6 +229,7 @@ fn test_arg_parse() {
         HazeArgs::parse(vec!["haze", "exec", "foo", "bar"].into_iter()).unwrap(),
         HazeArgs::Exec {
             filter: None,
+            service: None,
             command: vec!["foo".to_string(), "bar".to_string()],
         }
     );
@@ -216,6 +237,15 @@ fn test_arg_parse() {
         HazeArgs::parse(vec!["haze", "asdasd", "exec", "foo", "bar"].into_iter()).unwrap(),
         HazeArgs::Exec {
             filter: Some("asdasd".to_string()),
+            service: None,
+            command: vec!["foo".to_string(), "bar".to_string()],
+        }
+    );
+    assert_eq!(
+        HazeArgs::parse(vec!["haze", "asdasd", "exec", "db", "foo", "bar"].into_iter()).unwrap(),
+        HazeArgs::Exec {
+            filter: Some("asdasd".to_string()),
+            service: Some("db".to_string()),
             command: vec!["foo".to_string(), "bar".to_string()],
         }
     );

src/database.rs

@@ -5,7 +5,7 @@ use bollard::models::{EndpointSettings, HostConfig};
 use bollard::Docker;
 use color_eyre::{eyre::WrapErr, Report, Result};
 use maplit::hashmap;
-use std::io::Stdout;
+use std::io::{stdout, Stdout};
 use std::str::FromStr;
 use std::time::Duration;
 use tokio::time::{sleep, timeout};
@@ -209,6 +209,24 @@ impl Database {
         Ok(Some(id))
     }
 
+    pub async fn exec_sh<S: Into<String>>(
+        &self,
+        docker: &mut Docker,
+        cloud_id: &str,
+        cmd: Vec<S>,
+        tty: bool,
+    ) -> Result<i64> {
+        let container = match self.family() {
+            DatabaseFamily::Sqlite => cloud_id.to_string(),
+            _ => format!("{}-db", cloud_id.to_string()),
+        };
+        if tty {
+            exec_tty(docker, &container, "root", cmd, vec![]).await
+        } else {
+            exec(docker, &container, "root", cmd, vec![], Some(stdout())).await
+        }
+    }
+
     pub async fn exec(&self, docker: &mut Docker, cloud_id: &str, root: bool) -> Result<i64> {
         match self.family() {
             DatabaseFamily::Sqlite => {

src/main.rs

@@ -1,4 +1,4 @@
-use crate::args::HazeArgs;
+use crate::args::{ExecService, HazeArgs};
 use crate::cloud::Cloud;
 use crate::config::HazeConfig;
 use crate::exec::container_logs;
@@ -111,19 +111,42 @@ async fn main() -> Result<()> {
                 print!("{}", log);
             }
         }
-        HazeArgs::Exec { filter, command } => {
+        HazeArgs::Exec {
+            filter,
+            service,
+            command,
+        } => {
             let cloud = Cloud::get_by_filter(&mut docker, filter, &config).await?;
-            cloud
+            match service {
-                .exec(
+                None => {
-                    &mut docker,
+                    cloud
-                    if command.is_empty() {
+                        .exec(
-                        vec!["bash".to_string()]
+                            &mut docker,
-                    } else {
+                            if command.is_empty() {
-                        command
+                                vec!["bash".to_string()]
-                    },
+                            } else {
-                    true,
+                                command
-                )
+                            },
-                .await?;
+                            true,
+                        )
+                        .await?;
+                }
+                Some(ExecService::Db) => {
+                    cloud
+                        .db
+                        .exec_sh(
+                            &mut docker,
+                            &cloud.id,
+                            if command.is_empty() {
+                                vec!["bash".to_string()]
+                            } else {
+                                command
+                            },
+                            true,
+                        )
+                        .await?;
+                }
+            }
         }
         HazeArgs::Occ {
             filter,