refactor: Move command execution to run functions

Author: tomasol

src/command/component.rs

@@ -1,12 +1,59 @@
 use crate::FunctionMetadataVerbosity;
 use crate::FunctionRepositoryClient;
+use crate::args;
+use crate::get_fn_repository_client;
+use crate::oci;
 use anyhow::Context;
 use concepts::ComponentType;
 use concepts::{FunctionFqn, FunctionMetadata};
 use grpc::grpc_gen;
 use std::path::PathBuf;
 use utils::wasm_tools::WasmComponent;
 
+impl args::Component {
+    pub(crate) async fn run(self, api_url: &str) -> Result<(), anyhow::Error> {
+        match self {
+            args::Component::Inspect {
+                path,
+                component_type,
+                imports,
+                extensions,
+                convert_core_module,
+            } => {
+                inspect(
+                    path,
+                    component_type,
+                    if imports {
+                        FunctionMetadataVerbosity::ExportsAndImports
+                    } else {
+                        FunctionMetadataVerbosity::ExportsOnly
+                    },
+                    extensions,
+                    convert_core_module,
+                )
+                .await
+            }
+            args::Component::List {
+                imports,
+                extensions,
+            } => {
+                let client = get_fn_repository_client(api_url).await?;
+                list_components(
+                    client,
+                    if imports {
+                        FunctionMetadataVerbosity::ExportsAndImports
+                    } else {
+                        FunctionMetadataVerbosity::ExportsOnly
+                    },
+                    extensions,
+                )
+                .await
+            }
+            args::Component::Push { path, image_name } => oci::push(path, &image_name).await,
+        }
+    }
+}
+
 pub(crate) async fn inspect(
     wasm_path: PathBuf,
     component_type: ComponentType,

src/command/execution.rs

@@ -1,4 +1,7 @@
 use crate::ExecutionRepositoryClient;
+use crate::args;
+use crate::args::params::parse_params;
+use crate::get_execution_repository_client;
 use crate::get_fn_repository_client;
 use anyhow::bail;
 use chrono::DateTime;
@@ -15,6 +18,54 @@ use serde_json::json;
 use std::time::Duration;
 use tracing::instrument;
 
+impl args::Execution {
+    pub(crate) async fn run(self, api_url: &str) -> Result<(), anyhow::Error> {
+        match self {
+            args::Execution::Submit {
+                ffqn,
+                params,
+                follow,
+                json,
+                no_reconnect,
+            } => {
+                let client = get_execution_repository_client(api_url).await?;
+                let opts = if json {
+                    SubmitOutputOpts::Json
+                } else {
+                    SubmitOutputOpts::Plain { no_reconnect }
+                };
+                submit(client, ffqn, parse_params(params)?, follow, opts, api_url).await
+            }
+            args::Execution::Stub(args::Stub {
+                execution_id,
+                return_value,
+            }) => {
+                let client = get_execution_repository_client(api_url).await?;
+                stub(client, execution_id, return_value).await
+            }
+            args::Execution::Get {
+                execution_id,
+                follow,
+                no_reconnect,
+            } => {
+                let client = get_execution_repository_client(api_url).await?;
+                let opts = GetStatusOptions {
+                    follow,
+                    no_reconnect,
+                };
+                get_status(client, execution_id, opts).await
+            }
+            args::Execution::GetJson {
+                follow,
+                execution_id,
+            } => {
+                let client = get_execution_repository_client(api_url).await?;
+                get_status_json(client, execution_id, follow, false).await
+            }
+        }
+    }
+}
+
 #[derive(PartialEq)]
 pub(crate) enum SubmitOutputOpts {
     Json,

src/command/generate.rs

@@ -1,3 +1,4 @@
+use crate::args::Generate;
 use crate::{args::shadow::PKG_VERSION, config::toml::ConfigToml};
 use anyhow::Context;
 use concepts::ComponentType;
@@ -10,6 +11,30 @@ use std::{
 };
 use utils::{wasm_tools::WasmComponent, wit};
 
+impl Generate {
+    pub(crate) async fn run(self) -> Result<(), anyhow::Error> {
+        match self {
+            Generate::ConfigSchema { output } => generate_toml_schema(output),
+            Generate::Extensions {
+                component_type,
+                input_wit_directory,
+                output_directory,
+            } => {
+                generate_exported_extension_wits(
+                    input_wit_directory,
+                    output_directory,
+                    component_type,
+                )
+                .await
+            }
+            Generate::WitSupport {
+                component_type,
+                output_directory,
+            } => generate_support_wits(component_type, output_directory).await,
+        }
+    }
+}
+
 pub(crate) fn generate_toml_schema(output: Option<PathBuf>) -> Result<(), anyhow::Error> {
     let schema = schema_for!(ConfigToml);
     if let Some(output) = output {

src/command/server.rs

@@ -1,3 +1,4 @@
+use crate::args::Server;
 use crate::config::ComponentConfig;
 use crate::config::ComponentConfigImportable;
 use crate::config::ComponentLocation;
@@ -26,6 +27,7 @@ use crate::config::toml::webhook::WebhookRoute;
 use crate::config::toml::webhook::WebhookRouteVerified;
 use crate::init;
 use crate::init::Guard;
+use crate::project_dirs;
 use anyhow::Context;
 use anyhow::bail;
 use chrono::DateTime;
@@ -144,6 +146,55 @@ const GET_STATUS_POLLING_SLEEP: Duration = Duration::from_secs(1);
 
 type ComponentSourceMap = hashbrown::HashMap<ComponentId, MatchableSourceMap>;
 
+impl Server {
+    pub(crate) async fn run(self) -> Result<(), anyhow::Error> {
+        match self {
+            Server::Run {
+                clean_sqlite_directory,
+                clean_cache,
+                clean_codegen_cache,
+                config,
+            } => {
+                Box::pin(run(
+                    project_dirs(),
+                    BaseDirs::new(),
+                    config,
+                    RunParams {
+                        clean_sqlite_directory,
+                        clean_cache,
+                        clean_codegen_cache,
+                    },
+                ))
+                .await
+            }
+            Server::GenerateConfig => {
+                let obelisk_toml = PathBuf::from("obelisk.toml");
+                ConfigHolder::generate_default_config(&obelisk_toml).await?;
+                println!("Generated {obelisk_toml:?}");
+                Ok(())
+            }
+            Server::Verify {
+                clean_cache,
+                clean_codegen_cache,
+                config,
+                ignore_missing_env_vars,
+            } => {
+                verify(
+                    project_dirs(),
+                    BaseDirs::new(),
+                    config,
+                    VerifyParams {
+                        clean_cache,
+                        clean_codegen_cache,
+                        ignore_missing_env_vars,
+                    },
+                )
+                .await
+            }
+        }
+    }
+}
+
 #[derive(derive_more::Debug)]
 struct GrpcServer {
     #[debug(skip)]
@@ -2543,8 +2594,8 @@ impl MatchableSourceMap {
 #[cfg(test)]
 mod tests {
     use crate::{
-        ConfigHolder,
         command::server::{ServerCompiledLinked, ServerVerified, VerifyParams},
+        config::config_holder::ConfigHolder,
     };
     use directories::BaseDirs;
     use rstest::rstest;