Cons-n-Stuff/slidershim
1
0
Fork 0
mirror of https://github.com/4yn/slidershim.git synced 2025-02-02 04:27:58 +01:00
Code Releases Activity

better async

Browse Source
This commit is contained in:
4yn 2022-02-05 00:40:50 +08:00
parent 281e4b02b1
commit 7f155903ca
6 changed files with 85 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src-tauri/Cargo.lock generated
View File

@ -105,6 +105,17 @@ dependencies = [
"winapi", "winapi",
] ]
[[package]]
name = "async-trait"
version = "0.1.52"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "061a7acccaa286c011ddc30970520b98fa40e00c9d644633fb26b5fc63a265e3"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]] [[package]]
name = "atk" name = "atk"
version = "0.14.0" version = "0.14.0"
@ -3041,6 +3052,7 @@ checksum = "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5"
name = "slidershim" name = "slidershim"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"async-trait",
"directories", "directories",
"env_logger", "env_logger",
"futures", "futures",

1
src-tauri/Cargo.toml
View File

@ -30,6 +30,7 @@ palette = "0.6.0"
winapi = "0.3.9" winapi = "0.3.9"
futures = "0.3.19" futures = "0.3.19"
async-trait = "0.1.52"
tokio = { version="1.16.1", features=["rt-multi-thread","macros"] } tokio = { version="1.16.1", features=["rt-multi-thread","macros"] }
hyper = { version="0.14.16", features=["server","http1","http2","tcp"] } hyper = { version="0.14.16", features=["server","http1","http2","tcp"] }
tungstenite = { version="0.16.0", default-features=false } tungstenite = { version="0.16.0", default-features=false }

54
src-tauri/src/bin/test_async.rs
View File

@ -1,39 +1,45 @@
extern crate slidershim; extern crate slidershim;
use std::{io, time::Duration}; use async_trait::async_trait;
use std::{future::Future, io, time::Duration};
use tokio::time::sleep; use tokio::{select, time::sleep};
// use slidershim::slider_io::worker::{AsyncJob, AsyncJobFut, AsyncJobRecvStop, AsyncWorker}; use slidershim::slider_io::worker::{AsyncJob, AsyncWorker};
// struct CounterJob; struct CounterJob;
// impl AsyncJob for CounterJob { #[async_trait]
// fn job(self, mut recv_stop: AsyncJobRecvStop) -> AsyncJobFut { impl AsyncJob for CounterJob {
// return Box::pin(async move { async fn do_work<F: Future<Output = ()> + Send>(self, stop_signal: F) {
// let mut x = 0; let job_a = async {
// loop { println!("Start job A");
// x += 1; let mut x = 0;
// println!("{}", x); loop {
// sleep(Duration::from_millis(500)).await; x += 1;
// match recv_stop.try_recv() { println!("{}", x);
// Ok(_) => { sleep(Duration::from_millis(100)).await;
// println!("@@@"); }
// break; };
// } let job_b = async move {
// _ => {} println!("Start job B");
// } stop_signal.await;
// } println!("Stop signal hit at job B");
// }); };
// }
// } select! {
_ = job_a => {},
_ = job_b => {},
}
}
}
fn main() { fn main() {
env_logger::Builder::new() env_logger::Builder::new()
.filter_level(log::LevelFilter::Debug) .filter_level(log::LevelFilter::Debug)
.init(); .init();
// let worker = AsyncWorker::new("counter", CounterJob); let worker = AsyncWorker::new("counter", CounterJob);
let mut input = String::new(); let mut input = String::new();
let string = io::stdin().read_line(&mut input).unwrap(); let string = io::stdin().read_line(&mut input).unwrap();
} }

17
src-tauri/src/bin/test_brokenithm.rs Normal file
View File

@ -0,0 +1,17 @@
extern crate slidershim;
use std::{io, time::Duration};
use tokio::time::sleep;
// use slidershim::slider_io::{brokenithm::BrokenithmJob, worker::AsyncWorker};
fn main() {
env_logger::Builder::new()
.filter_level(log::LevelFilter::Debug)
.init();
// let worker = AsyncWorker::new("brokenithm", BrokenithmJob);
let mut input = String::new();
let string = io::stdin().read_line(&mut input).unwrap();
}

12
src-tauri/src/slider_io/brokenithm.rs
View File

@ -9,6 +9,8 @@ use hyper::{
Body, Request, Response, Server, Body, Request, Response, Server,
}; };
// use crate::slider_io::worker::{AsyncJob, AsyncJobFut, AsyncJobRecvStop};
async fn handle_request( async fn handle_request(
request: Request<Body>, request: Request<Body>,
remote_addr: SocketAddr, remote_addr: SocketAddr,
@ -19,7 +21,7 @@ async fn handle_request(
)))) ))))
} }
pub async fn brokenithm_server() { async fn brokenithm_server() {
let addr = SocketAddr::from(([0, 0, 0, 0], 1666)); let addr = SocketAddr::from(([0, 0, 0, 0], 1666));
info!("Brokenithm opening on {:?}", addr); info!("Brokenithm opening on {:?}", addr);
@ -38,3 +40,11 @@ pub async fn brokenithm_server() {
eprintln!("Server error: {}", e); eprintln!("Server error: {}", e);
} }
} }
// struct BrokenithmJob;
// impl AsyncJob {
// fn job(self, mut recv_stop: AsyncJobRecvStop) -> AsyncJobFut {
// return Box::pin()
// }
// }

23
src-tauri/src/slider_io/worker.rs
View File

@ -1,3 +1,5 @@
use async_trait::async_trait;
use log::info;
use std::{ use std::{
future::Future, future::Future,
pin::Pin, pin::Pin,
@ -8,8 +10,6 @@ use std::{
thread, thread,
}; };
use log::info;
use tokio::{ use tokio::{
runtime::Runtime, runtime::Runtime,
sync::oneshot::{self, Receiver}, sync::oneshot::{self, Receiver},
@ -66,10 +66,9 @@ impl Drop for ThreadWorker {
} }
} }
pub type AsyncJobRecvStop = oneshot::Receiver<()>; #[async_trait]
pub type AsyncJobFut = Pin<Box<dyn Future<Output = ()> + Send + 'static>>; pub trait AsyncJob: Send + 'static {
pub trait AsyncJob { async fn do_work<F: Future<Output = ()> + Send>(self, stop_signal: F);
fn job(self, recv_stop: AsyncJobRecvStop) -> AsyncJobFut;
} }
pub struct AsyncWorker { pub struct AsyncWorker {
@ -80,7 +79,10 @@ pub struct AsyncWorker {
} }
impl AsyncWorker { impl AsyncWorker {
pub fn new<T: 'static + AsyncJob + Send>(name: &'static str, job: T) -> AsyncWorker { pub fn new<T>(name: &'static str, job: T) -> AsyncWorker
where
T: AsyncJob,
{
info!("Async worker starting {}", name); info!("Async worker starting {}", name);
let (send_stop, recv_stop) = oneshot::channel::<()>(); let (send_stop, recv_stop) = oneshot::channel::<()>();
@ -91,8 +93,11 @@ impl AsyncWorker {
.unwrap(); .unwrap();
let task = runtime.spawn(async move { let task = runtime.spawn(async move {
let fut = job.job(recv_stop); job
fut.await; .do_work(async move {
recv_stop.await;
})
.await;
}); });
AsyncWorker { AsyncWorker {