feat(cli): deploy-service

cli/src/main.rs

@@ -1,8 +1,11 @@
 use std::net::IpAddr;
 
 use clap::{Parser, Subcommand};
-use eyre::Ok;
-use proto::clients::CtlClient;
+use proto::{
+    clients::CtlClient,
+    common::service::{ResourceConfig, ServiceId, ServiceImage, ServiceSpec},
+    ctl::deployer::RedeploymentPolicy,
+};
 use tabled::{self, Table, Tabled};
 
 #[derive(Debug, Parser)]
@@ -39,25 +42,40 @@ pub enum WorkerCmd {
 #[derive(Debug, Subcommand)]
 pub enum ServiceCmd {
     List,
-    Show { id: String },
-    Deploy { id: String, image: String },
-    Terminate { id: String },
+    Show {
+        id: String,
+    },
+    Deploy {
+        #[arg(long)]
+        id: String,
+        #[arg(long)]
+        image: String,
+        #[arg(long)]
+        public: bool,
+        #[arg(long)]
+        concurrency: u32,
+        #[arg(long)]
+        cpu_shares: i64,
+        #[arg(long)]
+        memory_limit: i64,
+    },
+    Terminate {
+        id: String,
+    },
 }
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {
     let cli = Cli::parse();
     let ctl_client = CtlClient::new(cli.ctl_addr);
-
     match cli.cmd {
-        Cmd::Node(cmd) => handle_node(&cmd, ctl_client).await?,
-        Cmd::Service(cmd) => handle_service(&cmd)?,
+        Cmd::Node(cmd) => handle_node(cmd, ctl_client).await?,
+        Cmd::Service(cmd) => handle_service(cmd, ctl_client).await?,
     }
-
     Ok(())
 }
 
-async fn handle_node(cmd: &NodeCmd, ctl_client: CtlClient) -> eyre::Result<()> {
+async fn handle_node(cmd: NodeCmd, ctl_client: CtlClient) -> eyre::Result<()> {
     match cmd {
         NodeCmd::List => {
             let workers = ctl_client.query_workers().await.unwrap().workers;
@@ -69,11 +87,33 @@ async fn handle_node(cmd: &NodeCmd, ctl_client: CtlClient) -> eyre::Result<()> {
     }
 }
 
-fn handle_service(cmd: &ServiceCmd) -> eyre::Result<()> {
+async fn handle_service(cmd: ServiceCmd, ctl_client: CtlClient) -> eyre::Result<()> {
     match cmd {
         ServiceCmd::List => todo!(),
         ServiceCmd::Show { .. } => todo!(),
-        ServiceCmd::Deploy { .. } => todo!(),
+        ServiceCmd::Deploy {
+            id,
+            image,
+            public,
+            concurrency,
+            cpu_shares,
+            memory_limit,
+        } => {
+            let spec = ServiceSpec {
+                service_id: ServiceId(id),
+                image: ServiceImage(image),
+                public,
+                concurrency,
+                resource_config: ResourceConfig {
+                    cpu_shares,
+                    memory_limit: memory_limit * 1024 * 1024,
+                },
+            };
+            let rd = RedeploymentPolicy::None;
+            let res = ctl_client.deploy_service(spec, rd).await?;
+            println!("Successfully deployed service #{}", res.deployment_id);
+            Ok(())
+        }
         ServiceCmd::Terminate { .. } => todo!(),
     }
 }

ctl/src/deployer/mod.rs

@@ -13,7 +13,7 @@ use tokio::{
     sync::{mpsc, oneshot},
     task::JoinSet,
 };
-use tracing::{error, instrument, warn};
+use tracing::{debug, error, instrument, warn};
 use uuid::Uuid;
 
 use crate::{
@@ -110,6 +110,7 @@ impl Deployer {
     }
 
     async fn handle_deploy_service(&mut self, spec: ServiceSpec) -> eyre::Result<DeployServiceRes> {
+        debug!(?spec, "deploying service");
         let workers = self.h.worker_mgr.query_workers().await;
         let instances = alloc::rand_many(&workers, spec.concurrency);
         let deployment_id = DeploymentId(Uuid::now_v7());

proto/src/ctl/deployer.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, net::IpAddr};
+use std::{collections::HashMap, fmt, net::IpAddr};
 
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
@@ -14,6 +14,12 @@ pub struct RevisionId(pub Uuid);
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, Default)]
 pub struct DeploymentId(pub Uuid);
 
+impl fmt::Display for DeploymentId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 /// Starts a new deploy in the system.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct DeployServiceReq {

worker/src/runner/container_rt.rs

@@ -121,7 +121,7 @@ impl ContainerRuntime {
 
         let options = Some(CreateContainerOptions {
             name,
-            platform: Some("linux/x86_64".to_string()),
+            platform: None,
         });
         let create_response = self.docker.create_container(options, config).await?;