从 cc::Build 制作一个 rust wasm bindgen 未来示例

Answer 1

事实证明，cc::Build 用例/后者的唯一用例不需要 wasm-bindgen。

use serde::Serialize;
use std::{
    collections::HashMap,
    future::Future,
    mem,
    pin::Pin,
    sync::mpsc::{channel, Sender},
    sync::{Arc, Mutex},
    task::{Context, Poll, Waker},
    thread::{self, JoinHandle},
    time::Duration,
};
#[derive(Serialize)]
struct Product {
    ivity: String,
}

显然，以下是从async{block.await}“任务”创建Future 的最低要求。

//(1) Reactor
enum TaskState {
    Ready,
    NotReady(Waker),
    Finished,
} //https://cfsamson.github.io/books-futures-explained/6_future_example.html
struct Reactor {
    dispatcher: Sender<Event>,
    handle: Option<JoinHandle<()>>,
    tasks: HashMap<usize, TaskState>,
}
#[derive(Debug)]
enum Event {
    Close,
    Timeout(u64, usize),
}
impl Reactor {
    fn new() -> Arc<Mutex<Box<Self>>> {
        let (tx, rx) = channel::<Event>();
        let reactor = Arc::new(Mutex::new(Box::new(Reactor {
            dispatcher: tx,
            handle: None,
            tasks: HashMap::new(),
        })));
        let reactor_clone = Arc::downgrade(&reactor);
        let handle = thread::spawn(move || {
            let mut handles = vec![];
            for event in rx {
                println!("REACTOR: {:?}", event);
                let reactor = reactor_clone.clone();
                match event {
                    Event::Close => break,
                    Event::Timeout(duration, id) => {
                        let event_handle = thread::spawn(move || {
                            thread::sleep(Duration::from_secs(duration));
                            let reactor = reactor.upgrade().unwrap();
                            reactor.lock().map(|mut r| r.wake(id)).unwrap();
                        });
                        handles.push(event_handle);
                    }
                }
            }
            handles
                .into_iter()
                .for_each(|handle| handle.join().unwrap());
        });
        reactor.lock().map(|mut r| r.handle = Some(handle)).unwrap();
        reactor
    }
    fn wake(&mut self, id: usize) {
        self.tasks
            .get_mut(&id)
            .map(|state| {
                match mem::replace(state, TaskState::Ready) {
                    TaskState::NotReady(waker) => waker.wake(),
                    TaskState::Finished => {
                        panic!("Called 'wake' twice on task: {}", id)
                    }
                    _ => unreachable!(),
                }
            })
            .unwrap();
    }
    fn register(&mut self, duration: u64, waker: Waker, id: usize) {
        if self.tasks.insert(id, TaskState::NotReady(waker)).is_some() {
            panic!("Tried to insert a task with id: '{}', twice!", id);
        }
        self.dispatcher.send(Event::Timeout(duration, id)).unwrap();
    }
    fn is_ready(&self, id: usize) -> bool {
        self.tasks
            .get(&id)
            .map(|state| match state {
                TaskState::Ready => true,
                _ => false,
            })
            .unwrap_or(false)
    }
}

impl Drop for Reactor {
    fn drop(&mut self) {
        self.dispatcher.send(Event::Close).unwrap();
        self.handle.take().map(|h| h.join().unwrap()).unwrap();
    }
}
//(2) Task
#[derive(Clone)]
pub struct Task {
    app: u64,
    reactor: Arc<Mutex<Box<Reactor>>>,
    id: usize,
}
impl Task {
    fn new(pathstr: &str, reactor: Arc<Mutex<Box<Reactor>>>, id: usize) -> Self {
        //Task {
        Task {
            app: match pathstr {
                //let s: String = match pathstr {
                "/" => {
                    fn pathify(path: &str) -> std::path::PathBuf {
                        let mut input_file = std::path::PathBuf::new();
                        let _arr: () =
                            path.split("/").map(|x| input_file.push(x)).collect();
                        return input_file;
                    }
                    let lock: std::path::PathBuf = pathify("./exec.c");
                    let appel = cc::Build::new().file(lock).expand();
                    //String::from_utf8(appel).unwrap()
                    u64::from_be_bytes(appel.try_into().expect(""))
                    //.iter().collect()
                }
                &_ => u64::from_be_bytes("".as_bytes().try_into().expect("")),
                //};
                //u64::from_str_radix(s.expect("")) //,16
            },
            reactor,
            id,
        }
    }
}
// (3) Future implementation
impl Future for Task {
    type Output = usize;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        //let mut r = self.app;
        let mut r = self.reactor.lock().unwrap();
        if r.is_ready(self.id) {
            *r.tasks.get_mut(&self.id).unwrap() = TaskState::Finished;
            Poll::Ready(self.id)
        } else if r.tasks.contains_key(&self.id) {
            r.tasks
                .insert(self.id, TaskState::NotReady(cx.waker().clone()));
            Poll::Pending
        } else {
            r.register(self.app, cx.waker().clone(), self.id);
            Poll::Pending
        }
    }
}
let path = req.path(); //longer lived with let
let pathstr: &str = path.as_str();
let reactor = Reactor::new();
let id = 1;
let future1 = Task::new(pathstr, reactor.clone(), id);
let fut1 = async {
    future1.await
    //let val = future1.await;
    //println!("Got {} at time: {:.2}.", val, start.elapsed().as_secs_f32());
};
Response::from_json(&Product {
    ivity: fut1.await.to_string(),
})

在我构建它时，我将使用use wasm_bindgen::prelude::*; use wasm_bindgen_futures::{JsFuture, future_to_promise}; 对其进行编辑，但我不想用这个通过的 rustup 分析器进一步误导这个问题（也就是我现在正在测试，请记住，VS 代码像终端一样钝，可能需要关闭一次）。