finish ctx

8 files changed, 56 insertions, 23 deletions

diff --git a/src/client/connector.rs b/src/client/connector.rs
index f48b039..32c9cae 100644
--- a/src/client/connector.rs
+++ b/src/client/connector.rs
@@ -7,7 +7,13 @@ use std::{
 };
 
 use crate::client::Client;
-use remote_control_rs::{executor::Executor, tasks::client::NETWORK_T};
+use remote_control_rs::{
+    executor::Executor,
+    tasks::{
+        IntoTaskErr,
+        client::{NETWORK_T, Task},
+    },
+};
 
 pub type Result<T: Display, E: Debug> = result::Result<T, E>;
 
@@ -28,7 +34,7 @@ pub trait Connection {
     fn get_ip(&self) -> Option<IpAddr>;
 
     fn force_network(&mut self) {
-        _ = Executor::new(NETWORK_T.as_ref(), ["true"]);
+        _ = Executor::new(NETWORK_T.as_ref(), ["true"], ());
     }
 
     fn init<'a>(&self, c: &Client<'a, Self>) -> std::result::Result<(), Self::Err>
@@ -67,7 +73,7 @@ pub trait Connection {
                     None => return,
                 };
                 // FIXME: handle the errors... peak prod code
-                self.ntfy(Executor::new(task.try_into().unwrap(), it).unwrap().run().as_ref().unwrap().clone()).unwrap();
+                self.ntfy(Executor::new((task.try_into() as result::Result<Task, IntoTaskErr>).unwrap().as_ref(), it, ()).unwrap().run().as_ref().unwrap().clone()).unwrap();
             }
             Result::Err(e) => {
                 #[cfg(debug_assertions)]
diff --git a/src/client/connector/httpconnector.rs b/src/client/connector/httpconnector.rs
index eb5ebe3..d668ce5 100644
--- a/src/client/connector/httpconnector.rs
+++ b/src/client/connector/httpconnector.rs
@@ -37,7 +37,7 @@ pub struct HTTPConnector {
 impl HTTPConnector {
     pub fn new(pull_url: &str, ntfy_url: &str, ip_getter_url: &str) -> result::Result<Self, HTTPConnectorError> {
         Ok(Self {
-            network_enforcer: Executor::new(NETWORK_T.as_ref(), ["true"]).unwrap(), // .unwrap() should never panic
+            network_enforcer: Executor::new(NETWORK_T.as_ref(), ["true"], ()).unwrap(), // .unwrap() should never panic
             prev: String::new(),
             pull_url: Url::parse(pull_url)?,
             ntfy_url: Url::parse(ntfy_url)?,
diff --git a/src/executor.rs b/src/executor.rs
index df59734..ec95b18 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -1,18 +1,19 @@
 use crate::tasks::{CompletedTask, IntoTaskErr, Task, TaskOutput};
 
-pub struct Executor<'a, 't, N: Copy> {
-    task: &'t Task<N>,
+pub struct Executor<'a, 't, N: Copy, T = ()> {
+    task: &'t Task<N, T>,
     args: Box<[&'a str]>,
+    ctx: T,
     complete_task: Option<CompletedTask<N>>,
 }
 
-impl<'a, 't, N: Copy> Executor<'a, 't, N> {
-    pub fn new(task: &'t Task<N>, args: impl IntoIterator<Item = &'a str>) -> Result<Self, IntoTaskErr> {
-        Ok(Self { task: task, args: args.into_iter().collect(), complete_task: None })
+impl<'a, 't, N: Copy, T> Executor<'a, 't, N, T> {
+    pub fn new(task: &'t Task<N, T>, args: impl IntoIterator<Item = &'a str>, ctx: T) -> Result<Self, IntoTaskErr> {
+        Ok(Self { task: task, args: args.into_iter().collect(), ctx, complete_task: None })
     }
 
     pub fn run(&mut self) -> &TaskOutput {
-        let output = (self.task.exec)(&self.args);
+        let output = (self.task.exec)(&self.args, &self.ctx);
         self.complete_task = Some(CompletedTask { name: self.task.name, output: Some(output) });
         self.complete_task.as_ref().unwrap().output.as_ref().unwrap()
     }
diff --git a/src/server/servers.rs b/src/server/servers.rs
index fcc6e7f..238fb46 100644
--- a/src/server/servers.rs
+++ b/src/server/servers.rs
@@ -1,4 +1,4 @@
-use remote_control_rs::tasks::Task;
+use remote_control_rs::tasks::server::Task;
 
 pub mod tcpserver;
 
diff --git a/src/server/servers/tcpserver/server.rs b/src/server/servers/tcpserver/server.rs
index 198fd6f..0b9b9b7 100644
--- a/src/server/servers/tcpserver/server.rs
+++ b/src/server/servers/tcpserver/server.rs
@@ -4,7 +4,7 @@ use std::{
     sync::{Arc, Weak},
 };
 
-use remote_control_rs::{client, tasks::Task};
+use remote_control_rs::{client, tasks::server::Task};
 use tokio::{
     io::{self, AsyncReadExt},
     net::{TcpListener, TcpStream},
@@ -51,7 +51,7 @@ impl<'a> Server<'a> for TCPServer<'a> {
     }
 }
 
-struct Client<'a> {
+pub struct Client<'a> {
     server: Arc<TCPServer<'a>>,
     stream: TcpStream,
     addr: SocketAddr,
diff --git a/src/tasks.rs b/src/tasks.rs
index 069f9c2..e08c876 100644
--- a/src/tasks.rs
+++ b/src/tasks.rs
@@ -4,9 +4,10 @@ pub type TaskOutput = Result<String, String>;
 pub mod client;
 pub mod server;
 
+#[derive(Clone, Copy)]
 pub struct Task<N, T = ()> {
     pub name: N,
-    pub exec: fn(&[&str], T) -> TaskOutput,
+    pub exec: fn(&[&str], &T) -> TaskOutput,
 }
 
 #[derive(Deserialize)]
diff --git a/src/tasks/client.rs b/src/tasks/client.rs
index ea7525a..e4510aa 100644
--- a/src/tasks/client.rs
+++ b/src/tasks/client.rs
@@ -3,6 +3,7 @@ use std::fmt::Display;
 use crate::tasks::{IntoTaskErr, Task as BaseTask};
 use serde::Deserialize;
 
+#[derive(Clone, Copy)]
 pub struct Task(pub BaseTask<Name>);
 
 #[derive(Debug, Deserialize, Clone, Copy)]
@@ -21,11 +22,11 @@ impl Display for Name {
 pub const TASKS: &[Task] = &[Task(BaseTask { name: Name::Nop, exec: no_op }), Task(BaseTask { name: Name::Exec, exec: exec }), NETWORK_T];
 pub const NETWORK_T: Task = Task(BaseTask { name: Name::Network, exec: network });
 
-fn no_op(_: &[&str]) -> Result<String, String> {
+fn no_op(_: &[&str], _: &()) -> Result<String, String> {
     Ok("".to_string())
 }
 
-fn exec(cmds: &[&str]) -> Result<String, String> {
+fn exec(cmds: &[&str], _: &()) -> Result<String, String> {
     use std::process::Command;
     // TODO: fmt and add exit code, and add support for both stdout and stderr, and
     // support for no output
@@ -41,7 +42,7 @@ fn exec(cmds: &[&str]) -> Result<String, String> {
     }
 }
 
-fn network(switch: &[&str]) -> Result<String, String> {
+fn network(switch: &[&str], _: &()) -> Result<String, String> {
     use std::process::{Command, Stdio};
     let switch: bool = switch[0].parse::<bool>().map_err(|e| e.to_string())?;
 
@@ -128,6 +129,20 @@ impl TryFrom<&str> for &'static Task {
     }
 }
 
+// ts uses Copy trait, try avoid that
+impl TryFrom<&str> for Task {
+    type Error = IntoTaskErr;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        for task in TASKS {
+            if task.0.name.to_string() == value {
+                return Ok(*task);
+            }
+        }
+        Err(IntoTaskErr::NotFound(value.to_string()))
+    }
+}
+
 impl From<Task> for BaseTask<Name> {
     fn from(value: Task) -> Self {
         value.0
diff --git a/src/tasks/server.rs b/src/tasks/server.rs
index 0896dca..b1cfc15 100644
--- a/src/tasks/server.rs
+++ b/src/tasks/server.rs
@@ -2,8 +2,13 @@ use std::fmt::Display;
 
 use crate::tasks::{IntoTaskErr, Task as BaseTask, TaskOutput};
 use serde::Deserialize;
+use tokio::net::TcpStream;
 
-pub struct Task<T = ()>(pub BaseTask<Name, T>);
+pub struct ServerCtx {
+    stream: TcpStream,
+}
+
+pub struct Task(pub BaseTask<Name, ServerCtx>);
 
 #[derive(Debug, Deserialize, Clone, Copy)]
 pub enum Name {
@@ -16,9 +21,14 @@ impl Display for Name {
     }
 }
 
-pub const TASKS: &[Task] = &[Task::<i32>(BaseTask { name: Name::GetIp, exec: get_ip })];
+pub const TASKS: &[Task] = &[Task(BaseTask { name: Name::GetIp, exec: get_ip })];
 
-fn get_ip(cmds: &[&str], _: i32) -> TaskOutput {}
+fn get_ip(_: &[&str], ctx: &ServerCtx) -> TaskOutput {
+    match ctx.stream.peer_addr() {
+        Ok(addr) => Ok(addr.ip().to_string()),
+        Err(e) => Err(e.to_string()),
+    }
+}
 
 impl TryFrom<&str> for &'static Task {
     type Error = IntoTaskErr;
@@ -33,14 +43,14 @@ impl TryFrom<&str> for &'static Task {
     }
 }
 
-impl From<Task> for BaseTask<Name> {
+impl From<Task> for BaseTask<Name, ServerCtx> {
     fn from(value: Task) -> Self {
         value.0
     }
 }
 
-impl AsRef<BaseTask<Name>> for Task {
-    fn as_ref(&self) -> &BaseTask<Name> {
+impl AsRef<BaseTask<Name, ServerCtx>> for Task {
+    fn as_ref(&self) -> &BaseTask<Name, ServerCtx> {
         &self.0
     }
 }