wip

9 files changed, 67 insertions, 58 deletions

diff --git a/src/client/connector.rs b/src/client/connector.rs
index 32c9cae..22a9f5a 100644
--- a/src/client/connector.rs
+++ b/src/client/connector.rs
@@ -73,7 +73,7 @@ pub trait Connection {
                     None => return,
                 };
                 // FIXME: handle the errors... peak prod code
-                self.ntfy(Executor::new((task.try_into() as result::Result<Task, IntoTaskErr>).unwrap().as_ref(), it, ()).unwrap().run().as_ref().unwrap().clone()).unwrap();
+                self.ntfy(Executor::new((task.try_into() as result::Result<Task, IntoTaskErr>).unwrap().as_ref(), it, ()).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 d668ce5..67741e9 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() 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 ec95b18..58be87d 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -1,15 +1,15 @@
-use crate::tasks::{CompletedTask, IntoTaskErr, Task, TaskOutput};
+use crate::tasks::{CompletedTask, Task, TaskOutput};
 
-pub struct Executor<'a, 't, N: Copy, T = ()> {
+pub struct Executor<'a, 't, N: Copy + PartialEq, T = ()> {
     task: &'t Task<N, T>,
     args: Box<[&'a str]>,
     ctx: T,
     complete_task: Option<CompletedTask<N>>,
 }
 
-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 })
+impl<'a, 't, N: Copy + PartialEq, T> Executor<'a, 't, N, T> {
+    pub fn new(task: &'t Task<N, T>, args: impl IntoIterator<Item = &'a str>, ctx: T) -> Self {
+        Self { task: task, args: args.into_iter().collect(), ctx, complete_task: None }
     }
 
     pub fn run(&mut self) -> &TaskOutput {
diff --git a/src/server/server.rs b/src/server/server.rs
index 39e246b..36b6e7e 100644
--- a/src/server/server.rs
+++ b/src/server/server.rs
@@ -1,9 +1,17 @@
-use remote_control_rs::tasks::server::Task;
+use remote_control_rs::{
+    executor::Executor,
+    tasks::{
+        IntoTaskErr,
+        server::{Name, Task},
+    },
+};
+
+use crate::tasks::{Request, Requests};
 
 pub mod tcpserver;
 
 pub trait Server<'a> {
-    fn update(&mut self, task: Task);
+    fn update(&mut self, task: Task<'a>);
 
     async fn listen(&self) -> !;
 }
diff --git a/src/server/server/tcpserver.rs b/src/server/server/tcpserver.rs
index 3fc69aa..118560d 100644
--- a/src/server/server/tcpserver.rs
+++ b/src/server/server/tcpserver.rs
@@ -4,7 +4,14 @@ use std::{
     sync::{Arc, Weak},
 };
 
-use remote_control_rs::{client, tasks::server::Task};
+use remote_control_rs::{
+    client,
+    executor::Executor,
+    tasks::{
+        IntoTaskErr,
+        server::{ServerCtx, Task},
+    },
+};
 use tokio::{
     io::{self, AsyncReadExt},
     net::{TcpListener, TcpStream},
@@ -12,14 +19,14 @@ use tokio::{
 
 use crate::{
     server::Server,
-    tasks::{Request, RequestType},
+    tasks::{Request, Requests},
 };
 
 use bincode::serde;
 
 pub struct TCPServer<'a> {
     this: RefCell<Weak<Self>>,
-    task: Option<Task>,
+    task: Option<Task<'a>>,
     listener: TcpListener,
     clients: RefCell<Vec<Client<'a>>>,
 }
@@ -37,7 +44,7 @@ impl<'a> TCPServer<'a> {
 }
 
 impl<'a> Server<'a> for TCPServer<'a> {
-    fn update(&mut self, task: Task) {
+    fn update(&mut self, task: Task<'a>) {
         self.task = Some(task);
     }
 
@@ -104,7 +111,7 @@ impl<'a> Client<'a> {
                 continue;
             }
             if let Some((buf, len)) = self.read().await {
-                let req: RequestType = match serde::decode_from_slice(buf.as_slice(), bincode::config::standard()) {
+                let req: Requests = match serde::decode_from_slice(buf.as_slice(), bincode::config::standard()) {
                     Ok((decoded, size)) => {
                         if size != len {
                             eprintln!("Decoded size {size} does not match expected size {len}, decode succeeded anyways?");
@@ -116,25 +123,16 @@ impl<'a> Client<'a> {
                         continue;
                     }
                 };
-                match req {
-                    // TODO: seperate send and respond
-                    RequestType::Send(req) => match req {
-                        Request::Get(req) => {
-                            todo!()
-                        }
-                        Request::Post(req) => {
-                            todo!()
-                        }
-                    },
-                    RequestType::Respond(res) => match res {
-                        Request::Get(req) => {
-                            todo!()
-                        }
-                        Request::Post(req) => {
-                            todo!()
-                        }
-                    },
-                }
+            }
+        }
+    }
+
+    // Some(Request) should be send back to client
+    fn handle_request(&self, req: Requests) -> Option<Request> {
+        match req {
+            Requests::Send((prev, (name, args))) => Some(Request::Post((name, Executor::new((name.try_into() as Result<&Task, IntoTaskErr>).unwrap().as_ref(), args.split_whitespace(), ServerCtx { stream: &self.stream }).run().to_owned()).into())),
+            _ => {
+                panic!()
             }
         }
     }
diff --git a/src/server/tasks.rs b/src/server/tasks.rs
index 5052dfe..88f3767 100644
--- a/src/server/tasks.rs
+++ b/src/server/tasks.rs
@@ -1,20 +1,16 @@
-use remote_control_rs::tasks::{CompletedTask, client::Name};
+use remote_control_rs::tasks::{CompletedTask, server::Name};
 use serde::Deserialize;
 
-#[derive(Deserialize)]
-pub enum RequestType {
-    Send(Request),
-    Respond(Request),
-}
+pub type Task = (Name, String);
 
 #[derive(Deserialize)]
-pub enum Request {
-    Get(TaskType),
-    Post(TaskType),
+pub enum Requests {
+    Send((Vec<Requests>, Task)),
+    Respond((Vec<Requests>, CompletedTask<Task>)),
 }
 
 #[derive(Deserialize)]
-pub enum TaskType {
-    Completed(CompletedTask<Name>),
-    Pending(Name),
+pub enum Request {
+    Get(Name),
+    Post(CompletedTask<Name>),
 }
diff --git a/src/tasks.rs b/src/tasks.rs
index e08c876..85e57c5 100644
--- a/src/tasks.rs
+++ b/src/tasks.rs
@@ -5,7 +5,7 @@ pub mod client;
 pub mod server;
 
 #[derive(Clone, Copy)]
-pub struct Task<N, T = ()> {
+pub struct Task<N: PartialEq, T = ()> {
     pub name: N,
     pub exec: fn(&[&str], &T) -> TaskOutput,
 }
@@ -16,6 +16,12 @@ pub struct CompletedTask<N> {
     pub output: Option<TaskOutput>,
 }
 
+impl<N> From<(N, TaskOutput)> for CompletedTask<N> {
+    fn from((name, output): (N, TaskOutput)) -> Self {
+        CompletedTask { name, output: Some(output) }
+    }
+}
+
 #[derive(Debug)]
 pub enum IntoTaskErr {
     NotFound(String),
diff --git a/src/tasks/client.rs b/src/tasks/client.rs
index e4510aa..6561efd 100644
--- a/src/tasks/client.rs
+++ b/src/tasks/client.rs
@@ -6,7 +6,7 @@ use serde::Deserialize;
 #[derive(Clone, Copy)]
 pub struct Task(pub BaseTask<Name>);
 
-#[derive(Debug, Deserialize, Clone, Copy)]
+#[derive(Debug, Deserialize, Clone, Copy, PartialEq)]
 pub enum Name {
     Nop,
     Exec,
diff --git a/src/tasks/server.rs b/src/tasks/server.rs
index b1cfc15..45be9f1 100644
--- a/src/tasks/server.rs
+++ b/src/tasks/server.rs
@@ -4,13 +4,14 @@ use crate::tasks::{IntoTaskErr, Task as BaseTask, TaskOutput};
 use serde::Deserialize;
 use tokio::net::TcpStream;
 
-pub struct ServerCtx {
-    stream: TcpStream,
+#[derive(Clone, Copy)]
+pub struct ServerCtx<'a> {
+    pub stream: &'a TcpStream,
 }
 
-pub struct Task(pub BaseTask<Name, ServerCtx>);
+pub struct Task<'a>(pub BaseTask<Name, ServerCtx<'a>>);
 
-#[derive(Debug, Deserialize, Clone, Copy)]
+#[derive(Debug, Deserialize, Clone, Copy, PartialEq)]
 pub enum Name {
     GetIp,
 }
@@ -30,12 +31,12 @@ fn get_ip(_: &[&str], ctx: &ServerCtx) -> TaskOutput {
     }
 }
 
-impl TryFrom<&str> for &'static Task {
+impl<'a> TryFrom<Name> for &'static Task<'a> {
     type Error = IntoTaskErr;
 
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
+    fn try_from(value: Name) -> Result<Self, Self::Error> {
         for task in TASKS {
-            if task.0.name.to_string() == value {
+            if task.0.name == value {
                 return Ok(task);
             }
         }
@@ -43,14 +44,14 @@ impl TryFrom<&str> for &'static Task {
     }
 }
 
-impl From<Task> for BaseTask<Name, ServerCtx> {
-    fn from(value: Task) -> Self {
+impl<'a> From<Task<'a>> for BaseTask<Name, ServerCtx<'a>> {
+    fn from(value: Task<'a>) -> Self {
         value.0
     }
 }
 
-impl AsRef<BaseTask<Name, ServerCtx>> for Task {
-    fn as_ref(&self) -> &BaseTask<Name, ServerCtx> {
+impl<'a> AsRef<BaseTask<Name, ServerCtx<'a>>> for Task<'a> {
+    fn as_ref(&self) -> &BaseTask<Name, ServerCtx<'a>> {
         &self.0
     }
 }