actix-channels - a wrapper around actix websockets to communicate with multiple people at once.

This crate is indented to be used in with actix-web

How to use:

You will need to include in your Cargo.toml - actix-web = "4.0.0-beta" - actix = "^0.12" - actix-web-actors = "4.0.0-beta" - actix_channels

Simple example ```

use actix::*; use actixweb::{get, web, App, HttpRequest, HttpResponse, HttpServer}; use actixweb_actors::ws; use std::env; use std::sync::Arc;

[actix_web::main]

async fn main() -> std::io::Result<()> { prettyenvlogger::init();

let port = env::var("PORT").unwrap_or_else(|_| "5000".to_owned());
let host = env::var("HOST").unwrap_or_else(|_| "0.0.0.0".to_owned());
let bind_interface: String = format!("{}:{}", host, port);
log::info!("Server Running: {}", &bind_interface);

//This is an actix actor
//boot up a single actor to handle message passing for ws channels
let ws_relay = actix_channels::ChannelRelay::new().start();

HttpServer::new(move || {
    App::new()
        .data(ws_relay.clone())
        .service(channel_example)
        .default_service(web::get().to(p404))
})
.bind(bind_interface)?
.run()
.await

}

pub async fn p404() -> HttpResponse { HttpResponse::NotFound().finish() }

[get("/channel_example")]

pub async fn channelexample( req: HttpRequest, stream: web::Payload, relay: web::Data>, ) -> HttpResponse { let channel = "/channelexample/itentifyerofchannel".tostring(); let hooks = Box::new(ChatRoomHooks { chatroomname: channel.clone(), }); let session = ChannelSession::new(&channel, relay.getref().clone(), hooks); let resp = ws::start(session, &req, stream); match resp { Ok(r) => r, Err(err) => { log::error!("SOCKET ERROR: {:?}", err); HttpResponse::build(actixweb::http::StatusCode::INTERNALSERVERERROR).finish() } } }

struct ChatRoomHooks { chatroom_name: String, }

use actixchannels::{ asynctrait, bytes, errors::ChannelError, ChannelRelay, ChannelSession, Dest, SessionHook, };

[async_trait]

impl SessionHook for ChatRoomHooks { // when a user connects to the channel to this... async fn onconnectbroadcast( &self, ) -> Result<(Option, Option, Dest), ChannelError> { let msg = format!("Hello you just joined: {}", self.chatroom_name); Ok((Some(msg), None, Dest::Everyone)) }

async fn client_to_channel_text(&self, text: String) -> Result<(String, Dest), ChannelError> {
    // Dest::Others will send to everyone except the sender
    Ok((text.into(), Dest::Others))
}

async fn client_to_channel_binary(
    &self,
    _bytes: bytes::Bytes,
) -> Result<(bytes::Bytes, Dest), ChannelError> {
    // if you want to block the message return a StopMessage
    Err(ChannelError::StopMessage)
}

fn channel_to_client_text(&self, text: Arc<String>) -> Result<String, ChannelError> {
    Ok(text.to_string())
}

fn channel_to_client_binary(
    &self,
    _bytes: Arc<bytes::Bytes>,
) -> Result<Arc<bytes::Bytes>, ChannelError> {
    // if you want to block the message return a StopMessage
    Err(ChannelError::StopMessage)
}

}

```