hook up node impleemntion to the cli

Author: kariy

crates/cli/src/full.rs

@@ -1,11 +1,18 @@
 use std::path::PathBuf;
 
-use anyhow::{anyhow, Result};
+use anyhow::{Context, Result};
 pub use clap::Parser;
+use katana_node::config::db::DbConfig;
+use katana_node::config::metrics::MetricsConfig;
+use katana_node::config::rpc::RpcConfig;
+use katana_node::full;
 use serde::{Deserialize, Serialize};
+use tracing::info;
 
 use crate::options::*;
 
+pub(crate) const LOG_TARGET: &str = "katana::cli::full";
+
 #[derive(Parser, Debug, Serialize, Deserialize, Default, Clone, PartialEq)]
 #[command(next_help_heading = "Full node options")]
 pub struct FullNodeArgs {
@@ -21,6 +28,11 @@ pub struct FullNodeArgs {
     #[arg(value_name = "PATH")]
     pub db_dir: Option<PathBuf>,
 
+    /// Gateway API key for accessing the sequencer gateway.
+    #[arg(long)]
+    #[arg(value_name = "KEY")]
+    pub gateway_api_key: Option<String>,
+
     #[command(flatten)]
     pub logging: LoggingOptions,
 
@@ -42,6 +54,95 @@ pub struct FullNodeArgs {
 
 impl FullNodeArgs {
     pub async fn execute(&self) -> Result<()> {
-        Err(anyhow!("Full node is not implemented yet!"))
+        // Initialize logging with tracer
+        let tracer_config = self.tracer_config();
+        katana_tracing::init(self.logging.log_format, tracer_config).await?;
+        self.start_node().await
+    }
+
+    async fn start_node(&self) -> Result<()> {
+        // Build the node
+        let config = self.config()?;
+        let node = full::Node::build(config).context("failed to build full node")?;
+
+        if !self.silent {
+            info!(target: LOG_TARGET, "Starting full node");
+        }
+
+        // Launch the node
+        let handle = node.launch().await.context("failed to launch full node")?;
+
+        // Wait until an OS signal (ie SIGINT, SIGTERM) is received or the node is shutdown.
+        tokio::select! {
+            _ = katana_utils::wait_shutdown_signals() => {
+                // Gracefully shutdown the node before exiting
+                handle.stop().await?;
+            },
+
+            _ = handle.stopped() => { }
+        }
+
+        info!("Shutting down.");
+
+        Ok(())
+    }
+
+    fn config(&self) -> Result<full::Config> {
+        let db = self.db_config();
+        let rpc = self.rpc_config()?;
+        let metrics = self.metrics_config();
+
+        Ok(full::Config { db, rpc, metrics, gateway_api_key: self.gateway_api_key.clone() })
+    }
+
+    fn db_config(&self) -> DbConfig {
+        DbConfig { dir: self.db_dir.clone() }
+    }
+
+    fn rpc_config(&self) -> Result<RpcConfig> {
+        #[cfg(feature = "server")]
+        {
+            use std::time::Duration;
+
+            let cors_origins = self.server.http_cors_origins.clone();
+
+            Ok(RpcConfig {
+                apis: Default::default(),
+                port: self.server.http_port,
+                addr: self.server.http_addr,
+                max_connections: self.server.max_connections,
+                max_concurrent_estimate_fee_requests: None,
+                max_request_body_size: None,
+                max_response_body_size: None,
+                timeout: self.server.timeout.map(Duration::from_secs),
+                cors_origins,
+                #[cfg(feature = "explorer")]
+                explorer: self.explorer.explorer,
+                max_event_page_size: Some(self.server.max_event_page_size),
+                max_proof_keys: Some(self.server.max_proof_keys),
+                max_call_gas: Some(self.server.max_call_gas),
+            })
+        }
+
+        #[cfg(not(feature = "server"))]
+        {
+            Ok(RpcConfig::default())
+        }
+    }
+
+    fn metrics_config(&self) -> Option<MetricsConfig> {
+        #[cfg(feature = "server")]
+        if self.metrics.metrics {
+            Some(MetricsConfig { addr: self.metrics.metrics_addr, port: self.metrics.metrics_port })
+        } else {
+            None
+        }
+
+        #[cfg(not(feature = "server"))]
+        None
+    }
+
+    fn tracer_config(&self) -> Option<katana_tracing::TracerConfig> {
+        self.tracer.config()
     }
 }