lemmy/crates/websocket/src/routes.rs

196 lines
5.0 KiB
Rust
Raw Normal View History

use crate::{
chat_server::ChatServer,
2021-02-22 18:04:32 +00:00
messages::{Connect, Disconnect, StandardMessage, WsMessage},
LemmyContext,
};
use actix::prelude::*;
use actix_web::{web, Error, HttpRequest, HttpResponse};
use actix_web_actors::ws;
use lemmy_utils::{rate_limit::RateLimit, utils::get_ip, ConnectionId, IpAddr};
2020-05-16 14:04:08 +00:00
use std::time::{Duration, Instant};
2021-11-23 12:16:47 +00:00
use tracing::{debug, error, info};
/// How often heartbeat pings are sent
const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);
/// How long before lack of client response causes a timeout
const CLIENT_TIMEOUT: Duration = Duration::from_secs(10);
/// Entry point for our route
2021-03-29 21:48:37 +00:00
pub async fn chat_route(
req: HttpRequest,
stream: web::Payload,
context: web::Data<LemmyContext>,
rate_limiter: web::Data<RateLimit>,
) -> Result<HttpResponse, Error> {
ws::start(
2021-02-22 18:04:32 +00:00
WsSession {
cs_addr: context.chat_server().to_owned(),
id: 0,
hb: Instant::now(),
2020-04-20 18:02:25 +00:00
ip: get_ip(&req.connection_info()),
rate_limiter: rate_limiter.as_ref().to_owned(),
},
&req,
stream,
)
}
2021-02-22 18:04:32 +00:00
struct WsSession {
cs_addr: Addr<ChatServer>,
/// unique session id
id: ConnectionId,
ip: IpAddr,
/// Client must send ping at least once per 10 seconds (CLIENT_TIMEOUT),
/// otherwise we drop connection.
hb: Instant,
/// A rate limiter for websocket joins
rate_limiter: RateLimit,
}
2021-02-22 18:04:32 +00:00
impl Actor for WsSession {
type Context = ws::WebsocketContext<Self>;
/// Method is called on actor start.
/// We register ws session with ChatServer
fn started(&mut self, ctx: &mut Self::Context) {
// we'll start heartbeat process on session start.
self.hb(ctx);
// register self in chat server. `AsyncContext::wait` register
// future within context, but context waits until this future resolves
// before processing any other events.
// across all routes within application
let addr = ctx.address();
if !self.rate_limit_check(ctx) {
return;
}
self
.cs_addr
.send(Connect {
addr: addr.recipient(),
ip: self.ip.to_owned(),
})
.into_actor(self)
.then(|res, act, ctx| {
match res {
Ok(res) => act.id = res,
// something is wrong with chat server
_ => ctx.stop(),
}
2020-01-10 22:41:08 +00:00
actix::fut::ready(())
})
.wait(ctx);
}
fn stopping(&mut self, _ctx: &mut Self::Context) -> Running {
// notify chat server
self.cs_addr.do_send(Disconnect {
id: self.id,
ip: self.ip.to_owned(),
});
Running::Stop
}
}
/// Handle messages from chat server, we simply send it to peer websocket
/// These are room messages, IE sent to others in the room
2021-02-22 18:04:32 +00:00
impl Handler<WsMessage> for WsSession {
type Result = ();
2021-02-22 18:04:32 +00:00
fn handle(&mut self, msg: WsMessage, ctx: &mut Self::Context) {
ctx.text(msg.0);
}
}
/// WebSocket message handler
2021-02-22 18:04:32 +00:00
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for WsSession {
2020-01-10 22:41:08 +00:00
fn handle(&mut self, result: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
if !self.rate_limit_check(ctx) {
return;
}
2020-01-10 22:41:08 +00:00
let message = match result {
Ok(m) => m,
Err(e) => {
2020-03-13 15:08:42 +00:00
error!("{}", e);
2020-01-10 22:41:08 +00:00
return;
}
};
match message {
ws::Message::Ping(msg) => {
self.hb = Instant::now();
ctx.pong(&msg);
}
ws::Message::Pong(_) => {
self.hb = Instant::now();
}
ws::Message::Text(text) => {
let m = text.trim().to_owned();
self
.cs_addr
.send(StandardMessage {
id: self.id,
msg: m,
})
.into_actor(self)
.then(|res, _, ctx| {
match res {
Ok(Ok(res)) => ctx.text(res),
2020-04-21 20:40:03 +00:00
Ok(Err(_)) => {}
Err(e) => error!("{}", &e),
}
2020-01-10 22:41:08 +00:00
actix::fut::ready(())
})
2020-04-22 04:29:25 +00:00
.spawn(ctx);
}
2020-03-13 15:08:42 +00:00
ws::Message::Binary(_bin) => info!("Unexpected binary"),
ws::Message::Close(_) => {
ctx.stop();
}
_ => {}
}
}
}
2021-02-22 18:04:32 +00:00
impl WsSession {
/// helper method that sends ping to client every second.
///
/// also this method checks heartbeats from client
fn hb(&self, ctx: &mut ws::WebsocketContext<Self>) {
ctx.run_interval(HEARTBEAT_INTERVAL, |act, ctx| {
// check client heartbeats
if Instant::now().duration_since(act.hb) > CLIENT_TIMEOUT {
// heartbeat timed out
debug!("Websocket Client heartbeat failed, disconnecting!");
// notify chat server
act.cs_addr.do_send(Disconnect {
id: act.id,
ip: act.ip.to_owned(),
});
// stop actor
ctx.stop();
// don't try to send a ping
return;
}
2020-01-10 22:41:08 +00:00
ctx.ping(b"");
});
}
/// Check the rate limit, and stop the ctx if it fails
fn rate_limit_check(&mut self, ctx: &mut ws::WebsocketContext<Self>) -> bool {
let check = self.rate_limiter.message().check(self.ip.to_owned());
if !check {
debug!("Websocket join with IP: {} has been rate limited.", self.ip);
ctx.stop()
}
check
}
}