这是一个死胡同

遗憾的是，在评估了rust的愿景与我们的愿景之后，我们决定不再投资于rust。Osaka是devguard.io的重要构建块，但将不会有更新使其可供公众使用。

Osaka是受Go和Clay编程语言启发的Rust异步编程

其设计围绕continuations而非combinators，允许更易读的流程。

原因

Rust的tokio/futures生态系统是一个复杂的单体，对于我工作的2MB闪存mips盒子等受限设备来说效果不佳（tokio本身就有1Mb，加上所有futures combinators）。Osaka更像是为我工作的一个hack，而不是尝试超越futures.rs。

Continuations比combinators更容易理解，且不需要特定的运行时。

它看起来像什么

最初我计划实现一个proc macro，允许实现golang风格的chans

#[osaka]
pub fn something(bar: chan String) {
    let foo <- bar;
}

然而，由于对tokio的替代方案缺乏兴趣，我决定只做最少的努力，所以它看起来像这样

#[osaka]
pub fn something(bar: Channel<String>) {
    let foo = sync!(bar);
}

在实际代码中，你可能需要将某物注册到Poll实例，以便在poll准备好时重新激活闭包。

#[osaka]
pub fn something(poll: Poll) -> Result<Vec<String>, std::io::Error> {
    let sock    = mio::UdpSocket::bind(&"0.0.0.0:0".parse().unwrap())?;
    let token   = poll.register(&sock, mio::Ready::readable(), mio::PollOpt::level()).unwrap();

    loop {
        let mut buf = vec![0; 1024];
        if let Err(e) = sock.recv_from(&mut buf) {
            if e.kind() == std::io::ErrorKind::WouldBlock {
                yield poll.again(token, Some(Duration::from_secs(1)));
            }
        }
    }
}

pub fn main() {
    let poll = osaka::Poll::new();
    something(poll).run().unwrap();
}

注意，在后台没有单例运行时。整个executor（poll）被显式作为参数传递。Osaka故意比futures.rs简单。

这里有一些来自osaka-dns的实际代码

#[osaka]
pub fn resolve(poll: Poll, names: Vec<String>) -> Result<Vec<String>, Error> {
    //...
    let sock = UdpSocket::bind(&"0.0.0.0:0".parse().unwrap()).map_err(|e| Error::Io(e))?;
    let token = poll
        .register(&sock, mio::Ready::readable(), mio::PollOpt::level())
        .unwrap();
    //...

    // wait for a packet
    let pkt = match loop {
        // wait for the token to be ready, or timeout
        yield poll.again(token.clone(), Some(Duration::from_secs(5)));
        if now.elapsed() >= Duration::from_secs(5) {
            // timeout
            break None;
        }
        // now the socket _should_ be ready
        let (len, from) = match sock.recv_from(&mut buf) {
            Ok(v) => v,
            Err(e) => {
                // but just in case it isn't lets re-loop
                if e.kind() == std::io::ErrorKind::WouldBlock {
                    continue;
                }
                return Err(Error::Io(e));
            }
        };
    }

    // do stuff with the pkt
    // ...
}

pub fn test(poll: Poll) -> Result<(), Error> {
    let mut a = resolve(
        poll.clone(),
        vec![
            "3.carrier.devguard.io".into(),
        ],
    );
    let y = osaka::sync!(a);
    println!("resolved: {:?}", y);
    Ok(())
}

pub fn main() {
    tinylogger::init().ok();
    let poll = osaka::Poll::new();
    test(poll).run().unwrap();
}

与async/await的差异

最重要的功能之一是所有行为都定义良好。在任何情况下panic都是osaka的bug，而不是你的代码的bug。Osaka通常更适用于“编译通过，就可以发货”的工作流程。更倾向于明确性和“容易争论”而不是试图为了“容易编写”代码而隐藏事件流。

• Osaka没有隐式依赖
• osaka::Again包含一个continuation token，而不是隐藏的单例“任务”注册表。
• 就绪状态是明确的，这使得代码更容易争论“这里发生了什么”。
• 所有错误都是明确的
• 没有未定义的行为。恐慌是osaka的错误，而不是你的代码。
• 如RFC2394中所述的“热函数”在osaka中运行良好，因为延续点是明确的。