use crate::messages::Message;
use crate::room::RoomId;
use sansio::Protocol;
use std::collections::VecDeque;
use std::convert::Infallible;
use std::time::Instant;
const MAX_QUEUED_MSG_COUNT: usize = 1024;
pub type ClientId = String;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ClientEvent {
Expired,
}
pub struct Client {
id: ClientId,
room_id: RoomId,
registered: bool,
msgs: VecDeque<String>,
reads: VecDeque<Message>,
writes: VecDeque<Message>,
events: VecDeque<ClientEvent>,
timeout: Option<Instant>,
is_initiator: bool,
}
impl Client {
pub fn new(id: ClientId, room_id: RoomId, timeout: Option<Instant>) -> Self {
Self {
id,
room_id,
registered: false,
msgs: VecDeque::new(),
reads: VecDeque::new(),
writes: VecDeque::new(),
events: VecDeque::new(),
timeout,
is_initiator: false,
}
}
pub fn id(&self) -> &ClientId {
&self.id
}
pub fn room_id(&self) -> &RoomId {
&self.room_id
}
pub fn is_initiator(&self) -> bool {
self.is_initiator
}
pub fn set_initiator(&mut self, is_initiator: bool) {
self.is_initiator = is_initiator;
}
pub fn set_timer(&mut self, timeout: Option<Instant>) {
self.timeout = timeout;
}
pub fn register(&mut self) -> Result<(), String> {
if self.registered {
return Err("Duplicated registration".to_string());
}
self.set_timer(None);
self.registered = true;
Ok(())
}
pub fn deregister(&mut self) {
self.registered = false;
}
pub fn registered(&self) -> bool {
self.registered
}
pub fn enqueue(&mut self, msg: String) -> Result<(), String> {
if self.msgs.len() >= MAX_QUEUED_MSG_COUNT {
return Err("Too many messages queued for the client".to_string());
}
self.msgs.push_back(msg);
Ok(())
}
pub fn drain_msgs(&mut self) -> Vec<String> {
self.msgs.drain(..).collect()
}
pub fn send_queued(&mut self, other: &mut Client) -> Result<(), String> {
if self.id == other.id || !other.registered {
return Err("Invalid client".to_string());
}
for msg in self.msgs.drain(..) {
other.handle_write(Message {
roomid: self.room_id.clone(),
clientid: other.id.clone(),
msg,
})?;
}
Ok(())
}
pub fn send(&mut self, other: &mut Client, msg: String) -> Result<(), String> {
if self.id == other.id {
return Err("Invalid client".to_string());
}
if other.registered {
other.handle_write(Message {
roomid: self.room_id.clone(),
clientid: other.id.clone(),
msg,
})?;
Ok(())
} else {
self.enqueue(msg)
}
}
}
impl Protocol<Message, Message, Infallible> for Client {
type Rout = Message;
type Wout = Message;
type Eout = ClientEvent;
type Error = String;
type Time = Instant;
fn handle_read(&mut self, msg: Message) -> Result<(), Self::Error> {
self.reads.push_back(msg);
Ok(())
}
fn poll_read(&mut self) -> Option<Self::Rout> {
self.reads.pop_front()
}
fn handle_write(&mut self, msg: Message) -> Result<(), Self::Error> {
self.writes.push_back(msg);
Ok(())
}
fn poll_write(&mut self) -> Option<Self::Wout> {
self.writes.pop_front()
}
fn poll_event(&mut self) -> Option<Self::Eout> {
self.events.pop_front()
}
fn handle_timeout(&mut self, now: Self::Time) -> Result<(), Self::Error> {
if let Some(deadline) = self.timeout
&& now >= deadline
&& !self.registered
{
self.events.push_back(ClientEvent::Expired);
self.timeout = None;
}
Ok(())
}
fn poll_timeout(&mut self) -> Option<Self::Time> {
self.timeout
}
fn close(&mut self) -> Result<(), Self::Error> {
self.deregister();
Ok(())
}
}