Struct actix_web_actors::HttpContext

pub struct HttpContext<A>
where
    A: Actor<Context = HttpContext<A>>,
{ /* private fields */ }

Execution context for HTTP actors

Example

A demonstration of server-sent events using actors:

use std::time::Duration;

use actix::{Actor, AsyncContext};
use actix_web::{get, http::header, App, HttpResponse, HttpServer};
use actix_web_actors::HttpContext;
use bytes::Bytes;

struct MyActor {
    count: usize,
}

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

    fn started(&mut self, ctx: &mut Self::Context) {
        ctx.run_later(Duration::from_millis(100), Self::write);
    }
}

impl MyActor {
    fn write(&mut self, ctx: &mut HttpContext<Self>) {
        self.count += 1;
        if self.count > 3 {
            ctx.write_eof()
        } else {
            ctx.write(Bytes::from(format!("event: count\ndata: {}\n\n", self.count)));
            ctx.run_later(Duration::from_millis(100), Self::write);
        }
    }
}

#[get("/")]
async fn index() -> HttpResponse {
    HttpResponse::Ok()
        .insert_header(header::ContentType(mime::TEXT_EVENT_STREAM))
        .streaming(HttpContext::create(MyActor { count: 0 }))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(index))
        .bind(("127.0.0.1", 8080))?
        .run()
        .await
}

Implementations

impl<A> HttpContext<A>

where A: Actor<Context = Self>,

pub fn create(actor: A) -> impl Stream<Item = Result<Bytes, Error>>

Create a new HTTP Context from a request and an actor

pub fn with_factory<F>(f: F) -> impl Stream<Item = Result<Bytes, Error>>

where F: FnOnce(&mut Self) -> A + 'static,

Create a new HTTP Context

impl<A> HttpContext<A>

where A: Actor<Context = Self>,

pub fn write(&mut self, data: Bytes)

Write payload

pub fn write_eof(&mut self)

Indicate end of streaming payload. Also this method calls Self::close.

pub fn handle(&self) -> SpawnHandle

Handle of the running future

SpawnHandle is the handle returned by AsyncContext::spawn() method.

Trait Implementations

impl<A> ActorContext for HttpContext<A>

where A: Actor<Context = Self>,

fn stop(&mut self)

Immediately stop processing incoming messages and switch to a stopping state. This only affects actors that are currently running. Future attempts to queue messages will fail.

fn terminate(&mut self)

Terminate actor execution unconditionally. This sets the actor into the stopped state. This causes future attempts to queue messages to fail.

fn state(&self) -> ActorState

Retrieve the current Actor execution state.

impl<A> AsyncContext<A> for HttpContext<A>

where A: Actor<Context = Self>,

fn spawn<F>(&mut self, fut: F) -> SpawnHandle

where F: ActorFuture<A, Output = ()> + 'static,

Spawns a future into the context.

fn wait<F>(&mut self, fut: F)

where F: ActorFuture<A, Output = ()> + 'static,

Spawns a future into the context, waiting for it to resolve.

fn cancel_future(&mut self, handle: SpawnHandle) -> bool

Cancels a spawned future.

fn address(&self) -> Addr<A>

Returns the address of the context.

fn waiting(&self) -> bool

Checks if the context is paused (waiting for future completion or stopping).

fn add_stream<S>(&mut self, fut: S) -> SpawnHandle

where S: Stream + 'static, A: StreamHandler<<S as Stream>::Item>,

Registers a stream with the context.

fn add_message_stream<S>(&mut self, fut: S)

where S: Stream + 'static, <S as Stream>::Item: Message, A: Handler<<S as Stream>::Item>,

Registers a stream with the context, ignoring errors.

fn notify<M>(&mut self, msg: M)

where A: Handler<M>, M: Message + 'static,

Sends the message msg to self. This bypasses the mailbox capacity, and will always queue the message. If the actor is in the stopped state, an error will be raised.

fn notify_later<M>(&mut self, msg: M, after: Duration) -> SpawnHandle

where A: Handler<M>, M: Message + 'static,

Sends the message msg to self after a specified period of time.

fn run_later<F>(&mut self, dur: Duration, f: F) -> SpawnHandle

where F: FnOnce(&mut A, &mut <A as Actor>::Context) + 'static,

Executes a closure after a specified period of time.

fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandle

where F: FnMut(&mut A, &mut <A as Actor>::Context) + 'static,

Spawns a job to execute the given closure periodically, at a specified fixed interval.

impl<A> AsyncContextParts<A> for HttpContext<A>

where A: Actor<Context = Self>,

fn parts(&mut self) -> &mut ContextParts<A>

impl<A, M> ToEnvelope<A, M> for HttpContext<A>

where A: Actor<Context = HttpContext<A>> + Handler<M>, M: Message + Send + 'static, M::Result: Send,

fn pack(msg: M, tx: Option<Sender<M::Result>>) -> Envelope<A>

Pack message into suitable envelope