From 2e1d12ec90ea12e8824d79dfc31b5b3cae397df8 Mon Sep 17 00:00:00 2001 From: littleblack111 Date: Sun, 21 Sep 2025 22:59:47 +0800 Subject: wip --- src/client/connector.rs | 2 +- src/client/connector/httpconnector.rs | 2 +- src/executor.rs | 10 ++++---- src/server/server.rs | 12 +++++++-- src/server/server/tcpserver.rs | 46 +++++++++++++++++------------------ src/server/tasks.rs | 20 ++++++--------- src/tasks.rs | 8 +++++- src/tasks/client.rs | 2 +- src/tasks/server.rs | 23 +++++++++--------- 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).unwrap().as_ref(), it, ()).unwrap().run().as_ref().unwrap().clone()).unwrap(); + self.ntfy(Executor::new((task.try_into() as result::Result).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 { 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, args: Box<[&'a str]>, ctx: T, complete_task: Option>, } -impl<'a, 't, N: Copy, T> Executor<'a, 't, N, T> { - pub fn new(task: &'t Task, args: impl IntoIterator, ctx: T) -> Result { - 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, args: impl IntoIterator, 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>, - task: Option, + task: Option>, listener: TcpListener, clients: RefCell>>, } @@ -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 { + 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, Task)), + Respond((Vec, CompletedTask)), } #[derive(Deserialize)] -pub enum TaskType { - Completed(CompletedTask), - Pending(Name), +pub enum Request { + Get(Name), + Post(CompletedTask), } 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 { +pub struct Task { pub name: N, pub exec: fn(&[&str], &T) -> TaskOutput, } @@ -16,6 +16,12 @@ pub struct CompletedTask { pub output: Option, } +impl From<(N, TaskOutput)> for CompletedTask { + 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); -#[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); +pub struct Task<'a>(pub BaseTask>); -#[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 for &'static Task<'a> { type Error = IntoTaskErr; - fn try_from(value: &str) -> Result { + fn try_from(value: Name) -> Result { 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 for BaseTask { - fn from(value: Task) -> Self { +impl<'a> From> for BaseTask> { + fn from(value: Task<'a>) -> Self { value.0 } } -impl AsRef> for Task { - fn as_ref(&self) -> &BaseTask { +impl<'a> AsRef>> for Task<'a> { + fn as_ref(&self) -> &BaseTask> { &self.0 } } -- cgit v1.2.3