3 files changed, 40 insertions, 38 deletions
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>),
 }