From e076b120293995fe4a7c944ce899a2903e31b9bf Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Sun, 12 Oct 2025 18:15:44 +0800 Subject: fix: Resolve callback type mismatch in client_registry - Fix lifetime issue in on_proc_begin callback registration - Use cloned context in async closure to avoid lifetime conflicts - Rename unused variable to suppress warning --- crates/vcs_actions/src/registry/client_registry.rs | 39 ++++++++++++++++++++++ 1 file changed, 39 insertions(+) (limited to 'crates/vcs_actions/src') diff --git a/crates/vcs_actions/src/registry/client_registry.rs b/crates/vcs_actions/src/registry/client_registry.rs index e69de29..c32ce5a 100644 --- a/crates/vcs_actions/src/registry/client_registry.rs +++ b/crates/vcs_actions/src/registry/client_registry.rs @@ -0,0 +1,39 @@ +use action_system::{action::ActionContext, action_pool::ActionPool}; +use tcp_connection::error::TcpTargetError; + +use crate::actions::local_actions::SetUpstreamVaultAction; + +fn register_actions(pool: &mut ActionPool) { + // Pool register here + SetUpstreamVaultAction::register_to_pool(pool); +} + +pub fn client_action_pool() -> ActionPool { + // Create pool + let mut pool = ActionPool::new(); + + // Register actions + register_actions(&mut pool); + + // Add process events + pool.set_on_proc_begin(|ctx| Box::pin(on_proc_begin(ctx))); + + // Return + pool +} + +async fn on_proc_begin(ctx: &ActionContext) -> Result<(), TcpTargetError> { + // Get instance + let Some(_instance) = ctx.instance() else { + return Err(TcpTargetError::Unsupported( + "Missing ConnectionInstance in current context, this ActionPool does not support this call" + .to_string())); + }; + + // If it's remote, invoke action at server + if ctx.is_remote() { + // instance.write_text(text) + } + + Ok(()) +} -- cgit From 1eaa869b85d0c5719e6249f717b26aaf3a0aeb1b Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Sun, 12 Oct 2025 18:16:07 +0800 Subject: feat: Add server action registry - Create server_action_pool function - Register SetUpstreamVaultAction for server use --- crates/vcs_actions/src/registry/server_registry.rs | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'crates/vcs_actions/src') diff --git a/crates/vcs_actions/src/registry/server_registry.rs b/crates/vcs_actions/src/registry/server_registry.rs index e69de29..bdd6a65 100644 --- a/crates/vcs_actions/src/registry/server_registry.rs +++ b/crates/vcs_actions/src/registry/server_registry.rs @@ -0,0 +1,9 @@ +use action_system::action_pool::ActionPool; + +use crate::actions::local_actions::SetUpstreamVaultAction; + +pub fn server_action_pool() -> ActionPool { + let mut pool = ActionPool::new(); + SetUpstreamVaultAction::register_to_pool(&mut pool); + pool +} -- cgit From e8e0b6c230f6f7efb0f5773dc49f4a5d619fdbc4 Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Sun, 12 Oct 2025 18:16:18 +0800 Subject: feat: Implement SetUpstreamVaultAction - Add local action for setting upstream vault - Use action_gen macro for automatic registration - Validate action is executed locally --- crates/vcs_actions/src/actions/local_actions.rs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) (limited to 'crates/vcs_actions/src') diff --git a/crates/vcs_actions/src/actions/local_actions.rs b/crates/vcs_actions/src/actions/local_actions.rs index e69de29..b230c6f 100644 --- a/crates/vcs_actions/src/actions/local_actions.rs +++ b/crates/vcs_actions/src/actions/local_actions.rs @@ -0,0 +1,17 @@ +use std::net::SocketAddr; + +use action_system::{action::ActionContext, action_gen}; +use tcp_connection::error::TcpTargetError; + +#[action_gen(local)] +pub async fn set_upstream_vault_action( + ctx: ActionContext, + upstream: SocketAddr, +) -> Result<(), TcpTargetError> { + if ctx.is_remote() { + return Err(TcpTargetError::NotLocal( + "Action was not invoked on the local machine".to_string(), + )); + } + Ok(()) +} -- cgit From 19c5780c2ee4920916aa5d766e02faa27fe2af2a Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Sun, 12 Oct 2025 18:16:28 +0800 Subject: chore: Update dependencies and module exports - Add required dependencies for action system - Export registry modules in vcs_actions library --- crates/vcs_actions/src/lib.rs | 1 + 1 file changed, 1 insertion(+) (limited to 'crates/vcs_actions/src') diff --git a/crates/vcs_actions/src/lib.rs b/crates/vcs_actions/src/lib.rs index 92de35f..2f7cbe4 100644 --- a/crates/vcs_actions/src/lib.rs +++ b/crates/vcs_actions/src/lib.rs @@ -1,2 +1,3 @@ pub mod actions; +pub mod connection; pub mod registry; -- cgit From 635ded4f6815d738dd9b9b711aa4c7cf302d340b Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Sun, 12 Oct 2025 18:17:08 +0800 Subject: feat: Add connection infrastructure and documentation - Implement action service for connection handling - Add error types for connection operations - Create todo.md for project tracking --- crates/vcs_actions/src/connection.rs | 2 + .../vcs_actions/src/connection/action_service.rs | 129 +++++++++++++++++++++ crates/vcs_actions/src/connection/error.rs | 14 +++ 3 files changed, 145 insertions(+) create mode 100644 crates/vcs_actions/src/connection.rs create mode 100644 crates/vcs_actions/src/connection/action_service.rs create mode 100644 crates/vcs_actions/src/connection/error.rs (limited to 'crates/vcs_actions/src') diff --git a/crates/vcs_actions/src/connection.rs b/crates/vcs_actions/src/connection.rs new file mode 100644 index 0000000..dabbd44 --- /dev/null +++ b/crates/vcs_actions/src/connection.rs @@ -0,0 +1,2 @@ +pub mod action_service; +pub mod error; diff --git a/crates/vcs_actions/src/connection/action_service.rs b/crates/vcs_actions/src/connection/action_service.rs new file mode 100644 index 0000000..8d3a03d --- /dev/null +++ b/crates/vcs_actions/src/connection/action_service.rs @@ -0,0 +1,129 @@ +use std::{net::SocketAddr, path::PathBuf, sync::Arc}; + +use action_system::action_pool::ActionPool; +use cfg_file::config::ConfigFile; +use tcp_connection::{error::TcpTargetError, instance::ConnectionInstance}; +use tokio::{ + net::{TcpListener, TcpStream}, + select, signal, spawn, + sync::mpsc, +}; +use vcs_data::data::vault::{Vault, config::VaultConfig}; + +use crate::registry::server_registry::server_action_pool; + +// Start the server with a Vault using the specified directory +pub async fn server_entry(path: impl Into) -> Result<(), TcpTargetError> { + // Read the vault cfg + let vault_cfg = VaultConfig::read().await?; + + // Create TCPListener + let listener = create_tcp_listener(&vault_cfg).await?; + + // Initialize the vault + let vault: Arc = init_vault(vault_cfg, path.into()).await?; + + // Create ActionPool + let action_pool: Arc = Arc::new(server_action_pool()); + + // Start the server + let (_shutdown_rx, future) = build_server_future(vault.clone(), action_pool.clone(), listener); + let _ = future.await?; // Start and block until shutdown + + Ok(()) +} + +async fn create_tcp_listener(cfg: &VaultConfig) -> Result { + let local_bind_addr = cfg.server_config().local_bind(); + let bind_port = cfg.server_config().port(); + let sock_addr = SocketAddr::new(local_bind_addr.clone(), bind_port); + let listener = TcpListener::bind(sock_addr).await?; + + Ok(listener) +} + +async fn init_vault(cfg: VaultConfig, path: PathBuf) -> Result, TcpTargetError> { + // Init and create the vault + let Some(vault) = Vault::init(cfg, path) else { + return Err(TcpTargetError::NotFound("Vault not found".to_string())); + }; + let vault: Arc = Arc::new(vault); + + Ok(vault) +} + +fn build_server_future( + vault: Arc, + action_pool: Arc, + listener: TcpListener, +) -> ( + mpsc::Sender<()>, + impl std::future::Future>, +) { + let (tx, mut rx) = mpsc::channel::(100); + let (shutdown_tx, mut shutdown_rx) = mpsc::channel::<()>(1); + let mut active_connections = 0; + let mut shutdown_requested = false; + + // Spawn task to handle Ctrl+C + let shutdown_tx_clone = shutdown_tx.clone(); + spawn(async move { + if let Ok(()) = signal::ctrl_c().await { + let _ = shutdown_tx_clone.send(()).await; + } + }); + + let future = async move { + loop { + select! { + // Accept new connections + accept_result = listener.accept(), if !shutdown_requested => { + match accept_result { + Ok((stream, _addr)) => { + active_connections += 1; + let _ = tx.send(1).await; + + let vault_clone = vault.clone(); + let action_pool_clone = action_pool.clone(); + let tx_clone = tx.clone(); + spawn(async move { + process_connection(stream, vault_clone, action_pool_clone).await; + let _ = tx_clone.send(-1).await; + }); + } + Err(_) => { + continue; + } + } + } + + // Handle connection count updates + Some(count_change) = rx.recv() => { + active_connections = (active_connections as i32 + count_change) as usize; + + // Check if we should shutdown after all connections are done + if shutdown_requested && active_connections == 0 { + break; + } + } + + // Handle shutdown signal + _ = shutdown_rx.recv() => { + shutdown_requested = true; + // If no active connections, break immediately + if active_connections == 0 { + break; + } + } + } + } + + Ok(()) + }; + + (shutdown_tx, future) +} + +async fn process_connection(stream: TcpStream, vault: Arc, action_pool: Arc) { + let instance = ConnectionInstance::from(stream); +} diff --git a/crates/vcs_actions/src/connection/error.rs b/crates/vcs_actions/src/connection/error.rs new file mode 100644 index 0000000..241c16e --- /dev/null +++ b/crates/vcs_actions/src/connection/error.rs @@ -0,0 +1,14 @@ +use std::io; +use thiserror::Error; + +#[derive(Error, Debug, Clone)] +pub enum ConnectionError { + #[error("I/O error: {0}")] + Io(String), +} + +impl From for ConnectionError { + fn from(error: io::Error) -> Self { + ConnectionError::Io(error.to_string()) + } +} -- cgit From 860fb317bca61ce66a2c98df933aa666dae0a43f Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Mon, 13 Oct 2025 11:17:00 +0800 Subject: feat: Add JSON-based action invocation to ActionPool - Extend action_gen macro to generate JSON serialization logic - Implement generic action processing using JSON text for type-agnostic calls - Add callback mechanism with action name and arguments in ActionPool - Update client and server registries to use new callback system - Improve action system flexibility at the cost of serialization overhead --- crates/vcs_actions/src/registry/client_registry.rs | 4 ++-- crates/vcs_actions/src/registry/server_registry.rs | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'crates/vcs_actions/src') diff --git a/crates/vcs_actions/src/registry/client_registry.rs b/crates/vcs_actions/src/registry/client_registry.rs index c32ce5a..d298099 100644 --- a/crates/vcs_actions/src/registry/client_registry.rs +++ b/crates/vcs_actions/src/registry/client_registry.rs @@ -1,11 +1,11 @@ use action_system::{action::ActionContext, action_pool::ActionPool}; use tcp_connection::error::TcpTargetError; -use crate::actions::local_actions::SetUpstreamVaultAction; +use crate::actions::local_actions::register_set_upstream_vault_action; fn register_actions(pool: &mut ActionPool) { // Pool register here - SetUpstreamVaultAction::register_to_pool(pool); + register_set_upstream_vault_action(pool); } pub fn client_action_pool() -> ActionPool { diff --git a/crates/vcs_actions/src/registry/server_registry.rs b/crates/vcs_actions/src/registry/server_registry.rs index bdd6a65..3ecc103 100644 --- a/crates/vcs_actions/src/registry/server_registry.rs +++ b/crates/vcs_actions/src/registry/server_registry.rs @@ -1,9 +1,9 @@ use action_system::action_pool::ActionPool; -use crate::actions::local_actions::SetUpstreamVaultAction; +use crate::actions::local_actions::register_set_upstream_vault_action; pub fn server_action_pool() -> ActionPool { let mut pool = ActionPool::new(); - SetUpstreamVaultAction::register_to_pool(&mut pool); + register_set_upstream_vault_action(&mut pool); pool } -- cgit From 67fb8ec01b351c6c9fd2af321166bb92250b1218 Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Mon, 13 Oct 2025 13:34:39 +0800 Subject: feat: Implement JSON-based type-erased action invocation - Add process_json method to ActionPool for type-agnostic calls using JSON serialization - Extend ActionContext with action_name and action_args fields and setter methods - Update action_gen macro to use process_json instead of typed process method - Implement remote action invocation framework in client_registry and action_service - Add protocol definitions for remote action communication - Enable flexible action execution without explicit type specifications --- crates/vcs_actions/src/actions/local_actions.rs | 2 +- crates/vcs_actions/src/connection.rs | 1 + .../vcs_actions/src/connection/action_service.rs | 29 ++++++++++++++++++---- crates/vcs_actions/src/connection/protocol.rs | 7 ++++++ crates/vcs_actions/src/registry/client_registry.rs | 28 +++++++++++++++++---- 5 files changed, 56 insertions(+), 11 deletions(-) create mode 100644 crates/vcs_actions/src/connection/protocol.rs (limited to 'crates/vcs_actions/src') diff --git a/crates/vcs_actions/src/actions/local_actions.rs b/crates/vcs_actions/src/actions/local_actions.rs index b230c6f..0e210a7 100644 --- a/crates/vcs_actions/src/actions/local_actions.rs +++ b/crates/vcs_actions/src/actions/local_actions.rs @@ -6,7 +6,7 @@ use tcp_connection::error::TcpTargetError; #[action_gen(local)] pub async fn set_upstream_vault_action( ctx: ActionContext, - upstream: SocketAddr, + _upstream: SocketAddr, ) -> Result<(), TcpTargetError> { if ctx.is_remote() { return Err(TcpTargetError::NotLocal( diff --git a/crates/vcs_actions/src/connection.rs b/crates/vcs_actions/src/connection.rs index dabbd44..918f93c 100644 --- a/crates/vcs_actions/src/connection.rs +++ b/crates/vcs_actions/src/connection.rs @@ -1,2 +1,3 @@ pub mod action_service; pub mod error; +pub mod protocol; diff --git a/crates/vcs_actions/src/connection/action_service.rs b/crates/vcs_actions/src/connection/action_service.rs index 8d3a03d..9ea5957 100644 --- a/crates/vcs_actions/src/connection/action_service.rs +++ b/crates/vcs_actions/src/connection/action_service.rs @@ -1,6 +1,6 @@ use std::{net::SocketAddr, path::PathBuf, sync::Arc}; -use action_system::action_pool::ActionPool; +use action_system::{action::ActionContext, action_pool::ActionPool}; use cfg_file::config::ConfigFile; use tcp_connection::{error::TcpTargetError, instance::ConnectionInstance}; use tokio::{ @@ -10,10 +10,12 @@ use tokio::{ }; use vcs_data::data::vault::{Vault, config::VaultConfig}; -use crate::registry::server_registry::server_action_pool; +use crate::{ + connection::protocol::RemoteActionInvoke, registry::server_registry::server_action_pool, +}; // Start the server with a Vault using the specified directory -pub async fn server_entry(path: impl Into) -> Result<(), TcpTargetError> { +pub async fn server_entry(vault_path: impl Into) -> Result<(), TcpTargetError> { // Read the vault cfg let vault_cfg = VaultConfig::read().await?; @@ -21,7 +23,7 @@ pub async fn server_entry(path: impl Into) -> Result<(), TcpTargetError let listener = create_tcp_listener(&vault_cfg).await?; // Initialize the vault - let vault: Arc = init_vault(vault_cfg, path.into()).await?; + let vault: Arc = init_vault(vault_cfg, vault_path.into()).await?; // Create ActionPool let action_pool: Arc = Arc::new(server_action_pool()); @@ -125,5 +127,22 @@ fn build_server_future( } async fn process_connection(stream: TcpStream, vault: Arc, action_pool: Arc) { - let instance = ConnectionInstance::from(stream); + // Setup connection instance + let mut instance = ConnectionInstance::from(stream); + + // Read action name and action arguments + let Ok(msg) = instance.read_msgpack::().await else { + return; + }; + + // Build context + let ctx = ActionContext::remote().insert_instance(instance); + + // Process action + let Ok(_result_json) = action_pool + .process_json(&msg.action_name, ctx, msg.action_args_json) + .await + else { + return; + }; } diff --git a/crates/vcs_actions/src/connection/protocol.rs b/crates/vcs_actions/src/connection/protocol.rs new file mode 100644 index 0000000..2cebe79 --- /dev/null +++ b/crates/vcs_actions/src/connection/protocol.rs @@ -0,0 +1,7 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Default, Clone, Serialize, Deserialize)] +pub struct RemoteActionInvoke { + pub action_name: String, + pub action_args_json: String, +} diff --git a/crates/vcs_actions/src/registry/client_registry.rs b/crates/vcs_actions/src/registry/client_registry.rs index d298099..56acdad 100644 --- a/crates/vcs_actions/src/registry/client_registry.rs +++ b/crates/vcs_actions/src/registry/client_registry.rs @@ -1,7 +1,10 @@ use action_system::{action::ActionContext, action_pool::ActionPool}; use tcp_connection::error::TcpTargetError; -use crate::actions::local_actions::register_set_upstream_vault_action; +use crate::{ + actions::local_actions::register_set_upstream_vault_action, + connection::protocol::RemoteActionInvoke, +}; fn register_actions(pool: &mut ActionPool) { // Pool register here @@ -22,18 +25,33 @@ pub fn client_action_pool() -> ActionPool { pool } -async fn on_proc_begin(ctx: &ActionContext) -> Result<(), TcpTargetError> { +async fn on_proc_begin(ctx: &mut ActionContext) -> Result<(), TcpTargetError> { + // Is ctx remote + let is_remote = ctx.is_remote(); + + // Action name and arguments + let action_name = ctx.action_name().to_string(); + let action_args_json = ctx.action_args_json().clone(); + // Get instance - let Some(_instance) = ctx.instance() else { + let Some(instance) = ctx.instance_mut() else { return Err(TcpTargetError::Unsupported( "Missing ConnectionInstance in current context, this ActionPool does not support this call" .to_string())); }; // If it's remote, invoke action at server - if ctx.is_remote() { - // instance.write_text(text) + if is_remote { + // Build protocol message + let msg = RemoteActionInvoke { + action_name: action_name, + action_args_json: action_args_json, + }; + + // Send + instance.write_msgpack(msg).await?; } + // Return OK, wait for client to execute Action locally Ok(()) } -- cgit From acf0804b5f9bdc2796d847919a8ae20103be600a Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Mon, 13 Oct 2025 14:17:51 +0800 Subject: feat: implement asynchronous action call system - Add async callback support with proper argument passing - Implement remote action invocation via TCP connection - Add hello_world_action example demonstrating async communication - Improve ActionPool with type-safe async processing - Update client registry for remote action handling - Enhance ActionContext with better instance management - Support both local and remote action execution modes --- crates/vcs_actions/src/actions/local_actions.rs | 28 ++++++++++++++-------- .../vcs_actions/src/connection/action_service.rs | 5 +++- crates/vcs_actions/src/registry/client_registry.rs | 17 +++++++------ crates/vcs_actions/src/registry/server_registry.rs | 4 ++-- 4 files changed, 34 insertions(+), 20 deletions(-) (limited to 'crates/vcs_actions/src') diff --git a/crates/vcs_actions/src/actions/local_actions.rs b/crates/vcs_actions/src/actions/local_actions.rs index 0e210a7..b11a934 100644 --- a/crates/vcs_actions/src/actions/local_actions.rs +++ b/crates/vcs_actions/src/actions/local_actions.rs @@ -1,17 +1,25 @@ -use std::net::SocketAddr; - use action_system::{action::ActionContext, action_gen}; +use log::info; use tcp_connection::error::TcpTargetError; -#[action_gen(local)] -pub async fn set_upstream_vault_action( - ctx: ActionContext, - _upstream: SocketAddr, -) -> Result<(), TcpTargetError> { - if ctx.is_remote() { - return Err(TcpTargetError::NotLocal( - "Action was not invoked on the local machine".to_string(), +#[action_gen] +pub async fn hello_world_action(ctx: ActionContext, _n: ()) -> Result<(), TcpTargetError> { + // Ensure the instance is available + let Some(instance) = ctx.instance() else { + return Err(TcpTargetError::NotFound( + "Connection Instance Lost.".to_string(), )); + }; + + if ctx.is_local() { + // Invoke on local + // Send the message to the server + let _ = instance.lock().await.write_text("Hello World!").await; + } else if ctx.is_remote() { + // Read the message from the client + let read = instance.lock().await.read_text().await?; + info!("{}", read) } + Ok(()) } diff --git a/crates/vcs_actions/src/connection/action_service.rs b/crates/vcs_actions/src/connection/action_service.rs index 9ea5957..0a49953 100644 --- a/crates/vcs_actions/src/connection/action_service.rs +++ b/crates/vcs_actions/src/connection/action_service.rs @@ -136,7 +136,10 @@ async fn process_connection(stream: TcpStream, vault: Arc, action_pool: A }; // Build context - let ctx = ActionContext::remote().insert_instance(instance); + let ctx: ActionContext = ActionContext::remote().insert_instance(instance); + + // Insert vault into context + let ctx = ctx.insert_arc(vault); // Process action let Ok(_result_json) = action_pool diff --git a/crates/vcs_actions/src/registry/client_registry.rs b/crates/vcs_actions/src/registry/client_registry.rs index 56acdad..47fd7ee 100644 --- a/crates/vcs_actions/src/registry/client_registry.rs +++ b/crates/vcs_actions/src/registry/client_registry.rs @@ -2,13 +2,12 @@ use action_system::{action::ActionContext, action_pool::ActionPool}; use tcp_connection::error::TcpTargetError; use crate::{ - actions::local_actions::register_set_upstream_vault_action, - connection::protocol::RemoteActionInvoke, + actions::local_actions::register_hello_world_action, connection::protocol::RemoteActionInvoke, }; fn register_actions(pool: &mut ActionPool) { // Pool register here - register_set_upstream_vault_action(pool); + register_hello_world_action(pool); } pub fn client_action_pool() -> ActionPool { @@ -19,13 +18,16 @@ pub fn client_action_pool() -> ActionPool { register_actions(&mut pool); // Add process events - pool.set_on_proc_begin(|ctx| Box::pin(on_proc_begin(ctx))); + pool.set_on_proc_begin(|ctx, args| Box::pin(on_proc_begin(ctx, args))); // Return pool } -async fn on_proc_begin(ctx: &mut ActionContext) -> Result<(), TcpTargetError> { +async fn on_proc_begin( + ctx: &ActionContext, + _args: &(dyn std::any::Any + Send + Sync), +) -> Result<(), TcpTargetError> { // Is ctx remote let is_remote = ctx.is_remote(); @@ -34,7 +36,7 @@ async fn on_proc_begin(ctx: &mut ActionContext) -> Result<(), TcpTargetError> { let action_args_json = ctx.action_args_json().clone(); // Get instance - let Some(instance) = ctx.instance_mut() else { + let Some(instance) = ctx.instance() else { return Err(TcpTargetError::Unsupported( "Missing ConnectionInstance in current context, this ActionPool does not support this call" .to_string())); @@ -49,7 +51,8 @@ async fn on_proc_begin(ctx: &mut ActionContext) -> Result<(), TcpTargetError> { }; // Send - instance.write_msgpack(msg).await?; + let mut instance = instance.lock().await; + instance.write_msgpack(&msg).await?; } // Return OK, wait for client to execute Action locally diff --git a/crates/vcs_actions/src/registry/server_registry.rs b/crates/vcs_actions/src/registry/server_registry.rs index 3ecc103..b449b68 100644 --- a/crates/vcs_actions/src/registry/server_registry.rs +++ b/crates/vcs_actions/src/registry/server_registry.rs @@ -1,9 +1,9 @@ use action_system::action_pool::ActionPool; -use crate::actions::local_actions::register_set_upstream_vault_action; +use crate::actions::local_actions::register_hello_world_action; pub fn server_action_pool() -> ActionPool { let mut pool = ActionPool::new(); - register_set_upstream_vault_action(&mut pool); + register_hello_world_action(&mut pool); pool } -- cgit From 4810f56e6a49b60923eb850d5944457650c81c75 Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Mon, 13 Oct 2025 14:27:01 +0800 Subject: Fix Clippy warnings and optimize code - Fix let_underscore_future warning by properly awaiting async functions - Make accept_import function async to match add_mapping usage - Propagate errors properly with ? operator instead of ignoring them - Replace manual Default implementation with derive attribute - Replace vec! with array literal to avoid useless_vec warning - All tests pass and code is now Clippy clean --- crates/vcs_actions/src/connection/action_service.rs | 4 ++-- crates/vcs_actions/src/registry/client_registry.rs | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'crates/vcs_actions/src') diff --git a/crates/vcs_actions/src/connection/action_service.rs b/crates/vcs_actions/src/connection/action_service.rs index 0a49953..c302fd4 100644 --- a/crates/vcs_actions/src/connection/action_service.rs +++ b/crates/vcs_actions/src/connection/action_service.rs @@ -30,7 +30,7 @@ pub async fn server_entry(vault_path: impl Into) -> Result<(), TcpTarge // Start the server let (_shutdown_rx, future) = build_server_future(vault.clone(), action_pool.clone(), listener); - let _ = future.await?; // Start and block until shutdown + future.await?; // Start and block until shutdown Ok(()) } @@ -38,7 +38,7 @@ pub async fn server_entry(vault_path: impl Into) -> Result<(), TcpTarge async fn create_tcp_listener(cfg: &VaultConfig) -> Result { let local_bind_addr = cfg.server_config().local_bind(); let bind_port = cfg.server_config().port(); - let sock_addr = SocketAddr::new(local_bind_addr.clone(), bind_port); + let sock_addr = SocketAddr::new(*local_bind_addr, bind_port); let listener = TcpListener::bind(sock_addr).await?; Ok(listener) diff --git a/crates/vcs_actions/src/registry/client_registry.rs b/crates/vcs_actions/src/registry/client_registry.rs index 47fd7ee..5939bed 100644 --- a/crates/vcs_actions/src/registry/client_registry.rs +++ b/crates/vcs_actions/src/registry/client_registry.rs @@ -46,8 +46,8 @@ async fn on_proc_begin( if is_remote { // Build protocol message let msg = RemoteActionInvoke { - action_name: action_name, - action_args_json: action_args_json, + action_name, + action_args_json, }; // Send -- cgit