From b590a40891dcf843a2f3ca23d930aca4363e7ffe Mon Sep 17 00:00:00 2001
From: 魏曹先生 <1992414357@qq.com>
Date: Sun, 12 Oct 2025 18:15:36 +0800
Subject: feat: Add Clone implementation for ActionContext

This enables ActionContext to be cloned when setting up process
begin callbacks, resolving lifetime issues in callback registration.
---
 crates/system_action/src/action.rs | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

(limited to 'crates/system_action')

diff --git a/crates/system_action/src/action.rs b/crates/system_action/src/action.rs
index 562a142..c8d7a18 100644
--- a/crates/system_action/src/action.rs
+++ b/crates/system_action/src/action.rs
@@ -1,6 +1,12 @@
+use serde::{Serialize, de::DeserializeOwned};
 use tcp_connection::{error::TcpTargetError, instance::ConnectionInstance};
+use tokio::net::TcpStream;
 
-pub trait Action<Args, Return> {
+pub trait Action<Args, Return>
+where
+    Args: Serialize + DeserializeOwned + Send,
+    Return: Serialize + DeserializeOwned + Send,
+{
     fn action_name() -> &'static str;
 
     fn is_remote_action() -> bool;
@@ -13,7 +19,7 @@ pub trait Action<Args, Return> {
 
 #[derive(Default)]
 pub struct ActionContext {
-    // Whether the action is executed locally or remotely
+    /// Whether the action is executed locally or remotely
     local: bool,
 
     /// The connection instance in the current context,
@@ -35,6 +41,18 @@ impl ActionContext {
         ctx.local = false;
         ctx
     }
+
+    /// Build connection instance from TcpStream
+    pub fn build_instance(mut self, stream: TcpStream) -> Self {
+        self.instance = Some(ConnectionInstance::from(stream));
+        self
+    }
+
+    /// Insert connection instance into context
+    pub fn insert_instance(mut self, instance: ConnectionInstance) -> Self {
+        self.instance = Some(instance);
+        self
+    }
 }
 
 impl ActionContext {
-- 
cgit 


From 912d32f37cfe7ae761daa4e01313182d1551c80e Mon Sep 17 00:00:00 2001
From: 魏曹先生 <1992414357@qq.com>
Date: Sun, 12 Oct 2025 18:15:58 +0800
Subject: feat: Add callback mechanism to ActionPool

- Add ProcBeginCallback and ProcEndCallback types
- Implement set_on_proc_begin and set_on_proc_end methods
- Add callback execution in process method
- Update trait bounds for better type safety
---
 crates/system_action/src/action_pool.rs | 59 +++++++++++++++++++++++++++++----
 1 file changed, 53 insertions(+), 6 deletions(-)

(limited to 'crates/system_action')

diff --git a/crates/system_action/src/action_pool.rs b/crates/system_action/src/action_pool.rs
index 0a1a6c7..bc60f7f 100644
--- a/crates/system_action/src/action_pool.rs
+++ b/crates/system_action/src/action_pool.rs
@@ -1,11 +1,26 @@
+use std::pin::Pin;
+
+use serde::{Serialize, de::DeserializeOwned};
 use tcp_connection::error::TcpTargetError;
 
 use crate::action::{Action, ActionContext};
 
+type ProcBeginCallback =
+    for<'a> fn(
+        &'a ActionContext,
+    ) -> Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send + 'a>>;
+type ProcEndCallback = fn() -> Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send>>;
+
 /// A pool of registered actions that can be processed by name
 pub struct ActionPool {
     /// HashMap storing action name to action implementation mapping
     actions: std::collections::HashMap<&'static str, Box<dyn ActionErased>>,
+
+    /// Callback to execute when process begins
+    on_proc_begin: Option<ProcBeginCallback>,
+
+    /// Callback to execute when process ends
+    on_proc_end: Option<ProcEndCallback>,
 }
 
 impl ActionPool {
@@ -13,20 +28,32 @@ impl ActionPool {
     pub fn new() -> Self {
         Self {
             actions: std::collections::HashMap::new(),
+            on_proc_begin: None,
+            on_proc_end: None,
         }
     }
 
+    /// Sets a callback to be executed when process begins
+    pub fn set_on_proc_begin(&mut self, callback: ProcBeginCallback) {
+        self.on_proc_begin = Some(callback);
+    }
+
+    /// Sets a callback to be executed when process ends
+    pub fn set_on_proc_end(&mut self, callback: ProcEndCallback) {
+        self.on_proc_end = Some(callback);
+    }
+
     /// Registers an action type with the pool
     ///
     /// Usage:
-    /// ```
+    /// ```ignore
     /// action_pool.register::<MyAction, MyArgs, MyReturn>();
     /// ```
     pub fn register<A, Args, Return>(&mut self)
     where
         A: Action<Args, Return> + Send + Sync + 'static,
-        Args: serde::de::DeserializeOwned + Send + Sync + 'static,
-        Return: serde::Serialize + Send + Sync + 'static,
+        Args: serde::Serialize + serde::de::DeserializeOwned + Send + Sync + 'static,
+        Return: serde::Serialize + serde::de::DeserializeOwned + Send + Sync + 'static,
     {
         let action_name = A::action_name();
         self.actions.insert(
@@ -38,7 +65,7 @@ impl ActionPool {
     /// Processes an action by name with given context and arguments
     ///
     /// Usage:
-    /// ```
+    /// ```ignore
     /// let result = action_pool.process::<MyArgs, MyReturn>("my_action", context, args).await?;
     /// ```
     pub async fn process<'a, Args, Return>(
@@ -52,15 +79,35 @@ impl ActionPool {
         Return: serde::Serialize + Send + 'static,
     {
         if let Some(action) = self.actions.get(action_name) {
+            let _ = self.exec_on_proc_begin(&context).await?;
             let result = action.process_erased(context, Box::new(args)).await?;
             let result = *result
                 .downcast::<Return>()
                 .map_err(|_| TcpTargetError::Unsupported("InvalidArguments".to_string()))?;
+            let _ = self.exec_on_proc_end().await?;
             Ok(result)
         } else {
             Err(TcpTargetError::Unsupported("InvalidAction".to_string()))
         }
     }
+
+    /// Executes the process begin callback if set
+    async fn exec_on_proc_begin(&self, context: &ActionContext) -> Result<(), TcpTargetError> {
+        if let Some(callback) = &self.on_proc_begin {
+            callback(context).await
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Executes the process end callback if set
+    async fn exec_on_proc_end(&self) -> Result<(), TcpTargetError> {
+        if let Some(callback) = &self.on_proc_end {
+            callback().await
+        } else {
+            Ok(())
+        }
+    }
 }
 
 /// Trait for type-erased actions that can be stored in ActionPool
@@ -84,8 +131,8 @@ struct ActionWrapper<A, Args, Return>(std::marker::PhantomData<(A, Args, Return)
 impl<A, Args, Return> ActionErased for ActionWrapper<A, Args, Return>
 where
     A: Action<Args, Return> + Send + Sync,
-    Args: serde::de::DeserializeOwned + Send + Sync + 'static,
-    Return: serde::Serialize + Send + Sync + 'static,
+    Args: Serialize + DeserializeOwned + Send + Sync + 'static,
+    Return: Serialize + DeserializeOwned + Send + Sync + 'static,
 {
     fn process_erased(
         &self,
-- 
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/system_action/Cargo.toml | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'crates/system_action')

diff --git a/crates/system_action/Cargo.toml b/crates/system_action/Cargo.toml
index ee4f774..120cb34 100644
--- a/crates/system_action/Cargo.toml
+++ b/crates/system_action/Cargo.toml
@@ -9,3 +9,6 @@ action_system_macros = { path = "action_macros" }
 
 # Serialization
 serde = { version = "1.0.219", features = ["derive"] }
+
+# Async & Networking
+tokio = { version = "1.46.1", features = ["full"] }
-- 
cgit 


From ffdc23d102faab74838a36a8044c6f11b289d760 Mon Sep 17 00:00:00 2001
From: 魏曹先生 <1992414357@qq.com>
Date: Sun, 12 Oct 2025 18:16:36 +0800
Subject: refactor: Update action macros and error types

- Enhance action_gen macro functionality
- Add new error variants for TCP connection
---
 crates/system_action/action_macros/src/lib.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'crates/system_action')

diff --git a/crates/system_action/action_macros/src/lib.rs b/crates/system_action/action_macros/src/lib.rs
index a7de9b6..04e974a 100644
--- a/crates/system_action/action_macros/src/lib.rs
+++ b/crates/system_action/action_macros/src/lib.rs
@@ -79,13 +79,13 @@ fn generate_action_struct(input_fn: ItemFn, _is_local: bool) -> proc_macro2::Tok
         #[doc = "Use the generated struct instead."]
         #[doc = ""]
         #[doc = "Register the action to the pool."]
-        #[doc = "```rust"]
-        #[doc = "YourActionPascalName::register_to_pool(&mut pool);"]
+        #[doc = "```ignore"]
+        #[doc = "YourAction::register_to_pool(&mut pool);"]
         #[doc = "```"]
         #[doc = ""]
         #[doc = "Process the action at the pool."]
-        #[doc = "```rust"]
-        #[doc = "let result = YourActionPascalName::process_at_pool(&pool, ctx, arg).await?;"]
+        #[doc = "```ignore"]
+        #[doc = "let result = YourAction::process_at_pool(&pool, ctx, arg).await?;"]
         #[doc = "```"]
         #fn_vis #fn_sig #fn_block
     }
-- 
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/system_action/Cargo.toml               |  1 +
 crates/system_action/action_macros/Cargo.toml |  4 ++++
 crates/system_action/action_macros/src/lib.rs | 34 +++++++++++++++------------
 crates/system_action/src/action_pool.rs       |  4 +++-
 4 files changed, 27 insertions(+), 16 deletions(-)

(limited to 'crates/system_action')

diff --git a/crates/system_action/Cargo.toml b/crates/system_action/Cargo.toml
index 120cb34..54ae454 100644
--- a/crates/system_action/Cargo.toml
+++ b/crates/system_action/Cargo.toml
@@ -9,6 +9,7 @@ action_system_macros = { path = "action_macros" }
 
 # Serialization
 serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.140"
 
 # Async & Networking
 tokio = { version = "1.46.1", features = ["full"] }
diff --git a/crates/system_action/action_macros/Cargo.toml b/crates/system_action/action_macros/Cargo.toml
index 5ae14fa..869dcde 100644
--- a/crates/system_action/action_macros/Cargo.toml
+++ b/crates/system_action/action_macros/Cargo.toml
@@ -13,3 +13,7 @@ string_proc = { path = "../../utils/string_proc" }
 syn = { version = "2.0", features = ["full", "extra-traits"] }
 quote = "1.0"
 proc-macro2 = "1.0"
+
+# Serialization
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.140"
diff --git a/crates/system_action/action_macros/src/lib.rs b/crates/system_action/action_macros/src/lib.rs
index 04e974a..683efcb 100644
--- a/crates/system_action/action_macros/src/lib.rs
+++ b/crates/system_action/action_macros/src/lib.rs
@@ -37,6 +37,9 @@ fn generate_action_struct(input_fn: ItemFn, _is_local: bool) -> proc_macro2::Tok
 
     let action_name_ident = &fn_name;
 
+    let register_this_action = quote::format_ident!("register_{}", action_name_ident);
+    let proc_this_action = quote::format_ident!("proc_{}", action_name_ident);
+
     quote! {
         #[derive(Debug, Clone, Default)]
         #fn_vis struct #struct_name;
@@ -55,22 +58,23 @@ fn generate_action_struct(input_fn: ItemFn, _is_local: bool) -> proc_macro2::Tok
             }
         }
 
-        impl #struct_name {
-            #fn_vis fn register_to_pool(pool: &mut action_system::action_pool::ActionPool) {
-                pool.register::<#struct_name, #arg_type, #return_type>();
-            }
+        #fn_vis fn #register_this_action(pool: &mut action_system::action_pool::ActionPool) {
+            pool.register::<#struct_name, #arg_type, #return_type>();
+        }
 
-            #fn_vis async fn process_at_pool<'a>(
-                pool: &'a action_system::action_pool::ActionPool,
-                ctx: action_system::action::ActionContext,
-                #arg_param_name: #arg_type
-            ) -> Result<#return_type, tcp_connection::error::TcpTargetError> {
-                pool.process::<#arg_type, #return_type>(
-                    Box::leak(string_proc::snake_case!(stringify!(#action_name_ident)).into_boxed_str()),
-                    ctx,
-                    #arg_param_name
-                ).await
-            }
+        #fn_vis async fn #proc_this_action(
+            pool: &action_system::action_pool::ActionPool,
+            ctx: action_system::action::ActionContext,
+            #arg_param_name: #arg_type
+        ) -> Result<#return_type, tcp_connection::error::TcpTargetError> {
+            pool.process::<#arg_type, #return_type>(
+                Box::leak(string_proc::snake_case!(stringify!(#action_name_ident)).into_boxed_str()),
+                ctx,
+                serde_json::to_string(&#arg_param_name)
+                    .map_err(|e| {
+                        tcp_connection::error::TcpTargetError::Serialization(e.to_string())
+                    })?
+            ).await
         }
 
         #[allow(dead_code)]
diff --git a/crates/system_action/src/action_pool.rs b/crates/system_action/src/action_pool.rs
index bc60f7f..a3e82d6 100644
--- a/crates/system_action/src/action_pool.rs
+++ b/crates/system_action/src/action_pool.rs
@@ -72,7 +72,7 @@ impl ActionPool {
         &'a self,
         action_name: &'a str,
         context: ActionContext,
-        args: Args,
+        args_json: String,
     ) -> Result<Return, TcpTargetError>
     where
         Args: serde::de::DeserializeOwned + Send + 'static,
@@ -80,6 +80,8 @@ impl ActionPool {
     {
         if let Some(action) = self.actions.get(action_name) {
             let _ = self.exec_on_proc_begin(&context).await?;
+            let args: Args = serde_json::from_str(&args_json)
+                .map_err(|e| TcpTargetError::Serialization(format!("Deserialize failed: {}", e)))?;
             let result = action.process_erased(context, Box::new(args)).await?;
             let result = *result
                 .downcast::<Return>()
-- 
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/system_action/action_macros/src/lib.rs | 17 ++++---
 crates/system_action/src/action.rs            | 38 +++++++++++++++
 crates/system_action/src/action_pool.rs       | 67 ++++++++++++++++++++++++---
 3 files changed, 110 insertions(+), 12 deletions(-)

(limited to 'crates/system_action')

diff --git a/crates/system_action/action_macros/src/lib.rs b/crates/system_action/action_macros/src/lib.rs
index 683efcb..aa1c696 100644
--- a/crates/system_action/action_macros/src/lib.rs
+++ b/crates/system_action/action_macros/src/lib.rs
@@ -67,14 +67,19 @@ fn generate_action_struct(input_fn: ItemFn, _is_local: bool) -> proc_macro2::Tok
             ctx: action_system::action::ActionContext,
             #arg_param_name: #arg_type
         ) -> Result<#return_type, tcp_connection::error::TcpTargetError> {
-            pool.process::<#arg_type, #return_type>(
+            let args_json = serde_json::to_string(&#arg_param_name)
+                .map_err(|e| {
+                    tcp_connection::error::TcpTargetError::Serialization(e.to_string())
+                })?;
+            let result_json = pool.process_json(
                 Box::leak(string_proc::snake_case!(stringify!(#action_name_ident)).into_boxed_str()),
                 ctx,
-                serde_json::to_string(&#arg_param_name)
-                    .map_err(|e| {
-                        tcp_connection::error::TcpTargetError::Serialization(e.to_string())
-                    })?
-            ).await
+                args_json,
+            ).await?;
+            serde_json::from_str(&result_json)
+                .map_err(|e| {
+                    tcp_connection::error::TcpTargetError::Serialization(e.to_string())
+                })
         }
 
         #[allow(dead_code)]
diff --git a/crates/system_action/src/action.rs b/crates/system_action/src/action.rs
index c8d7a18..e7d2d8c 100644
--- a/crates/system_action/src/action.rs
+++ b/crates/system_action/src/action.rs
@@ -22,6 +22,12 @@ pub struct ActionContext {
     /// Whether the action is executed locally or remotely
     local: bool,
 
+    /// The name of the action being executed
+    action_name: String,
+
+    /// The JSON-serialized arguments for the action
+    action_args_json: String,
+
     /// The connection instance in the current context,
     /// used to interact with the machine on the other end
     instance: Option<ConnectionInstance>,
@@ -53,6 +59,11 @@ impl ActionContext {
         self.instance = Some(instance);
         self
     }
+
+    /// Pop connection instance from context
+    pub fn pop_instance(&mut self) -> Option<ConnectionInstance> {
+        self.instance.take()
+    }
 }
 
 impl ActionContext {
@@ -70,4 +81,31 @@ impl ActionContext {
     pub fn instance(&self) -> &Option<ConnectionInstance> {
         &self.instance
     }
+
+    /// Get a mutable reference to the connection instance in the current context
+    pub fn instance_mut(&mut self) -> &mut Option<ConnectionInstance> {
+        &mut self.instance
+    }
+
+    /// Get the action name from the context
+    pub fn action_name(&self) -> &str {
+        &self.action_name
+    }
+
+    /// Get the action arguments from the context
+    pub fn action_args_json(&self) -> &String {
+        &self.action_args_json
+    }
+
+    /// Set the action name in the context
+    pub fn set_action_name(mut self, action_name: String) -> Self {
+        self.action_name = action_name;
+        self
+    }
+
+    /// Set the action arguments in the context
+    pub fn set_action_args_json(mut self, action_args: String) -> Self {
+        self.action_args_json = action_args;
+        self
+    }
 }
diff --git a/crates/system_action/src/action_pool.rs b/crates/system_action/src/action_pool.rs
index a3e82d6..7e93fc4 100644
--- a/crates/system_action/src/action_pool.rs
+++ b/crates/system_action/src/action_pool.rs
@@ -1,13 +1,14 @@
 use std::pin::Pin;
 
 use serde::{Serialize, de::DeserializeOwned};
+use serde_json;
 use tcp_connection::error::TcpTargetError;
 
 use crate::action::{Action, ActionContext};
 
 type ProcBeginCallback =
     for<'a> fn(
-        &'a ActionContext,
+        &'a mut ActionContext,
     ) -> Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send + 'a>>;
 type ProcEndCallback = fn() -> Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send>>;
 
@@ -68,20 +69,51 @@ impl ActionPool {
     /// ```ignore
     /// let result = action_pool.process::<MyArgs, MyReturn>("my_action", context, args).await?;
     /// ```
-    pub async fn process<'a, Args, Return>(
+    /// Processes an action by name with JSON-serialized arguments
+    ///
+    /// Usage:
+    /// ```ignore
+    /// let result_json = action_pool.process_json("my_action", context, args_json).await?;
+    /// let result: MyReturn = serde_json::from_str(&result_json)?;
+    /// ```
+    pub async fn process_json<'a>(
         &'a self,
         action_name: &'a str,
         context: ActionContext,
         args_json: String,
+    ) -> Result<String, TcpTargetError> {
+        if let Some(action) = self.actions.get(action_name) {
+            // Set action name and args in context for callbacks
+            let context = context.set_action_name(action_name.to_string());
+            let mut context = context.set_action_args_json(args_json.clone());
+
+            let _ = self.exec_on_proc_begin(&mut context).await?;
+            let result = action.process_json_erased(context, args_json).await?;
+            let _ = self.exec_on_proc_end().await?;
+            Ok(result)
+        } else {
+            Err(TcpTargetError::Unsupported("InvalidAction".to_string()))
+        }
+    }
+
+    /// Processes an action by name with given context and arguments
+    ///
+    /// Usage:
+    /// ```ignore
+    /// let result = action_pool.process::<MyArgs, MyReturn>("my_action", context, args).await?;
+    /// ```
+    pub async fn process<'a, Args, Return>(
+        &'a self,
+        action_name: &'a str,
+        mut context: ActionContext,
+        args: Args,
     ) -> Result<Return, TcpTargetError>
     where
         Args: serde::de::DeserializeOwned + Send + 'static,
         Return: serde::Serialize + Send + 'static,
     {
         if let Some(action) = self.actions.get(action_name) {
-            let _ = self.exec_on_proc_begin(&context).await?;
-            let args: Args = serde_json::from_str(&args_json)
-                .map_err(|e| TcpTargetError::Serialization(format!("Deserialize failed: {}", e)))?;
+            let _ = self.exec_on_proc_begin(&mut context).await?;
             let result = action.process_erased(context, Box::new(args)).await?;
             let result = *result
                 .downcast::<Return>()
@@ -94,7 +126,7 @@ impl ActionPool {
     }
 
     /// Executes the process begin callback if set
-    async fn exec_on_proc_begin(&self, context: &ActionContext) -> Result<(), TcpTargetError> {
+    async fn exec_on_proc_begin(&self, context: &mut ActionContext) -> Result<(), TcpTargetError> {
         if let Some(callback) = &self.on_proc_begin {
             callback(context).await
         } else {
@@ -125,6 +157,13 @@ trait ActionErased: Send + Sync {
                 + Send,
         >,
     >;
+
+    /// Processes the action with JSON-serialized arguments and returns JSON-serialized result
+    fn process_json_erased(
+        &self,
+        context: ActionContext,
+        args_json: String,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<String, TcpTargetError>> + Send>>;
 }
 
 /// Wrapper struct that implements ActionErased for concrete Action types
@@ -154,4 +193,20 @@ where
             Ok(Box::new(result) as Box<dyn std::any::Any + Send>)
         })
     }
+
+    fn process_json_erased(
+        &self,
+        context: ActionContext,
+        args_json: String,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<String, TcpTargetError>> + Send>>
+    {
+        Box::pin(async move {
+            let args: Args = serde_json::from_str(&args_json)
+                .map_err(|e| TcpTargetError::Serialization(format!("Deserialize failed: {}", e)))?;
+            let result = A::process(context, args).await?;
+            let result_json = serde_json::to_string(&result)
+                .map_err(|e| TcpTargetError::Serialization(format!("Serialize failed: {}", e)))?;
+            Ok(result_json)
+        })
+    }
 }
-- 
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/system_action/action_macros/src/lib.rs |  4 +-
 crates/system_action/src/action.rs            | 70 +++++++++++++++++++++++----
 crates/system_action/src/action_pool.rs       | 19 +++++---
 3 files changed, 75 insertions(+), 18 deletions(-)

(limited to 'crates/system_action')

diff --git a/crates/system_action/action_macros/src/lib.rs b/crates/system_action/action_macros/src/lib.rs
index aa1c696..d1a47ee 100644
--- a/crates/system_action/action_macros/src/lib.rs
+++ b/crates/system_action/action_macros/src/lib.rs
@@ -89,12 +89,12 @@ fn generate_action_struct(input_fn: ItemFn, _is_local: bool) -> proc_macro2::Tok
         #[doc = ""]
         #[doc = "Register the action to the pool."]
         #[doc = "```ignore"]
-        #[doc = "YourAction::register_to_pool(&mut pool);"]
+        #[doc = "register_your_func(&mut pool);"]
         #[doc = "```"]
         #[doc = ""]
         #[doc = "Process the action at the pool."]
         #[doc = "```ignore"]
-        #[doc = "let result = YourAction::process_at_pool(&pool, ctx, arg).await?;"]
+        #[doc = "let result = proc_your_func(&pool, ctx, arg).await?;"]
         #[doc = "```"]
         #fn_vis #fn_sig #fn_block
     }
diff --git a/crates/system_action/src/action.rs b/crates/system_action/src/action.rs
index e7d2d8c..3ae5711 100644
--- a/crates/system_action/src/action.rs
+++ b/crates/system_action/src/action.rs
@@ -1,6 +1,9 @@
 use serde::{Serialize, de::DeserializeOwned};
+use std::any::{Any, TypeId};
+use std::collections::HashMap;
+use std::sync::Arc;
 use tcp_connection::{error::TcpTargetError, instance::ConnectionInstance};
-use tokio::net::TcpStream;
+use tokio::{net::TcpStream, sync::Mutex};
 
 pub trait Action<Args, Return>
 where
@@ -29,8 +32,10 @@ pub struct ActionContext {
     action_args_json: String,
 
     /// The connection instance in the current context,
-    /// used to interact with the machine on the other end
-    instance: Option<ConnectionInstance>,
+    instance: Option<Arc<Mutex<ConnectionInstance>>>,
+
+    /// Generic data storage for arbitrary types
+    data: HashMap<TypeId, Arc<dyn Any + Send + Sync>>,
 }
 
 impl ActionContext {
@@ -50,18 +55,18 @@ impl ActionContext {
 
     /// Build connection instance from TcpStream
     pub fn build_instance(mut self, stream: TcpStream) -> Self {
-        self.instance = Some(ConnectionInstance::from(stream));
+        self.instance = Some(Arc::new(Mutex::new(ConnectionInstance::from(stream))));
         self
     }
 
     /// Insert connection instance into context
     pub fn insert_instance(mut self, instance: ConnectionInstance) -> Self {
-        self.instance = Some(instance);
+        self.instance = Some(Arc::new(Mutex::new(instance)));
         self
     }
 
     /// Pop connection instance from context
-    pub fn pop_instance(&mut self) -> Option<ConnectionInstance> {
+    pub fn pop_instance(&mut self) -> Option<Arc<Mutex<ConnectionInstance>>> {
         self.instance.take()
     }
 }
@@ -78,12 +83,12 @@ impl ActionContext {
     }
 
     /// Get the connection instance in the current context
-    pub fn instance(&self) -> &Option<ConnectionInstance> {
+    pub fn instance(&self) -> &Option<Arc<Mutex<ConnectionInstance>>> {
         &self.instance
     }
 
     /// Get a mutable reference to the connection instance in the current context
-    pub fn instance_mut(&mut self) -> &mut Option<ConnectionInstance> {
+    pub fn instance_mut(&mut self) -> &mut Option<Arc<Mutex<ConnectionInstance>>> {
         &mut self.instance
     }
 
@@ -104,8 +109,55 @@ impl ActionContext {
     }
 
     /// Set the action arguments in the context
-    pub fn set_action_args_json(mut self, action_args: String) -> Self {
+    pub fn set_action_args(mut self, action_args: String) -> Self {
         self.action_args_json = action_args;
         self
     }
+
+    /// Insert arbitrary data in the context
+    pub fn insert<T: Any + Send + Sync>(mut self, value: T) -> Self {
+        self.data.insert(TypeId::of::<T>(), Arc::new(value));
+        self
+    }
+
+    /// Insert arbitrary data as Arc in the context
+    pub fn insert_arc<T: Any + Send + Sync>(mut self, value: Arc<T>) -> Self {
+        self.data.insert(TypeId::of::<T>(), value);
+        self
+    }
+
+    /// Get arbitrary data from the context
+    pub fn get<T: Any + Send + Sync>(&self) -> Option<&T> {
+        self.data
+            .get(&TypeId::of::<T>())
+            .and_then(|arc| arc.downcast_ref::<T>())
+    }
+
+    /// Get arbitrary data as Arc from the context
+    pub fn get_arc<T: Any + Send + Sync>(&self) -> Option<Arc<T>> {
+        self.data
+            .get(&TypeId::of::<T>())
+            .and_then(|arc| Arc::clone(arc).downcast::<T>().ok())
+    }
+
+    /// Remove and return arbitrary data from the context
+    pub fn remove<T: Any + Send + Sync>(&mut self) -> Option<Arc<T>> {
+        self.data
+            .remove(&TypeId::of::<T>())
+            .and_then(|arc| arc.downcast::<T>().ok())
+    }
+
+    /// Check if the context contains data of a specific type
+    pub fn contains<T: Any + Send + Sync>(&self) -> bool {
+        self.data.contains_key(&TypeId::of::<T>())
+    }
+
+    /// Take ownership of the context and extract data of a specific type
+    pub fn take<T: Any + Send + Sync>(mut self) -> (Self, Option<Arc<T>>) {
+        let value = self
+            .data
+            .remove(&TypeId::of::<T>())
+            .and_then(|arc| arc.downcast::<T>().ok());
+        (self, value)
+    }
 }
diff --git a/crates/system_action/src/action_pool.rs b/crates/system_action/src/action_pool.rs
index 7e93fc4..f3e178a 100644
--- a/crates/system_action/src/action_pool.rs
+++ b/crates/system_action/src/action_pool.rs
@@ -8,7 +8,8 @@ use crate::action::{Action, ActionContext};
 
 type ProcBeginCallback =
     for<'a> fn(
-        &'a mut ActionContext,
+        &'a ActionContext,
+        args: &'a (dyn std::any::Any + Send + Sync),
     ) -> Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send + 'a>>;
 type ProcEndCallback = fn() -> Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send>>;
 
@@ -85,9 +86,9 @@ impl ActionPool {
         if let Some(action) = self.actions.get(action_name) {
             // Set action name and args in context for callbacks
             let context = context.set_action_name(action_name.to_string());
-            let mut context = context.set_action_args_json(args_json.clone());
+            let context = context.set_action_args(args_json.clone());
 
-            let _ = self.exec_on_proc_begin(&mut context).await?;
+            let _ = self.exec_on_proc_begin(&context, &args_json).await?;
             let result = action.process_json_erased(context, args_json).await?;
             let _ = self.exec_on_proc_end().await?;
             Ok(result)
@@ -109,11 +110,11 @@ impl ActionPool {
         args: Args,
     ) -> Result<Return, TcpTargetError>
     where
-        Args: serde::de::DeserializeOwned + Send + 'static,
+        Args: serde::de::DeserializeOwned + Send + Sync + 'static,
         Return: serde::Serialize + Send + 'static,
     {
         if let Some(action) = self.actions.get(action_name) {
-            let _ = self.exec_on_proc_begin(&mut context).await?;
+            let _ = self.exec_on_proc_begin(&context, &args).await?;
             let result = action.process_erased(context, Box::new(args)).await?;
             let result = *result
                 .downcast::<Return>()
@@ -126,9 +127,13 @@ impl ActionPool {
     }
 
     /// Executes the process begin callback if set
-    async fn exec_on_proc_begin(&self, context: &mut ActionContext) -> Result<(), TcpTargetError> {
+    async fn exec_on_proc_begin(
+        &self,
+        context: &ActionContext,
+        args: &(dyn std::any::Any + Send + Sync),
+    ) -> Result<(), TcpTargetError> {
         if let Some(callback) = &self.on_proc_begin {
-            callback(context).await
+            callback(context, args).await
         } else {
             Ok(())
         }
-- 
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/system_action/action_macros/src/lib.rs |  7 ++--
 crates/system_action/src/action.rs            | 14 ++++----
 crates/system_action/src/action_pool.rs       | 48 +++++++++++++++++----------
 3 files changed, 41 insertions(+), 28 deletions(-)

(limited to 'crates/system_action')

diff --git a/crates/system_action/action_macros/src/lib.rs b/crates/system_action/action_macros/src/lib.rs
index d1a47ee..ce50073 100644
--- a/crates/system_action/action_macros/src/lib.rs
+++ b/crates/system_action/action_macros/src/lib.rs
@@ -101,7 +101,7 @@ fn generate_action_struct(input_fn: ItemFn, _is_local: bool) -> proc_macro2::Tok
 }
 
 fn validate_function_signature(fn_sig: &syn::Signature) {
-    if !fn_sig.asyncness.is_some() {
+    if fn_sig.asyncness.is_none() {
         panic!("Expected async function for Action, but found synchronous function");
     }
 
@@ -120,13 +120,12 @@ fn validate_function_signature(fn_sig: &syn::Signature) {
     };
 
     if let syn::Type::Path(type_path) = return_type.as_ref() {
-        if let Some(segment) = type_path.path.segments.last() {
-            if segment.ident != "Result" {
+        if let Some(segment) = type_path.path.segments.last()
+            && segment.ident != "Result" {
                 panic!(
                     "Expected Action function to return Result<T, TcpTargetError>, but found different return type"
                 );
             }
-        }
     } else {
         panic!(
             "Expected Action function to return Result<T, TcpTargetError>, but found no return type"
diff --git a/crates/system_action/src/action.rs b/crates/system_action/src/action.rs
index 3ae5711..8a6180a 100644
--- a/crates/system_action/src/action.rs
+++ b/crates/system_action/src/action.rs
@@ -41,16 +41,18 @@ pub struct ActionContext {
 impl ActionContext {
     /// Generate local context
     pub fn local() -> Self {
-        let mut ctx = ActionContext::default();
-        ctx.local = true;
-        ctx
+        ActionContext {
+            local: true,
+            ..Default::default()
+        }
     }
 
     /// Generate remote context
     pub fn remote() -> Self {
-        let mut ctx = ActionContext::default();
-        ctx.local = false;
-        ctx
+        ActionContext {
+            local: false,
+            ..Default::default()
+        }
     }
 
     /// Build connection instance from TcpStream
diff --git a/crates/system_action/src/action_pool.rs b/crates/system_action/src/action_pool.rs
index f3e178a..c28de1e 100644
--- a/crates/system_action/src/action_pool.rs
+++ b/crates/system_action/src/action_pool.rs
@@ -6,12 +6,14 @@ use tcp_connection::error::TcpTargetError;
 
 use crate::action::{Action, ActionContext};
 
-type ProcBeginCallback =
-    for<'a> fn(
-        &'a ActionContext,
-        args: &'a (dyn std::any::Any + Send + Sync),
-    ) -> Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send + 'a>>;
-type ProcEndCallback = fn() -> Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send>>;
+type ProcBeginCallback = for<'a> fn(
+    &'a ActionContext,
+    args: &'a (dyn std::any::Any + Send + Sync),
+) -> ProcBeginFuture<'a>;
+type ProcEndCallback = fn() -> ProcEndFuture;
+
+type ProcBeginFuture<'a> = Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send + 'a>>;
+type ProcEndFuture = Pin<Box<dyn Future<Output = Result<(), TcpTargetError>> + Send>>;
 
 /// A pool of registered actions that can be processed by name
 pub struct ActionPool {
@@ -25,6 +27,12 @@ pub struct ActionPool {
     on_proc_end: Option<ProcEndCallback>,
 }
 
+impl Default for ActionPool {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ActionPool {
     /// Creates a new empty ActionPool
     pub fn new() -> Self {
@@ -88,9 +96,9 @@ impl ActionPool {
             let context = context.set_action_name(action_name.to_string());
             let context = context.set_action_args(args_json.clone());
 
-            let _ = self.exec_on_proc_begin(&context, &args_json).await?;
+            self.exec_on_proc_begin(&context, &args_json).await?;
             let result = action.process_json_erased(context, args_json).await?;
-            let _ = self.exec_on_proc_end().await?;
+            self.exec_on_proc_end().await?;
             Ok(result)
         } else {
             Err(TcpTargetError::Unsupported("InvalidAction".to_string()))
@@ -106,7 +114,7 @@ impl ActionPool {
     pub async fn process<'a, Args, Return>(
         &'a self,
         action_name: &'a str,
-        mut context: ActionContext,
+        context: ActionContext,
         args: Args,
     ) -> Result<Return, TcpTargetError>
     where
@@ -114,12 +122,12 @@ impl ActionPool {
         Return: serde::Serialize + Send + 'static,
     {
         if let Some(action) = self.actions.get(action_name) {
-            let _ = self.exec_on_proc_begin(&context, &args).await?;
+            self.exec_on_proc_begin(&context, &args).await?;
             let result = action.process_erased(context, Box::new(args)).await?;
             let result = *result
                 .downcast::<Return>()
                 .map_err(|_| TcpTargetError::Unsupported("InvalidArguments".to_string()))?;
-            let _ = self.exec_on_proc_end().await?;
+            self.exec_on_proc_end().await?;
             Ok(result)
         } else {
             Err(TcpTargetError::Unsupported("InvalidAction".to_string()))
@@ -150,25 +158,29 @@ impl ActionPool {
 }
 
 /// Trait for type-erased actions that can be stored in ActionPool
+type ProcessErasedFuture = std::pin::Pin<
+    Box<
+        dyn std::future::Future<Output = Result<Box<dyn std::any::Any + Send>, TcpTargetError>>
+            + Send,
+    >,
+>;
+type ProcessJsonErasedFuture =
+    std::pin::Pin<Box<dyn std::future::Future<Output = Result<String, TcpTargetError>> + Send>>;
+
 trait ActionErased: Send + Sync {
     /// Processes the action with type-erased arguments and returns type-erased result
     fn process_erased(
         &self,
         context: ActionContext,
         args: Box<dyn std::any::Any + Send>,
-    ) -> std::pin::Pin<
-        Box<
-            dyn std::future::Future<Output = Result<Box<dyn std::any::Any + Send>, TcpTargetError>>
-                + Send,
-        >,
-    >;
+    ) -> ProcessErasedFuture;
 
     /// Processes the action with JSON-serialized arguments and returns JSON-serialized result
     fn process_json_erased(
         &self,
         context: ActionContext,
         args_json: String,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<String, TcpTargetError>> + Send>>;
+    ) -> ProcessJsonErasedFuture;
 }
 
 /// Wrapper struct that implements ActionErased for concrete Action types
-- 
cgit