2

我有一个小型 Rust 应用程序，它通过串行端口接收一些请求，进行一些处理并将结果保存在本地。我想将浏览器用作远程监视器，这样我就可以看到正在发生的一切，并且据我所知，SSE 非常适合这一点。

我尝试为此使用 Iron，但我找不到保持连接打开的方法。请求处理程序都需要返回 a Response，所以我不能继续发送数据。

这是我的（愚蠢的）尝试：

fn monitor(req: &mut Request) -> IronResult<Response> {
    let mut headers = Headers::new();
    headers.set(ContentType(Mime(TopLevel::Text, SubLevel::EventStream, vec![])));
    headers.set(CacheControl(vec![CacheDirective::NoCache]));

    println!("{:?}", req);

    let mut count = 0;
    loop {
        let mut response = Response::with((iron::status::Ok, format!("data: Count!:{}", count)));
        response.headers = headers.clone();
        return Ok(response); //obviously won't do what I want

        count += 1;
        std::thread::sleep_ms(1000);
    }
}
4

1 回答 1

4

我认为简短的回答是：你不能。当前版本的 Iron 是建立在单一的请求-响应交互之上的。这可以在您的代码中看到，因为发送响应的唯一方法是返回它；终止处理程序线程。

Iron 中存在一个问题，即利用 Hyper 中的新异步支持，它本身最近才被合并。甚至还有其他人尝试在 Hyper中使用服务器发送事件但尚未成功。

如果你愿意使用 Hyper master 分支，这样的事情似乎可以工作。不能保证这是一个好的解决方案，或者它不会耗尽您所有的 RAM 或 CPU。不过，它似乎可以在 Chrome 中使用。

extern crate hyper;

use std::time::{Duration, Instant};
use std::io::prelude::*;

use hyper::{Control, Encoder, Decoder, Next };
use hyper::server::{Server, HandlerFactory, Handler, Request, Response};
use hyper::status::StatusCode;
use hyper::header::ContentType;
use hyper::net::{HttpStream};


fn main() {
    let address = "0.0.0.0:7777".parse().expect("Invalid address");
    let server = Server::http(&address).expect("Invalid server");

    let (_listen, server_loop) = server.handle(MyFactory).expect("Failed to handle");

    println!("Starting...");
    server_loop.run();
}


struct MyFactory;

impl HandlerFactory<HttpStream> for MyFactory {
    type Output = MyHandler;

    fn create(&mut self, ctrl: Control) -> Self::Output {
        MyHandler {
            control: ctrl,
        }
    }
}


struct MyHandler {
    control: Control,
}

impl Handler<HttpStream> for MyHandler {
    fn on_request(&mut self, _request: Request<HttpStream>) -> Next {
        println!("A request was made");
        Next::write()
    }

    fn on_request_readable(&mut self, _request: &mut Decoder<HttpStream>) -> Next {
        println!("Request has data to read");
        Next::write()
    }

    fn on_response(&mut self, response: &mut Response) -> Next {
        println!("A response is ready to be sent");

        response.set_status(StatusCode::Ok);
        let mime = "text/event-stream".parse().expect("Invalid MIME");
        response.headers_mut().set(ContentType(mime));

        every_duration(Duration:: from_secs(1), self.control.clone());

        Next::wait()
    }

    fn on_response_writable(&mut self, response: &mut Encoder<HttpStream>) -> Next {
        println!("A response can be written");

        // Waited long enough, send some data
        let fake_data = r#"event: userconnect
data: {"username": "bobby", "time": "02:33:48"}"#;

        println!("Writing some data");
        response.write_all(fake_data.as_bytes()).expect("Failed to write");
        response.write_all(b"\n\n").expect("Failed to write");

        Next::wait()
    }
}

use std::thread;

fn every_duration(max_elapsed: Duration, control: Control) {
    let mut last_sent: Option<Instant> = None;
    let mut count = 0;

    thread::spawn(move || {
        loop {
            // Terminate after a fixed number of messages
            if count >= 5 {
                println!("Maximum messages sent, ending");
                control.ready(Next::end()).expect("Failed to trigger end");
                return;
            }

            // Wait a little while between messages
            if let Some(last) = last_sent {
                let elapsed = last.elapsed();
                println!("It's been {:?} since the last message", elapsed);

                if elapsed < max_elapsed {
                    let remaining = max_elapsed - elapsed;
                    println!("There's {:?} remaining", remaining);
                    thread::sleep(remaining);
                }
            }

            // Trigger a message
            control.ready(Next::write()).expect("Failed to trigger write");

            last_sent = Some(Instant::now());
            count += 1;
        }
    });
}

和客户端JS：

var evtSource = new EventSource("http://127.0.0.1:7777");

evtSource.addEventListener("userconnect", function(e) {
    const obj = JSON.parse(e.data);
    console.log(obj);
}, false);
于 2016-07-04T15:41:05.190 回答