feat: start network docker container with cli

cmd/soroban-cli/Cargo.toml

@@ -106,6 +106,8 @@ ureq = {version = "2.9.1", features = ["json"]}
 tempfile = "3.8.1"
 toml_edit = "0.21.0"
 rust-embed = { version = "8.2.0", features = ["debug-embed"] }
+bollard = "0.15.0"
+futures-util = "0.3.30"
 # For hyper-tls
 [target.'cfg(unix)'.dependencies]
 openssl = { version = "0.10.55", features = ["vendored"] }

cmd/soroban-cli/src/commands/config/mod.rs

@@ -38,7 +38,7 @@ impl Cmd {
     pub async fn run(&self) -> Result<(), Error> {
         match &self {
             Cmd::Identity(identity) => identity.run().await?,
-            Cmd::Network(network) => network.run()?,
+            Cmd::Network(network) => network.run().await?,
         }
         Ok(())
     }

cmd/soroban-cli/src/commands/mod.rs

@@ -95,7 +95,7 @@ impl Root {
             Cmd::Contract(contract) => contract.run(&self.global_args).await?,
             Cmd::Events(events) => events.run().await?,
             Cmd::Lab(lab) => lab.run().await?,
-            Cmd::Network(network) => network.run()?,
+            Cmd::Network(network) => network.run().await?,
             Cmd::Version(version) => version.run(),
             Cmd::Keys(id) => id.run().await?,
             Cmd::Config(c) => c.run().await?,

cmd/soroban-cli/src/commands/network/mod.rs

@@ -15,6 +15,9 @@ use super::config::locator;
 pub mod add;
 pub mod ls;
 pub mod rm;
+pub mod shared;
+pub mod start;
+pub mod stop;
 
 #[derive(Debug, Parser)]
 pub enum Cmd {
@@ -24,6 +27,16 @@ pub enum Cmd {
     Rm(rm::Cmd),
     /// List networks
     Ls(ls::Cmd),
+    /// Start network
+    ///
+    /// This command allows for starting a stellar quickstart container. To run it, you can use the following command:
+    /// `soroban network start <NETWORK> [OPTIONS]`
+    ///
+    /// By default, when starting a testnet container, without any optional arguments, it will run the equivalent of the following docker command:
+    /// docker run --rm -p 8000:8000 --name stellar stellar/quickstart:testing --testnet --enable-soroban-rpc
+    Start(start::Cmd),
+    /// Stop network
+    Stop(stop::Cmd),
 }
 
 #[derive(thiserror::Error, Debug)]
@@ -37,6 +50,12 @@ pub enum Error {
     #[error(transparent)]
     Ls(#[from] ls::Error),
 
+    #[error(transparent)]
+    Start(#[from] start::Error),
+
+    #[error(transparent)]
+    Stop(#[from] stop::Error),
+
     #[error(transparent)]
     Config(#[from] locator::Error),
 
@@ -57,11 +76,13 @@ pub enum Error {
 }
 
 impl Cmd {
-    pub fn run(&self) -> Result<(), Error> {
+    pub async fn run(&self) -> Result<(), Error> {
         match self {
             Cmd::Add(cmd) => cmd.run()?,
             Cmd::Rm(new) => new.run()?,
             Cmd::Ls(cmd) => cmd.run()?,
+            Cmd::Start(cmd) => cmd.run().await?,
+            Cmd::Stop(cmd) => cmd.run().await?,
         };
         Ok(())
     }

cmd/soroban-cli/src/commands/network/shared.rs

@@ -0,0 +1,76 @@
+use core::fmt;
+
+use bollard::{ClientVersion, Docker};
+use clap::ValueEnum;
+
+pub const DOCKER_SOCKET_PATH_HELP: &str = "Optional argument to override the default docker socket path. This is useful when you are using a non-standard docker socket path for your Docker-compatible container runtime, e.g. Docker Desktop defaults to $HOME/.docker/run/docker.sock instead of /var/run/docker.sock";
+
+// DEFAULT_TIMEOUT and API_DEFAULT_VERSION are from the bollard crate
+const DEFAULT_TIMEOUT: u64 = 120;
+const API_DEFAULT_VERSION: &ClientVersion = &ClientVersion {
+    major_version: 1,
+    minor_version: 40,
+};
+
+#[derive(ValueEnum, Debug, Clone, PartialEq)]
+pub enum Network {
+    Local,
+    Testnet,
+    Futurenet,
+    Pubnet,
+}
+
+impl fmt::Display for Network {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let variant_str = match self {
+            Network::Local => "local",
+            Network::Testnet => "testnet",
+            Network::Futurenet => "futurenet",
+            Network::Pubnet => "pubnet",
+        };
+
+        write!(f, "{variant_str}")
+    }
+}
+
+pub async fn connect_to_docker(
+    docker_socket_path: &Option<String>,
+) -> Result<Docker, bollard::errors::Error> {
+    let docker = if docker_socket_path.is_some() {
+        let socket = docker_socket_path.as_ref().unwrap();
+        let connection = Docker::connect_with_socket(socket, DEFAULT_TIMEOUT, API_DEFAULT_VERSION)?;
+        check_docker_connection(&connection).await?;
+        connection
+    } else {
+        let connection = Docker::connect_with_socket_defaults()?;
+        check_docker_connection(&connection).await?;
+        connection
+    };
+    Ok(docker)
+}
+
+// When bollard is not able to connect to the docker daemon, it returns a generic ConnectionRefused error
+// This method attempts to connect to the docker daemon and returns a more specific error message
+pub async fn check_docker_connection(docker: &Docker) -> Result<(), bollard::errors::Error> {
+    // This is a bit hacky, but the `client_addr` field is not directly accessible from the `Docker` struct, but we can access it from the debug string representation of the `Docker` struct
+    let docker_debug_string = format!("{docker:#?}");
+    let start_of_client_addr = docker_debug_string.find("client_addr: ").unwrap();
+    let end_of_client_addr = docker_debug_string[start_of_client_addr..]
+        .find(',')
+        .unwrap();
+    // Extract the substring containing the value of client_addr
+    let client_addr = &docker_debug_string
+        [start_of_client_addr + "client_addr: ".len()..start_of_client_addr + end_of_client_addr]
+        .trim()
+        .trim_matches('"');
+
+    match docker.version().await {
+        Ok(_version) => Ok(()),
+        Err(err) => {
+            println!(
+                "⛔️ Failed to connect to the Docker daemon at {client_addr:?}. Is the docker daemon running?\nℹ️  Running a local Stellar network requires a Docker-compatible container runtime.\nℹ️  Please note that if you are using Docker Desktop, you may need to utilize the `--docker-socket-path` flag to pass in the location of the docker socket on your machine.\n"
+            );
+            Err(err)
+        }
+    }
+}