我正在尝试使用Actix通过WebSockets传达捕获事件,并使用https://github.com/foochi/how-store-closures-with-actix之类的东西来处理它们。这个想法是提供一个库,该库可用于存储闭包(事件),并在收到WebSockets文本消息时运行它们。

use actix::*;
use actix_web::ws::{Client, Message, ProtocolError};
use futures::Future;

struct MyActor {
    handler: Box<Fn(String) + 'static>,
}

impl Actor for MyActor {
    type Context = Context<Self>;
}

impl StreamHandler<Message, ProtocolError> for MyActor {
    fn handle(&mut self, msg: Message, _ctx: &mut Context<Self>) {
        match msg {
            Message::Text(text) => {
                (self.handler)(text)
            },
            _ => panic!(),
        }
    }
}

pub struct Event {
    handler: Box<Fn(String) + 'static>,
}

pub struct EventManager {
    events: Vec<Event>,
}

impl EventManager {

    pub fn new() -> Self {
        Self { events: vec![] }
    }

    pub fn capture<F>(&mut self, function: F)
    where
        F: for<'h> Fn(String) + 'static
    {
        let event = Event { handler: Box::new(function), };
        self.events.push(event);
    }

    pub fn run(&self) {
        let runner = System::new("example");
        let event = &self.events[0];

        Arbiter::spawn(
            Client::new("example")
                .connect()
                .map(|(reader, _writer)| {
                    MyActor::create(|ctx| {
                        MyActor::add_stream(reader, ctx);
                        MyActor { handler: event.handler }
                    });
                })
                .map_err(|err| {})
        );

        runner.run();
    }
}

我的问题是我有此错误:

error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
  --> src/events.rs:48:22
   |
48 |         let event = &self.events[0];
   |                      ^^^^^^^^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 46:5...
  --> src/events.rs:46:5
   |
46 | /     pub fn run(&self) {
47 | |         let runner = System::new("example");
48 | |         let event = &self.events[0];
49 | |
...  |
62 | |         runner.run();
63 | |     }
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/events.rs:48:22
   |
48 |         let event = &self.events[0];
   |                      ^^^^^^^^^^^
   = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the type `[closure@src/events.rs:54:37: 57:22 reader:actix_web::ws::ClientReader, event:&&events::Event]` will meet its required lifetime bounds
  --> src/events.rs:54:21
   |
54 |                     MyActor::create(|ctx| {
   |                     ^^^^^^^^^^^^^^^

我认为我部分理解了根本原因:我正在尝试将引用(事件)传递给StreamHandler,但是生命周期不匹配。

我该如何解决?

最佳答案

免责声明:由于这才是Actix的良好设计模式,因此我无法对此发表评论,因为我才刚刚开始了解框架。

正如您已经发现的那样,问题与生命周期要求有关。

Actor::create 方法需要闭包参数的'static生命周期:

fn create<F>(f: F) -> Addr<Self>
where
    Self: Actor<Context = Context<Self>>,
    F: FnOnce(&mut Context<Self>) -> Self + 'static,
&self.events[0]不满足'static生存期要求。

一种解决方案是将EventManager对象的所有权移至MyActor:
use actix::*;
use actix_web::ws::{Client, Message, ProtocolError};
use futures::Future;

struct MyActor {
    evm: EventManager,
}

impl Actor for MyActor {
    type Context = Context<Self>;
}

impl StreamHandler<Message, ProtocolError> for MyActor {
    fn handle(&mut self, msg: Message, _ctx: &mut Context<Self>) {
        match msg {
            Message::Text(text) => {
                // just for sake of demo: execute all event handlers
                for idx in 0..self.evm.events.len() {
                    (self.evm.events[idx].handler)(text.clone())
                }
            }
            _ => panic!(),
        }
    }
}

pub struct Event {
    handler: Box<Fn(String) + 'static>,
}

pub struct EventManager {
    events: Vec<Event>,
}

impl EventManager {
    pub fn new() -> Self {
        Self { events: vec![] }
    }

    pub fn capture<F>(&mut self, function: F)
    where
        F: Fn(String) + 'static,
    {
        let event = Event {
            handler: Box::new(function),
        };
        self.events.push(event);
    }

    pub fn run(self) {
        let runner = System::new("example");

        Arbiter::spawn(
            Client::new("http://127.0.0.1:8080/ws/")
                .connect()
                .map(|(reader, _writer)| {
                    MyActor::create(|ctx| {
                        MyActor::add_stream(reader, ctx);

                        // move event manager inside the actor
                        MyActor { evm: self }
                    });
                }).map_err(|err| println!("FATAL: {}", err)),
        );

        runner.run();
    }
}

pub fn ready() {
    let mut client = EventManager::new();

    client.capture(|data| println!("processing the data: {:?}", data));
    client.capture(|data| println!("processing AGAIN the data: {:?}", data));
    client.run();

    // here run client is not more available: it was moved inside the actor
}

fn main() {
    ready();
}

关于rust - 我如何存储闭包并与Actix actor一起使用?,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/52717989/

10-11 02:48