aboutsummaryrefslogtreecommitdiffstats
path: root/mumd/src/state.rs
diff options
context:
space:
mode:
Diffstat (limited to 'mumd/src/state.rs')
-rw-r--r--mumd/src/state.rs781
1 files changed, 424 insertions, 357 deletions
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 46df421..a553e18 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -14,33 +14,38 @@ use mumble_protocol::control::msgs;
use mumble_protocol::control::ControlPacket;
use mumble_protocol::ping::PongPacket;
use mumble_protocol::voice::Serverbound;
-use mumlib::command::{Command, CommandResponse};
+use mumlib::command::{Command, CommandResponse, MessageTarget};
use mumlib::config::Config;
-use mumlib::error::ChannelIdentifierError;
use mumlib::Error;
use crate::state::user::UserDiff;
-use std::net::{SocketAddr, ToSocketAddrs};
+use std::{iter, net::{SocketAddr, ToSocketAddrs}, sync::{Arc, RwLock}};
use tokio::sync::{mpsc, watch};
macro_rules! at {
($event:expr, $generator:expr) => {
- ExecutionContext::TcpEvent($event, Box::new($generator))
+ ExecutionContext::TcpEventCallback($event, Box::new($generator))
};
}
macro_rules! now {
($data:expr) => {
- ExecutionContext::Now(Box::new(move || $data))
+ ExecutionContext::Now(Box::new(move || Box::new(iter::once($data))))
};
}
+type Responses = Box<dyn Iterator<Item = mumlib::error::Result<Option<CommandResponse>>>>;
+
//TODO give me a better name
pub enum ExecutionContext {
- TcpEvent(
+ TcpEventCallback(
+ TcpEvent,
+ Box<dyn FnOnce(TcpEventData) -> Responses>,
+ ),
+ TcpEventSubscriber(
TcpEvent,
- Box<dyn FnOnce(TcpEventData) -> mumlib::error::Result<Option<CommandResponse>>>,
+ Box<dyn FnMut(TcpEventData, &mut mpsc::UnboundedSender<mumlib::error::Result<Option<CommandResponse>>>) -> bool>,
),
- Now(Box<dyn FnOnce() -> mumlib::error::Result<Option<CommandResponse>>>),
+ Now(Box<dyn FnOnce() -> Responses>),
Ping(
Box<dyn FnOnce() -> mumlib::error::Result<SocketAddr>>,
Box<dyn FnOnce(Option<PongPacket>) -> mumlib::error::Result<Option<CommandResponse>> + Send>,
@@ -59,6 +64,7 @@ pub struct State {
server: Option<Server>,
audio_input: AudioInput,
audio_output: AudioOutput,
+ message_buffer: Vec<(String, u32)>,
phase_watcher: (watch::Sender<StatePhase>, watch::Receiver<StatePhase>),
}
@@ -79,355 +85,13 @@ impl State {
server: None,
audio_input,
audio_output,
+ message_buffer: Vec::new(),
phase_watcher,
};
state.reload_config();
Ok(state)
}
- pub fn handle_command(
- &mut self,
- command: Command,
- packet_sender: &mut mpsc::UnboundedSender<ControlPacket<Serverbound>>,
- connection_info_sender: &mut watch::Sender<Option<ConnectionInfo>>,
- ) -> ExecutionContext {
- match command {
- Command::ChannelJoin { channel_identifier } => {
- if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected(_)) {
- return now!(Err(Error::Disconnected));
- }
-
- let channels = self.server().unwrap().channels();
-
- let matches = channels
- .iter()
- .map(|e| (e.0, e.1.path(channels)))
- .filter(|e| e.1.ends_with(&channel_identifier))
- .collect::<Vec<_>>();
- let id = match matches.len() {
- 0 => {
- let soft_matches = channels
- .iter()
- .map(|e| (e.0, e.1.path(channels).to_lowercase()))
- .filter(|e| e.1.ends_with(&channel_identifier.to_lowercase()))
- .collect::<Vec<_>>();
- match soft_matches.len() {
- 0 => {
- return now!(Err(Error::ChannelIdentifierError(
- channel_identifier,
- ChannelIdentifierError::Invalid
- )))
- }
- 1 => *soft_matches.get(0).unwrap().0,
- _ => {
- return now!(Err(Error::ChannelIdentifierError(
- channel_identifier,
- ChannelIdentifierError::Invalid
- )))
- }
- }
- }
- 1 => *matches.get(0).unwrap().0,
- _ => {
- return now!(Err(Error::ChannelIdentifierError(
- channel_identifier,
- ChannelIdentifierError::Ambiguous
- )))
- }
- };
-
- let mut msg = msgs::UserState::new();
- msg.set_session(self.server.as_ref().unwrap().session_id().unwrap());
- msg.set_channel_id(id);
- packet_sender.send(msg.into()).unwrap();
- now!(Ok(None))
- }
- Command::ChannelList => {
- if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected(_)) {
- return now!(Err(Error::Disconnected));
- }
- let list = channel::into_channel(
- self.server.as_ref().unwrap().channels(),
- self.server.as_ref().unwrap().users(),
- );
- now!(Ok(Some(CommandResponse::ChannelList { channels: list })))
- }
- Command::ConfigReload => {
- self.reload_config();
- now!(Ok(None))
- }
- Command::DeafenSelf(toggle) => {
- if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected(_)) {
- return now!(Err(Error::Disconnected));
- }
-
- let server = self.server().unwrap();
- let action = match (toggle, server.muted(), server.deafened()) {
- (Some(false), false, false) => None,
- (Some(false), false, true) => Some((false, false)),
- (Some(false), true, false) => None,
- (Some(false), true, true) => Some((true, false)),
- (Some(true), false, false) => Some((false, true)),
- (Some(true), false, true) => None,
- (Some(true), true, false) => Some((true, true)),
- (Some(true), true, true) => None,
- (None, false, false) => Some((false, true)),
- (None, false, true) => Some((false, false)),
- (None, true, false) => Some((true, true)),
- (None, true, true) => Some((true, false)),
- };
-
- let mut new_deaf = None;
- if let Some((mute, deafen)) = action {
- if server.deafened() != deafen {
- self.audio_output.play_effect(if deafen {
- NotificationEvents::Deafen
- } else {
- NotificationEvents::Undeafen
- });
- } else if server.muted() != mute {
- self.audio_output.play_effect(if mute {
- NotificationEvents::Mute
- } else {
- NotificationEvents::Unmute
- });
- }
- let mut msg = msgs::UserState::new();
- if server.muted() != mute {
- msg.set_self_mute(mute);
- } else if !mute && !deafen && server.deafened() {
- msg.set_self_mute(false);
- }
- if server.deafened() != deafen {
- msg.set_self_deaf(deafen);
- new_deaf = Some(deafen);
- }
- let server = self.server_mut().unwrap();
- server.set_muted(mute);
- server.set_deafened(deafen);
- packet_sender.send(msg.into()).unwrap();
- }
-
- now!(Ok(new_deaf.map(|b| CommandResponse::DeafenStatus { is_deafened: b })))
- }
- Command::InputVolumeSet(volume) => {
- self.audio_input.set_volume(volume);
- now!(Ok(None))
- }
- Command::MuteOther(string, toggle) => {
- if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected(_)) {
- return now!(Err(Error::Disconnected));
- }
-
- let id = self
- .server_mut()
- .unwrap()
- .users_mut()
- .iter_mut()
- .find(|(_, user)| user.name() == string);
-
- let (id, user) = match id {
- Some(id) => (*id.0, id.1),
- None => return now!(Err(Error::InvalidUsername(string))),
- };
-
- let action = match toggle {
- Some(state) => {
- if user.suppressed() != state {
- Some(state)
- } else {
- None
- }
- }
- None => Some(!user.suppressed()),
- };
-
- if let Some(action) = action {
- user.set_suppressed(action);
- self.audio_output.set_mute(id, action);
- }
-
- return now!(Ok(None));
- }
- Command::MuteSelf(toggle) => {
- if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected(_)) {
- return now!(Err(Error::Disconnected));
- }
-
- let server = self.server().unwrap();
- let action = match (toggle, server.muted(), server.deafened()) {
- (Some(false), false, false) => None,
- (Some(false), false, true) => Some((false, false)),
- (Some(false), true, false) => Some((false, false)),
- (Some(false), true, true) => Some((false, false)),
- (Some(true), false, false) => Some((true, false)),
- (Some(true), false, true) => None,
- (Some(true), true, false) => None,
- (Some(true), true, true) => None,
- (None, false, false) => Some((true, false)),
- (None, false, true) => Some((false, false)),
- (None, true, false) => Some((false, false)),
- (None, true, true) => Some((false, false)),
- };
-
- let mut new_mute = None;
- if let Some((mute, deafen)) = action {
- if server.deafened() != deafen {
- self.audio_output.play_effect(if deafen {
- NotificationEvents::Deafen
- } else {
- NotificationEvents::Undeafen
- });
- } else if server.muted() != mute {
- self.audio_output.play_effect(if mute {
- NotificationEvents::Mute
- } else {
- NotificationEvents::Unmute
- });
- }
- let mut msg = msgs::UserState::new();
- if server.muted() != mute {
- msg.set_self_mute(mute);
- new_mute = Some(mute)
- } else if !mute && !deafen && server.deafened() {
- msg.set_self_mute(false);
- new_mute = Some(false)
- }
- if server.deafened() != deafen {
- msg.set_self_deaf(deafen);
- }
- let server = self.server_mut().unwrap();
- server.set_muted(mute);
- server.set_deafened(deafen);
- packet_sender.send(msg.into()).unwrap();
- }
-
- now!(Ok(new_mute.map(|b| CommandResponse::MuteStatus { is_muted: b })))
- }
- Command::OutputVolumeSet(volume) => {
- self.audio_output.set_volume(volume);
- now!(Ok(None))
- }
- Command::Ping => {
- now!(Ok(Some(CommandResponse::Pong)))
- }
- Command::ServerConnect {
- host,
- port,
- username,
- password,
- accept_invalid_cert,
- } => {
- if !matches!(*self.phase_receiver().borrow(), StatePhase::Disconnected) {
- return now!(Err(Error::AlreadyConnected));
- }
- let mut server = Server::new();
- *server.username_mut() = Some(username);
- *server.password_mut() = password;
- *server.host_mut() = Some(format!("{}:{}", host, port));
- self.server = Some(server);
- self.phase_watcher
- .0
- .send(StatePhase::Connecting)
- .unwrap();
-
- let socket_addr = match (host.as_ref(), port)
- .to_socket_addrs()
- .map(|mut e| e.next())
- {
- Ok(Some(v)) => v,
- _ => {
- warn!("Error parsing server addr");
- return now!(Err(Error::InvalidServerAddr(host, port)));
- }
- };
- connection_info_sender
- .send(Some(ConnectionInfo::new(
- socket_addr,
- host,
- accept_invalid_cert,
- )))
- .unwrap();
- at!(TcpEvent::Connected, |res| {
- //runs the closure when the client is connected
- if let TcpEventData::Connected(res) = res {
- res.map(|msg| {
- Some(CommandResponse::ServerConnect {
- welcome_message: if msg.has_welcome_text() {
- Some(msg.get_welcome_text().to_string())
- } else {
- None
- },
- })
- })
- } else {
- unreachable!("callback should be provided with a TcpEventData::Connected");
- }
- })
- }
- Command::ServerDisconnect => {
- if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected(_)) {
- return now!(Err(Error::Disconnected));
- }
-
- self.server = None;
-
- self.phase_watcher
- .0
- .send(StatePhase::Disconnected)
- .unwrap();
- self.audio_output.play_effect(NotificationEvents::ServerDisconnect);
- now!(Ok(None))
- }
- Command::ServerStatus { host, port } => ExecutionContext::Ping(
- Box::new(move || {
- match (host.as_str(), port)
- .to_socket_addrs()
- .map(|mut e| e.next())
- {
- Ok(Some(v)) => Ok(v),
- _ => Err(Error::InvalidServerAddr(host, port)),
- }
- }),
- Box::new(move |pong| {
- Ok(pong.map(|pong| CommandResponse::ServerStatus {
- version: pong.version,
- users: pong.users,
- max_users: pong.max_users,
- bandwidth: pong.bandwidth,
- }))
- }),
- ),
- Command::Status => {
- if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected(_)) {
- return now!(Err(Error::Disconnected));
- }
- let state = self.server.as_ref().unwrap().into();
- now!(Ok(Some(CommandResponse::Status {
- server_state: state, //guaranteed not to panic because if we are connected, server is guaranteed to be Some
- })))
- }
- Command::UserVolumeSet(string, volume) => {
- if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected(_)) {
- return now!(Err(Error::Disconnected));
- }
- let user_id = match self
- .server()
- .unwrap()
- .users()
- .iter()
- .find(|e| e.1.name() == string)
- .map(|e| *e.0)
- {
- None => return now!(Err(Error::InvalidUsername(string))),
- Some(v) => v,
- };
-
- self.audio_output.set_user_volume(user_id, volume);
- now!(Ok(None))
- }
- }
- }
pub fn parse_user_state(&mut self, msg: msgs::UserState) {
if !msg.has_session() {
@@ -590,6 +254,10 @@ impl State {
self.audio_output.load_sound_effects(sound_effects);
}
}
+
+ pub fn register_message(&mut self, msg: (String, u32)) {
+ self.message_buffer.push(msg);
+ }
pub fn broadcast_phase(&self, phase: StatePhase) {
self.phase_watcher
@@ -609,12 +277,6 @@ impl State {
pub fn audio_output(&self) -> &AudioOutput {
&self.audio_output
}
- pub fn audio_input_mut(&mut self) -> &mut AudioInput {
- &mut self.audio_input
- }
- pub fn audio_output_mut(&mut self) -> &mut AudioOutput {
- &mut self.audio_output
- }
pub fn phase_receiver(&self) -> watch::Receiver<StatePhase> {
self.phase_watcher.1.clone()
}
@@ -640,4 +302,409 @@ impl State {
.1
.channel()
}
+
+ /// Gets the username of a user with id `user` connected to the same server that we are connected to.
+ /// If we are connected to the server but the user with the id doesn't exist, the string "Unknown user {id}"
+ /// is returned instead. If we aren't connected to a server, None is returned instead.
+ fn get_user_name(&self, user: u32) -> Option<String> {
+ self.server()
+ .map(|e| e.users()
+ .get(&user).map(|e| e.name().to_string())
+ .unwrap_or(format!("Unknown user {}", user)))
+ }
+}
+
+pub fn handle_command(
+ og_state: Arc<RwLock<State>>,
+ command: Command,
+ packet_sender: &mut mpsc::UnboundedSender<ControlPacket<Serverbound>>,
+ connection_info_sender: &mut watch::Sender<Option<ConnectionInfo>>,
+) -> ExecutionContext {
+ let mut state = og_state.write().unwrap();
+ match command {
+ Command::ChannelJoin { channel_identifier } => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+
+ let id = match state.server().unwrap().channel_name(&channel_identifier) {
+ Ok((id, _)) => id,
+ Err(e) => return now!(Err(Error::ChannelIdentifierError(channel_identifier, e))),
+ };
+
+ let mut msg = msgs::UserState::new();
+ msg.set_session(state.server.as_ref().unwrap().session_id().unwrap());
+ msg.set_channel_id(id);
+ packet_sender.send(msg.into()).unwrap();
+ now!(Ok(None))
+ }
+ Command::ChannelList => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+ let list = channel::into_channel(
+ state.server.as_ref().unwrap().channels(),
+ state.server.as_ref().unwrap().users(),
+ );
+ now!(Ok(Some(CommandResponse::ChannelList { channels: list })))
+ }
+ Command::ConfigReload => {
+ state.reload_config();
+ now!(Ok(None))
+ }
+ Command::DeafenSelf(toggle) => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+
+ let server = state.server().unwrap();
+ let action = match (toggle, server.muted(), server.deafened()) {
+ (Some(false), false, false) => None,
+ (Some(false), false, true) => Some((false, false)),
+ (Some(false), true, false) => None,
+ (Some(false), true, true) => Some((true, false)),
+ (Some(true), false, false) => Some((false, true)),
+ (Some(true), false, true) => None,
+ (Some(true), true, false) => Some((true, true)),
+ (Some(true), true, true) => None,
+ (None, false, false) => Some((false, true)),
+ (None, false, true) => Some((false, false)),
+ (None, true, false) => Some((true, true)),
+ (None, true, true) => Some((true, false)),
+ };
+
+ let mut new_deaf = None;
+ if let Some((mute, deafen)) = action {
+ if server.deafened() != deafen {
+ state.audio_output.play_effect(if deafen {
+ NotificationEvents::Deafen
+ } else {
+ NotificationEvents::Undeafen
+ });
+ } else if server.muted() != mute {
+ state.audio_output.play_effect(if mute {
+ NotificationEvents::Mute
+ } else {
+ NotificationEvents::Unmute
+ });
+ }
+ let mut msg = msgs::UserState::new();
+ if server.muted() != mute {
+ msg.set_self_mute(mute);
+ } else if !mute && !deafen && server.deafened() {
+ msg.set_self_mute(false);
+ }
+ if server.deafened() != deafen {
+ msg.set_self_deaf(deafen);
+ new_deaf = Some(deafen);
+ }
+ let server = state.server_mut().unwrap();
+ server.set_muted(mute);
+ server.set_deafened(deafen);
+ packet_sender.send(msg.into()).unwrap();
+ }
+
+ now!(Ok(new_deaf.map(|b| CommandResponse::DeafenStatus { is_deafened: b })))
+ }
+ Command::InputVolumeSet(volume) => {
+ state.audio_input.set_volume(volume);
+ now!(Ok(None))
+ }
+ Command::MuteOther(string, toggle) => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+
+ let id = state
+ .server_mut()
+ .unwrap()
+ .users_mut()
+ .iter_mut()
+ .find(|(_, user)| user.name() == string);
+
+ let (id, user) = match id {
+ Some(id) => (*id.0, id.1),
+ None => return now!(Err(Error::InvalidUsername(string))),
+ };
+
+ let action = match toggle {
+ Some(state) => {
+ if user.suppressed() != state {
+ Some(state)
+ } else {
+ None
+ }
+ }
+ None => Some(!user.suppressed()),
+ };
+
+ if let Some(action) = action {
+ user.set_suppressed(action);
+ state.audio_output.set_mute(id, action);
+ }
+
+ return now!(Ok(None));
+ }
+ Command::MuteSelf(toggle) => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+
+ let server = state.server().unwrap();
+ let action = match (toggle, server.muted(), server.deafened()) {
+ (Some(false), false, false) => None,
+ (Some(false), false, true) => Some((false, false)),
+ (Some(false), true, false) => Some((false, false)),
+ (Some(false), true, true) => Some((false, false)),
+ (Some(true), false, false) => Some((true, false)),
+ (Some(true), false, true) => None,
+ (Some(true), true, false) => None,
+ (Some(true), true, true) => None,
+ (None, false, false) => Some((true, false)),
+ (None, false, true) => Some((false, false)),
+ (None, true, false) => Some((false, false)),
+ (None, true, true) => Some((false, false)),
+ };
+
+ let mut new_mute = None;
+ if let Some((mute, deafen)) = action {
+ if server.deafened() != deafen {
+ state.audio_output.play_effect(if deafen {
+ NotificationEvents::Deafen
+ } else {
+ NotificationEvents::Undeafen
+ });
+ } else if server.muted() != mute {
+ state.audio_output.play_effect(if mute {
+ NotificationEvents::Mute
+ } else {
+ NotificationEvents::Unmute
+ });
+ }
+ let mut msg = msgs::UserState::new();
+ if server.muted() != mute {
+ msg.set_self_mute(mute);
+ new_mute = Some(mute)
+ } else if !mute && !deafen && server.deafened() {
+ msg.set_self_mute(false);
+ new_mute = Some(false)
+ }
+ if server.deafened() != deafen {
+ msg.set_self_deaf(deafen);
+ }
+ let server = state.server_mut().unwrap();
+ server.set_muted(mute);
+ server.set_deafened(deafen);
+ packet_sender.send(msg.into()).unwrap();
+ }
+
+ now!(Ok(new_mute.map(|b| CommandResponse::MuteStatus { is_muted: b })))
+ }
+ Command::OutputVolumeSet(volume) => {
+ state.audio_output.set_volume(volume);
+ now!(Ok(None))
+ }
+ Command::Ping => {
+ now!(Ok(Some(CommandResponse::Pong)))
+ }
+ Command::ServerConnect {
+ host,
+ port,
+ username,
+ password,
+ accept_invalid_cert,
+ } => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Disconnected) {
+ return now!(Err(Error::AlreadyConnected));
+ }
+ let mut server = Server::new();
+ *server.username_mut() = Some(username);
+ *server.password_mut() = password;
+ *server.host_mut() = Some(format!("{}:{}", host, port));
+ state.server = Some(server);
+ state.phase_watcher
+ .0
+ .send(StatePhase::Connecting)
+ .unwrap();
+
+ let socket_addr = match (host.as_ref(), port)
+ .to_socket_addrs()
+ .map(|mut e| e.next())
+ {
+ Ok(Some(v)) => v,
+ _ => {
+ warn!("Error parsing server addr");
+ return now!(Err(Error::InvalidServerAddr(host, port)));
+ }
+ };
+ connection_info_sender
+ .send(Some(ConnectionInfo::new(
+ socket_addr,
+ host,
+ accept_invalid_cert,
+ )))
+ .unwrap();
+ at!(TcpEvent::Connected, |res| {
+ //runs the closure when the client is connected
+ if let TcpEventData::Connected(res) = res {
+ Box::new(iter::once(res.map(|msg| {
+ Some(CommandResponse::ServerConnect {
+ welcome_message: if msg.has_welcome_text() {
+ Some(msg.get_welcome_text().to_string())
+ } else {
+ None
+ },
+ })
+ })))
+ } else {
+ unreachable!("callback should be provided with a TcpEventData::Connected");
+ }
+ })
+ }
+ Command::ServerDisconnect => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+
+ state.server = None;
+
+ state.phase_watcher
+ .0
+ .send(StatePhase::Disconnected)
+ .unwrap();
+ state.audio_output.play_effect(NotificationEvents::ServerDisconnect);
+ now!(Ok(None))
+ }
+ Command::ServerStatus { host, port } => ExecutionContext::Ping(
+ Box::new(move || {
+ match (host.as_str(), port)
+ .to_socket_addrs()
+ .map(|mut e| e.next())
+ {
+ Ok(Some(v)) => Ok(v),
+ _ => Err(Error::InvalidServerAddr(host, port)),
+ }
+ }),
+ Box::new(move |pong| {
+ Ok(pong.map(|pong| (CommandResponse::ServerStatus {
+ version: pong.version,
+ users: pong.users,
+ max_users: pong.max_users,
+ bandwidth: pong.bandwidth,
+ })))
+ }),
+ ),
+ Command::Status => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+ let state = state.server.as_ref().unwrap().into();
+ now!(Ok(Some(CommandResponse::Status {
+ server_state: state, //guaranteed not to panic because if we are connected, server is guaranteed to be Some
+ })))
+ }
+ Command::UserVolumeSet(string, volume) => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+ let user_id = match state
+ .server()
+ .unwrap()
+ .users()
+ .iter()
+ .find(|e| e.1.name() == string)
+ .map(|e| *e.0)
+ {
+ None => return now!(Err(Error::InvalidUsername(string))),
+ Some(v) => v,
+ };
+
+ state.audio_output.set_user_volume(user_id, volume);
+ now!(Ok(None))
+ }
+ Command::PastMessages { block } => {
+ //does it make sense to wait for messages while not connected?
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+ if block {
+ let ref_state = Arc::clone(&og_state);
+ ExecutionContext::TcpEventSubscriber(
+ TcpEvent::TextMessage,
+ Box::new(move |data, sender| {
+ if let TcpEventData::TextMessage(a) = data {
+ let message = (
+ a.get_message().to_owned(),
+ ref_state.read().unwrap().get_user_name(a.get_actor()).unwrap()
+ );
+ sender.send(Ok(Some(CommandResponse::PastMessage { message }))).is_ok()
+ } else {
+ unreachable!("Should only receive a TextMessage data when listening to TextMessage events");
+ }
+ }),
+ )
+ } else {
+ let messages = std::mem::take(&mut state.message_buffer);
+ let messages: Vec<_> = messages.into_iter()
+ .map(|(msg, user)| (msg, state.get_user_name(user).unwrap()))
+ .map(|e| Ok(Some(CommandResponse::PastMessage { message: e })))
+ .collect();
+
+ ExecutionContext::Now(Box::new(move || {
+ Box::new(messages.into_iter())
+ }))
+ }
+ }
+ Command::SendMessage { message, targets } => {
+ if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
+ return now!(Err(Error::Disconnected));
+ }
+
+ let mut msg = msgs::TextMessage::new();
+
+ msg.set_message(message);
+
+ for target in targets {
+ match target {
+ MessageTarget::Channel { recursive, name } => {
+ let channel_id = state
+ .server()
+ .unwrap()
+ .channel_name(&name);
+
+ let channel_id = match channel_id {
+ Ok(id) => id,
+ Err(e) => return now!(Err(Error::ChannelIdentifierError(name, e))),
+ }.0;
+
+ if recursive {
+ msg.mut_tree_id()
+ } else {
+ msg.mut_channel_id()
+ }.push(channel_id);
+ }
+ MessageTarget::User { name } => {
+ let id = state
+ .server()
+ .unwrap()
+ .users()
+ .iter()
+ .find(|(_, user)| user.name() == &name)
+ .map(|(e, _)| *e);
+
+ let id = match id {
+ Some(id) => id,
+ None => return now!(Err(Error::InvalidUsername(name))),
+ };
+
+ msg.mut_session().push(id);
+ }
+ }
+ }
+
+ packet_sender.send(msg.into()).unwrap();
+
+ now!(Ok(None))
+ }
+ }
}
generated by cgit v1.2.1 (git 2.18.0) at 2025-12-14 14:42:53 +0100