forked from lavina/lavina
1
0
Fork 0

Compare commits

..

No commits in common. "d436631450d639a418c4896bbcf92c7dc526a1fd" and "c6fb74a84808c2867b24e17e6df37d67cf19c3fd" have entirely different histories.

25 changed files with 661 additions and 567 deletions

View File

@ -12,7 +12,7 @@ jobs:
uses: https://github.com/actions-rs/cargo@v1 uses: https://github.com/actions-rs/cargo@v1
with: with:
command: fmt command: fmt
args: "--check --all" args: "--check -p mgmt-api -p lavina-core -p projection-irc -p projection-xmpp -p sasl"
- name: cargo check - name: cargo check
uses: https://github.com/actions-rs/cargo@v1 uses: https://github.com/actions-rs/cargo@v1
with: with:

View File

@ -1,21 +0,0 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Run lavina" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
<option name="command" value="run --package lavina --bin lavina -- --config config.toml" />
<option name="workingDirectory" value="file://$PROJECT_DIR$" />
<envs>
<env name="RUST_LOG" value="debug" />
</envs>
<option name="emulateTerminal" value="true" />
<option name="channel" value="DEFAULT" />
<option name="requiredFeatures" value="true" />
<option name="allFeatures" value="false" />
<option name="withSudo" value="false" />
<option name="buildTarget" value="REMOTE" />
<option name="backtrace" value="FULL" />
<option name="isRedirectInput" value="false" />
<option name="redirectInputPath" value="" />
<method v="2">
<option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
</method>
</configuration>
</component>

588
Cargo.lock generated

File diff suppressed because it is too large Load Diff

View File

@ -18,8 +18,8 @@ assert_matches = "1.5.0"
tokio = { version = "1.24.1", features = ["full"] } # async runtime tokio = { version = "1.24.1", features = ["full"] } # async runtime
futures-util = "0.3.25" futures-util = "0.3.25"
anyhow = "1.0.68" # error utils anyhow = "1.0.68" # error utils
nonempty = "0.10.0" nonempty = "0.8.1"
quick-xml = { version = "0.31.0", features = ["async-tokio"] } quick-xml = { version = "0.30.0", features = ["async-tokio"] }
lazy_static = "1.4.0" lazy_static = "1.4.0"
regex = "1.7.1" regex = "1.7.1"
derive_more = "0.99.17" derive_more = "0.99.17"
@ -62,4 +62,4 @@ clap.workspace = true
[dev-dependencies] [dev-dependencies]
assert_matches.workspace = true assert_matches.workspace = true
regex = "1.7.1" regex = "1.7.1"
reqwest = { version = "0.12.0", default-features = false } reqwest = { version = "0.11", default-features = false }

View File

@ -14,7 +14,10 @@ use std::{
use prometheus::{IntGauge, Registry as MetricsRegistry}; use prometheus::{IntGauge, Registry as MetricsRegistry};
use serde::Serialize; use serde::Serialize;
use tokio::sync::mpsc::{channel, Receiver, Sender}; use tokio::{
sync::mpsc::{channel, Receiver, Sender},
task::JoinHandle,
};
use crate::prelude::*; use crate::prelude::*;
use crate::room::{RoomHandle, RoomId, RoomInfo, RoomRegistry}; use crate::room::{RoomHandle, RoomId, RoomInfo, RoomRegistry};
@ -42,65 +45,58 @@ impl PlayerId {
} }
} }
/// Node-local identifier of a connection. It is used to address a connection within a player actor.
#[derive(Debug, Clone, PartialEq, Eq, Hash)] #[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ConnectionId(pub AnonKey); pub struct ConnectionId(pub AnonKey);
/// Representation of an authenticated client connection.
/// The public API available to projections through which all client actions are executed.
///
/// The connection is used to send commands to the player actor and to receive updates that might be sent to the client.
pub struct PlayerConnection { pub struct PlayerConnection {
pub connection_id: ConnectionId, pub connection_id: ConnectionId,
pub receiver: Receiver<Updates>, pub receiver: Receiver<Updates>,
player_handle: PlayerHandle, player_handle: PlayerHandle,
} }
impl PlayerConnection { impl PlayerConnection {
/// Handled in [Player::send_message].
pub async fn send_message(&mut self, room_id: RoomId, body: Str) -> Result<()> { pub async fn send_message(&mut self, room_id: RoomId, body: Str) -> Result<()> {
let (promise, deferred) = oneshot(); self.player_handle
let cmd = ClientCommand::SendMessage { room_id, body, promise }; .send_message(room_id, self.connection_id.clone(), body)
self.player_handle.send(ActorCommand::ClientCommand(cmd, self.connection_id.clone())).await; .await
Ok(deferred.await?)
} }
/// Handled in [Player::join_room].
pub async fn join_room(&mut self, room_id: RoomId) -> Result<JoinResult> { pub async fn join_room(&mut self, room_id: RoomId) -> Result<JoinResult> {
let (promise, deferred) = oneshot(); self.player_handle.join_room(room_id, self.connection_id.clone()).await
let cmd = ClientCommand::JoinRoom { room_id, promise };
self.player_handle.send(ActorCommand::ClientCommand(cmd, self.connection_id.clone())).await;
Ok(deferred.await?)
} }
/// Handled in [Player::change_topic].
pub async fn change_topic(&mut self, room_id: RoomId, new_topic: Str) -> Result<()> { pub async fn change_topic(&mut self, room_id: RoomId, new_topic: Str) -> Result<()> {
let (promise, deferred) = oneshot(); let (promise, deferred) = oneshot();
let cmd = ClientCommand::ChangeTopic { let cmd = Cmd::ChangeTopic {
room_id, room_id,
new_topic, new_topic,
promise, promise,
}; };
self.player_handle.send(ActorCommand::ClientCommand(cmd, self.connection_id.clone())).await; self.player_handle
.send(PlayerCommand::Cmd(cmd, self.connection_id.clone()))
.await;
Ok(deferred.await?) Ok(deferred.await?)
} }
/// Handled in [Player::leave_room].
pub async fn leave_room(&mut self, room_id: RoomId) -> Result<()> { pub async fn leave_room(&mut self, room_id: RoomId) -> Result<()> {
let (promise, deferred) = oneshot(); let (promise, deferred) = oneshot();
let cmd = ClientCommand::LeaveRoom { room_id, promise }; self.player_handle
self.player_handle.send(ActorCommand::ClientCommand(cmd, self.connection_id.clone())).await; .send(PlayerCommand::Cmd(
Cmd::LeaveRoom { room_id, promise },
self.connection_id.clone(),
))
.await;
Ok(deferred.await?) Ok(deferred.await?)
} }
pub async fn terminate(self) { pub async fn terminate(self) {
self.player_handle.send(ActorCommand::TerminateConnection(self.connection_id)).await; self.player_handle
.send(PlayerCommand::TerminateConnection(self.connection_id))
.await;
} }
/// Handled in [Player::get_rooms].
pub async fn get_rooms(&self) -> Result<Vec<RoomInfo>> { pub async fn get_rooms(&self) -> Result<Vec<RoomInfo>> {
let (promise, deferred) = oneshot(); let (promise, deferred) = oneshot();
let cmd = ClientCommand::GetRooms { promise }; self.player_handle.send(PlayerCommand::GetRooms(promise)).await;
self.player_handle.send(ActorCommand::ClientCommand(cmd, self.connection_id.clone())).await;
Ok(deferred.await?) Ok(deferred.await?)
} }
} }
@ -108,13 +104,13 @@ impl PlayerConnection {
/// Handle to a player actor. /// Handle to a player actor.
#[derive(Clone)] #[derive(Clone)]
pub struct PlayerHandle { pub struct PlayerHandle {
tx: Sender<ActorCommand>, tx: Sender<PlayerCommand>,
} }
impl PlayerHandle { impl PlayerHandle {
pub async fn subscribe(&self) -> PlayerConnection { pub async fn subscribe(&self) -> PlayerConnection {
let (sender, receiver) = channel(32); let (sender, receiver) = channel(32);
let (promise, deferred) = oneshot(); let (promise, deferred) = oneshot();
let cmd = ActorCommand::AddConnection { sender, promise }; let cmd = PlayerCommand::AddConnection { sender, promise };
let _ = self.tx.send(cmd).await; let _ = self.tx.send(cmd).await;
let connection_id = deferred.await.unwrap(); let connection_id = deferred.await.unwrap();
PlayerConnection { PlayerConnection {
@ -124,34 +120,45 @@ impl PlayerHandle {
} }
} }
async fn send(&self, command: ActorCommand) { pub async fn send_message(&self, room_id: RoomId, connection_id: ConnectionId, body: Str) -> Result<()> {
// TODO either handle the error or doc why it is safe to ignore let (promise, deferred) = oneshot();
let cmd = Cmd::SendMessage { room_id, body, promise };
let _ = self.tx.send(PlayerCommand::Cmd(cmd, connection_id)).await;
Ok(deferred.await?)
}
pub async fn join_room(&self, room_id: RoomId, connection_id: ConnectionId) -> Result<JoinResult> {
let (promise, deferred) = oneshot();
let cmd = Cmd::JoinRoom { room_id, promise };
let _ = self.tx.send(PlayerCommand::Cmd(cmd, connection_id)).await;
Ok(deferred.await?)
}
async fn send(&self, command: PlayerCommand) {
let _ = self.tx.send(command).await; let _ = self.tx.send(command).await;
} }
pub async fn update(&self, update: Updates) { pub async fn update(&self, update: Updates) {
self.send(ActorCommand::Update(update)).await; self.send(PlayerCommand::Update(update)).await;
} }
} }
/// Messages sent to the player actor. enum PlayerCommand {
enum ActorCommand { /** Commands from connections */
/// Establish a new connection.
AddConnection { AddConnection {
sender: Sender<Updates>, sender: Sender<Updates>,
promise: Promise<ConnectionId>, promise: Promise<ConnectionId>,
}, },
/// Terminate an existing connection.
TerminateConnection(ConnectionId), TerminateConnection(ConnectionId),
/// Player-issued command. Cmd(Cmd, ConnectionId),
ClientCommand(ClientCommand, ConnectionId), /// Query - responds with a list of rooms the player is a member of.
/// Update which is sent from a room the player is member of. GetRooms(Promise<Vec<RoomInfo>>),
/** Events from rooms */
Update(Updates), Update(Updates),
Stop, Stop,
} }
/// Client-issued command sent to the player actor. The actor will respond with by fulfilling the promise. pub enum Cmd {
pub enum ClientCommand {
JoinRoom { JoinRoom {
room_id: RoomId, room_id: RoomId,
promise: Promise<JoinResult>, promise: Promise<JoinResult>,
@ -170,9 +177,6 @@ pub enum ClientCommand {
new_topic: Str, new_topic: Str,
promise: Promise<()>, promise: Promise<()>,
}, },
GetRooms {
promise: Promise<Vec<RoomInfo>>,
},
} }
pub enum JoinResult { pub enum JoinResult {
@ -239,7 +243,7 @@ impl PlayerRegistry {
pub async fn shutdown_all(&mut self) -> Result<()> { pub async fn shutdown_all(&mut self) -> Result<()> {
let mut inner = self.0.write().unwrap(); let mut inner = self.0.write().unwrap();
for (i, (k, j)) in inner.players.drain() { for (i, (k, j)) in inner.players.drain() {
k.send(ActorCommand::Stop).await; k.send(PlayerCommand::Stop).await;
drop(k); drop(k);
j.await?; j.await?;
log::debug!("Player stopped #{i:?}") log::debug!("Player stopped #{i:?}")
@ -262,7 +266,7 @@ struct Player {
connections: AnonTable<Sender<Updates>>, connections: AnonTable<Sender<Updates>>,
my_rooms: HashMap<RoomId, RoomHandle>, my_rooms: HashMap<RoomId, RoomHandle>,
banned_from: HashSet<RoomId>, banned_from: HashSet<RoomId>,
rx: Receiver<ActorCommand>, rx: Receiver<PlayerCommand>,
handle: PlayerHandle, handle: PlayerHandle,
rooms: RoomRegistry, rooms: RoomRegistry,
} }
@ -287,27 +291,24 @@ impl Player {
async fn main_loop(mut self) -> Self { async fn main_loop(mut self) -> Self {
while let Some(cmd) = self.rx.recv().await { while let Some(cmd) = self.rx.recv().await {
match cmd { match cmd {
ActorCommand::AddConnection { sender, promise } => { PlayerCommand::AddConnection { sender, promise } => {
let connection_id = self.connections.insert(sender); let connection_id = self.connections.insert(sender);
if let Err(connection_id) = promise.send(ConnectionId(connection_id)) { if let Err(connection_id) = promise.send(ConnectionId(connection_id)) {
log::warn!("Connection {connection_id:?} terminated before finalization"); log::warn!("Connection {connection_id:?} terminated before finalization");
self.terminate_connection(connection_id); self.terminate_connection(connection_id);
} }
} }
ActorCommand::TerminateConnection(connection_id) => { PlayerCommand::TerminateConnection(connection_id) => {
self.terminate_connection(connection_id); self.terminate_connection(connection_id);
} }
ActorCommand::Update(update) => self.handle_update(update).await, PlayerCommand::GetRooms(promise) => {
ActorCommand::ClientCommand(cmd, connection_id) => self.handle_cmd(cmd, connection_id).await, let mut response = vec![];
ActorCommand::Stop => break, for (_, handle) in &self.my_rooms {
response.push(handle.get_room_info().await);
} }
let _ = promise.send(response);
} }
log::debug!("Shutting down player actor #{:?}", self.player_id); PlayerCommand::Update(update) => {
self
}
/// Handle an incoming update by changing the internal state and broadcasting it to all connections if necessary.
async fn handle_update(&mut self, update: Updates) {
log::info!( log::info!(
"Player received an update, broadcasting to {} connections", "Player received an update, broadcasting to {} connections",
self.connections.len() self.connections.len()
@ -323,6 +324,13 @@ impl Player {
let _ = connection.send(update.clone()).await; let _ = connection.send(update.clone()).await;
} }
} }
PlayerCommand::Cmd(cmd, connection_id) => self.handle_cmd(cmd, connection_id).await,
PlayerCommand::Stop => break,
}
}
log::debug!("Shutting down player actor #{:?}", self.player_id);
self
}
fn terminate_connection(&mut self, connection_id: ConnectionId) { fn terminate_connection(&mut self, connection_id: ConnectionId) {
if let None = self.connections.pop(connection_id.0) { if let None = self.connections.pop(connection_id.0) {
@ -330,78 +338,52 @@ impl Player {
} }
} }
/// Dispatches a client command to the appropriate handler. async fn handle_cmd(&mut self, cmd: Cmd, connection_id: ConnectionId) {
async fn handle_cmd(&mut self, cmd: ClientCommand, connection_id: ConnectionId) {
match cmd { match cmd {
ClientCommand::JoinRoom { room_id, promise } => { Cmd::JoinRoom { room_id, promise } => {
let result = self.join_room(connection_id, room_id).await;
let _ = promise.send(result);
}
ClientCommand::LeaveRoom { room_id, promise } => {
self.leave_room(connection_id, room_id).await;
let _ = promise.send(());
}
ClientCommand::SendMessage { room_id, body, promise } => {
self.send_message(connection_id, room_id, body).await;
let _ = promise.send(());
}
ClientCommand::ChangeTopic {
room_id,
new_topic,
promise,
} => {
self.change_topic(connection_id, room_id, new_topic).await;
let _ = promise.send(());
}
ClientCommand::GetRooms { promise } => {
let result = self.get_rooms().await;
let _ = promise.send(result);
}
}
}
async fn join_room(&mut self, connection_id: ConnectionId, room_id: RoomId) -> JoinResult {
if self.banned_from.contains(&room_id) { if self.banned_from.contains(&room_id) {
return JoinResult::Banned; let _ = promise.send(JoinResult::Banned);
return;
} }
let room = match self.rooms.get_or_create_room(room_id.clone()).await { let room = match self.rooms.get_or_create_room(room_id.clone()).await {
Ok(room) => room, Ok(room) => room,
Err(e) => { Err(e) => {
log::error!("Failed to get or create room: {e}"); log::error!("Failed to get or create room: {e}");
todo!(); return;
} }
}; };
room.subscribe(self.player_id.clone(), self.handle.clone()).await; room.subscribe(self.player_id.clone(), self.handle.clone()).await;
self.my_rooms.insert(room_id.clone(), room.clone()); self.my_rooms.insert(room_id.clone(), room.clone());
let room_info = room.get_room_info().await; let room_info = room.get_room_info().await;
let _ = promise.send(JoinResult::Success(room_info));
let update = Updates::RoomJoined { let update = Updates::RoomJoined {
room_id, room_id,
new_member_id: self.player_id.clone(), new_member_id: self.player_id.clone(),
}; };
self.broadcast_update(update, connection_id).await; self.broadcast_update(update, connection_id).await;
JoinResult::Success(room_info)
} }
Cmd::LeaveRoom { room_id, promise } => {
async fn leave_room(&mut self, connection_id: ConnectionId, room_id: RoomId) {
let room = self.my_rooms.remove(&room_id); let room = self.my_rooms.remove(&room_id);
if let Some(room) = room { if let Some(room) = room {
room.unsubscribe(&self.player_id).await; room.unsubscribe(&self.player_id).await;
let room_info = room.get_room_info().await;
} }
let _ = promise.send(());
let update = Updates::RoomLeft { let update = Updates::RoomLeft {
room_id, room_id,
former_member_id: self.player_id.clone(), former_member_id: self.player_id.clone(),
}; };
self.broadcast_update(update, connection_id).await; self.broadcast_update(update, connection_id).await;
} }
Cmd::SendMessage { room_id, body, promise } => {
async fn send_message(&mut self, connection_id: ConnectionId, room_id: RoomId, body: Str) {
let room = self.rooms.get_room(&room_id).await; let room = self.rooms.get_room(&room_id).await;
if let Some(room) = room { if let Some(room) = room {
room.send_message(self.player_id.clone(), body.clone()).await; room.send_message(self.player_id.clone(), body.clone()).await;
} else { } else {
tracing::info!("no room found"); tracing::info!("no room found");
} }
let _ = promise.send(());
let update = Updates::NewMessage { let update = Updates::NewMessage {
room_id, room_id,
author_id: self.player_id.clone(), author_id: self.player_id.clone(),
@ -409,30 +391,24 @@ impl Player {
}; };
self.broadcast_update(update, connection_id).await; self.broadcast_update(update, connection_id).await;
} }
Cmd::ChangeTopic {
async fn change_topic(&mut self, connection_id: ConnectionId, room_id: RoomId, new_topic: Str) { room_id,
new_topic,
promise,
} => {
let room = self.rooms.get_room(&room_id).await; let room = self.rooms.get_room(&room_id).await;
if let Some(mut room) = room { if let Some(mut room) = room {
room.set_topic(self.player_id.clone(), new_topic.clone()).await; room.set_topic(self.player_id.clone(), new_topic.clone()).await;
} else { } else {
tracing::info!("no room found"); tracing::info!("no room found");
} }
let _ = promise.send(());
let update = Updates::RoomTopicChanged { room_id, new_topic }; let update = Updates::RoomTopicChanged { room_id, new_topic };
self.broadcast_update(update, connection_id).await; self.broadcast_update(update, connection_id).await;
} }
async fn get_rooms(&self) -> Vec<RoomInfo> {
let mut response = vec![];
for (_, handle) in &self.my_rooms {
response.push(handle.get_room_info().await);
} }
response
} }
/// Broadcasts an update to all connections except the one with the given id.
///
/// This is called after handling a client command.
/// Sending the update to the connection which sent the command is handled by the connection itself.
async fn broadcast_update(&self, update: Updates, except: ConnectionId) { async fn broadcast_update(&self, update: Updates, except: ConnectionId) {
for (a, b) in &self.connections { for (a, b) in &self.connections {
if ConnectionId(a) == except { if ConnectionId(a) == except {

View File

@ -160,13 +160,9 @@ impl RoomHandle {
} }
struct Room { struct Room {
/// The numeric node-local id of the room as it is stored in the database.
storage_id: u32, storage_id: u32,
/// The cluster-global id of the room.
room_id: RoomId, room_id: RoomId,
/// Player actors on the local node which are subscribed to this room's updates.
subscriptions: HashMap<PlayerId, PlayerHandle>, subscriptions: HashMap<PlayerId, PlayerHandle>,
/// The total number of messages. Used to calculate the id of the new message.
message_count: u32, message_count: u32,
topic: Str, topic: Str,
storage: Storage, storage: Storage,
@ -184,7 +180,9 @@ impl Room {
async fn send_message(&mut self, author_id: PlayerId, body: Str) -> Result<()> { async fn send_message(&mut self, author_id: PlayerId, body: Str) -> Result<()> {
tracing::info!("Adding a message to room"); tracing::info!("Adding a message to room");
self.storage.insert_message(self.storage_id, self.message_count, &body, &*author_id.as_inner()).await?; self.storage
.insert_message(self.storage_id, self.message_count, &body, &*author_id.as_inner())
.await?;
self.message_count += 1; self.message_count += 1;
let update = Updates::NewMessage { let update = Updates::NewMessage {
room_id: self.room_id.clone(), room_id: self.room_id.clone(),
@ -195,10 +193,6 @@ impl Room {
Ok(()) Ok(())
} }
/// Broadcasts an update to all players except the one who caused the update.
///
/// This is called after handling a client command.
/// Sending the update to the player who sent the command is handled by the player actor.
async fn broadcast_update(&self, update: Updates, except: &PlayerId) { async fn broadcast_update(&self, update: Updates, except: &PlayerId) {
tracing::debug!("Broadcasting an update to {} subs", self.subscriptions.len()); tracing::debug!("Broadcasting an update to {} subs", self.subscriptions.len());
for (player_id, sub) in &self.subscriptions { for (player_id, sub) in &self.subscriptions {

View File

@ -0,0 +1,2 @@
max_width = 120
chain_width = 120

View File

@ -30,8 +30,6 @@ mod cap;
use crate::cap::Capabilities; use crate::cap::Capabilities;
pub const APP_VERSION: &str = concat!("lavina", "_", env!("CARGO_PKG_VERSION"));
#[derive(Deserialize, Debug, Clone)] #[derive(Deserialize, Debug, Clone)]
pub struct ServerConfig { pub struct ServerConfig {
pub listen_on: SocketAddr, pub listen_on: SocketAddr,
@ -44,7 +42,7 @@ struct RegisteredUser {
/** /**
* Username is mostly unused in modern IRC. * Username is mostly unused in modern IRC.
* *
* <https://stackoverflow.com/questions/31666247/what-is-the-difference-between-the-nick-username-and-real-name-in-irc-and-wha> * [https://stackoverflow.com/questions/31666247/what-is-the-difference-between-the-nick-username-and-real-name-in-irc-and-wha]
*/ */
username: Str, username: Str,
realname: Str, realname: Str,
@ -393,14 +391,13 @@ async fn handle_registered_socket<'a>(
let player_id = PlayerId::from(user.nickname.clone())?; let player_id = PlayerId::from(user.nickname.clone())?;
let mut connection = players.connect_to_player(player_id.clone()).await; let mut connection = players.connect_to_player(player_id.clone()).await;
let text: Str = format!("Welcome to {} Server", &config.server_name).into();
ServerMessage { ServerMessage {
tags: vec![], tags: vec![],
sender: Some(config.server_name.clone()), sender: Some(config.server_name.clone()),
body: ServerMessageBody::N001Welcome { body: ServerMessageBody::N001Welcome {
client: user.nickname.clone(), client: user.nickname.clone(),
text: text.clone(), text: "Welcome to Kek Server".into(),
}, },
} }
.write_async(writer) .write_async(writer)
@ -410,7 +407,7 @@ async fn handle_registered_socket<'a>(
sender: Some(config.server_name.clone()), sender: Some(config.server_name.clone()),
body: ServerMessageBody::N002YourHost { body: ServerMessageBody::N002YourHost {
client: user.nickname.clone(), client: user.nickname.clone(),
text: text.clone(), text: "Welcome to Kek Server".into(),
}, },
} }
.write_async(writer) .write_async(writer)
@ -420,7 +417,7 @@ async fn handle_registered_socket<'a>(
sender: Some(config.server_name.clone()), sender: Some(config.server_name.clone()),
body: ServerMessageBody::N003Created { body: ServerMessageBody::N003Created {
client: user.nickname.clone(), client: user.nickname.clone(),
text: text.clone(), text: "Welcome to Kek Server".into(),
}, },
} }
.write_async(writer) .write_async(writer)
@ -431,7 +428,7 @@ async fn handle_registered_socket<'a>(
body: ServerMessageBody::N004MyInfo { body: ServerMessageBody::N004MyInfo {
client: user.nickname.clone(), client: user.nickname.clone(),
hostname: config.server_name.clone(), hostname: config.server_name.clone(),
softname: APP_VERSION.into(), softname: "kek-0.1.alpha.3".into(),
}, },
} }
.write_async(writer) .write_async(writer)

View File

@ -10,8 +10,8 @@ use tokio::net::TcpStream;
use lavina_core::repo::{Storage, StorageConfig}; use lavina_core::repo::{Storage, StorageConfig};
use lavina_core::{player::PlayerRegistry, room::RoomRegistry}; use lavina_core::{player::PlayerRegistry, room::RoomRegistry};
use projection_irc::APP_VERSION;
use projection_irc::{launch, read_irc_message, RunningServer, ServerConfig}; use projection_irc::{launch, read_irc_message, RunningServer, ServerConfig};
struct TestScope<'a> { struct TestScope<'a> {
reader: BufReader<ReadHalf<'a>>, reader: BufReader<ReadHalf<'a>>,
writer: WriteHalf<'a>, writer: WriteHalf<'a>,
@ -113,17 +113,10 @@ async fn scenario_basic() -> Result<()> {
s.send("PASS password").await?; s.send("PASS password").await?;
s.send("NICK tester").await?; s.send("NICK tester").await?;
s.send("USER UserName 0 * :Real Name").await?; s.send("USER UserName 0 * :Real Name").await?;
s.expect(":testserver 001 tester :Welcome to testserver Server").await?; s.expect(":testserver 001 tester :Welcome to Kek Server").await?;
s.expect(":testserver 002 tester :Welcome to testserver Server").await?; s.expect(":testserver 002 tester :Welcome to Kek Server").await?;
s.expect(":testserver 003 tester :Welcome to testserver Server").await?; s.expect(":testserver 003 tester :Welcome to Kek Server").await?;
s.expect( s.expect(":testserver 004 tester testserver kek-0.1.alpha.3 r CFILPQbcefgijklmnopqrstvz").await?;
format!(
":testserver 004 tester testserver {} r CFILPQbcefgijklmnopqrstvz",
&APP_VERSION
)
.as_str(),
)
.await?;
s.expect(":testserver 005 tester CHANTYPES=# :are supported by this server").await?; s.expect(":testserver 005 tester CHANTYPES=# :are supported by this server").await?;
s.expect_nothing().await?; s.expect_nothing().await?;
s.send("QUIT :Leaving").await?; s.send("QUIT :Leaving").await?;
@ -168,17 +161,10 @@ async fn scenario_cap_full_negotiation() -> Result<()> {
s.send("CAP END").await?; s.send("CAP END").await?;
s.expect(":testserver 001 tester :Welcome to testserver Server").await?; s.expect(":testserver 001 tester :Welcome to Kek Server").await?;
s.expect(":testserver 002 tester :Welcome to testserver Server").await?; s.expect(":testserver 002 tester :Welcome to Kek Server").await?;
s.expect(":testserver 003 tester :Welcome to testserver Server").await?; s.expect(":testserver 003 tester :Welcome to Kek Server").await?;
s.expect( s.expect(":testserver 004 tester testserver kek-0.1.alpha.3 r CFILPQbcefgijklmnopqrstvz").await?;
format!(
":testserver 004 tester testserver {} r CFILPQbcefgijklmnopqrstvz",
&APP_VERSION
)
.as_str(),
)
.await?;
s.expect(":testserver 005 tester CHANTYPES=# :are supported by this server").await?; s.expect(":testserver 005 tester CHANTYPES=# :are supported by this server").await?;
s.expect_nothing().await?; s.expect_nothing().await?;
s.send("QUIT :Leaving").await?; s.send("QUIT :Leaving").await?;
@ -217,17 +203,10 @@ async fn scenario_cap_short_negotiation() -> Result<()> {
s.send("CAP END").await?; s.send("CAP END").await?;
s.expect(":testserver 001 tester :Welcome to testserver Server").await?; s.expect(":testserver 001 tester :Welcome to Kek Server").await?;
s.expect(":testserver 002 tester :Welcome to testserver Server").await?; s.expect(":testserver 002 tester :Welcome to Kek Server").await?;
s.expect(":testserver 003 tester :Welcome to testserver Server").await?; s.expect(":testserver 003 tester :Welcome to Kek Server").await?;
s.expect( s.expect(":testserver 004 tester testserver kek-0.1.alpha.3 r CFILPQbcefgijklmnopqrstvz").await?;
format!(
":testserver 004 tester testserver {} r CFILPQbcefgijklmnopqrstvz",
&APP_VERSION
)
.as_str(),
)
.await?;
s.expect(":testserver 005 tester CHANTYPES=# :are supported by this server").await?; s.expect(":testserver 005 tester CHANTYPES=# :are supported by this server").await?;
s.expect_nothing().await?; s.expect_nothing().await?;
s.send("QUIT :Leaving").await?; s.send("QUIT :Leaving").await?;
@ -272,17 +251,10 @@ async fn scenario_cap_sasl_fail() -> Result<()> {
s.send("CAP END").await?; s.send("CAP END").await?;
s.expect(":testserver 001 tester :Welcome to testserver Server").await?; s.expect(":testserver 001 tester :Welcome to Kek Server").await?;
s.expect(":testserver 002 tester :Welcome to testserver Server").await?; s.expect(":testserver 002 tester :Welcome to Kek Server").await?;
s.expect(":testserver 003 tester :Welcome to testserver Server").await?; s.expect(":testserver 003 tester :Welcome to Kek Server").await?;
s.expect( s.expect(":testserver 004 tester testserver kek-0.1.alpha.3 r CFILPQbcefgijklmnopqrstvz").await?;
format!(
":testserver 004 tester testserver {} r CFILPQbcefgijklmnopqrstvz",
&APP_VERSION
)
.as_str(),
)
.await?;
s.expect(":testserver 005 tester CHANTYPES=# :are supported by this server").await?; s.expect(":testserver 005 tester CHANTYPES=# :are supported by this server").await?;
s.expect_nothing().await?; s.expect_nothing().await?;
s.send("QUIT :Leaving").await?; s.send("QUIT :Leaving").await?;

View File

@ -0,0 +1,2 @@
max_width = 120
chain_width = 120

View File

@ -7,42 +7,42 @@ use nonempty::NonEmpty;
/// Client-to-server command. /// Client-to-server command.
#[derive(Clone, Debug, PartialEq, Eq)] #[derive(Clone, Debug, PartialEq, Eq)]
pub enum ClientMessage { pub enum ClientMessage {
/// `CAP`. Capability-related commands. /// CAP. Capability-related commands.
Capability { Capability {
subcommand: CapabilitySubcommand, subcommand: CapabilitySubcommand,
}, },
/// `PING <token>` /// PING <token>
Ping { Ping {
token: Str, token: Str,
}, },
/// `PONG <token>` /// PONG <token>
Pong { Pong {
token: Str, token: Str,
}, },
/// `NICK <nickname>` /// NICK <nickname>
Nick { Nick {
nickname: Str, nickname: Str,
}, },
/// `PASS <password>` /// PASS <password>
Pass { Pass {
password: Str, password: Str,
}, },
/// `USER <username> 0 * :<realname>` /// USER <username> 0 * :<realname>
User { User {
username: Str, username: Str,
realname: Str, realname: Str,
}, },
/// `JOIN <chan>` /// JOIN <chan>
Join(Chan), Join(Chan),
/// `MODE <target>` /// MODE <target>
Mode { Mode {
target: Recipient, target: Recipient,
}, },
/// `WHO <target>` /// WHO <target>
Who { Who {
target: Recipient, // aka mask target: Recipient, // aka mask
}, },
/// `TOPIC <chan> :<topic>` /// TOPIC <chan> :<topic>
Topic { Topic {
chan: Chan, chan: Chan,
topic: Str, topic: Str,
@ -51,12 +51,12 @@ pub enum ClientMessage {
chan: Chan, chan: Chan,
message: Str, message: Str,
}, },
/// `PRIVMSG <target> :<msg>` /// PRIVMSG <target> :<msg>
PrivateMessage { PrivateMessage {
recipient: Recipient, recipient: Recipient,
body: Str, body: Str,
}, },
/// `QUIT :<reason>` /// QUIT :<reason>
Quit { Quit {
reason: Str, reason: Str,
}, },

View File

@ -36,9 +36,9 @@ fn params(input: &str) -> IResult<&str, &str> {
#[derive(Clone, Debug, PartialEq, Eq)] #[derive(Clone, Debug, PartialEq, Eq)]
pub enum Chan { pub enum Chan {
/// `#<name>` — network-global channel, available from any server in the network. /// #<name> — network-global channel, available from any server in the network.
Global(Str), Global(Str),
/// `&<name>` — server-local channel, available only to connections to the same server. Rarely used in practice. /// &<name> — server-local channel, available only to connections to the same server. Rarely used in practice.
Local(Str), Local(Str),
} }
impl Chan { impl Chan {
@ -118,7 +118,9 @@ mod test {
assert_matches!(result, Ok((_, result)) => assert_eq!(expected, result)); assert_matches!(result, Ok((_, result)) => assert_eq!(expected, result));
let mut bytes = vec![]; let mut bytes = vec![];
sync_future(expected.write_async(&mut bytes)).unwrap().unwrap(); sync_future(expected.write_async(&mut bytes))
.unwrap()
.unwrap();
assert_eq!(bytes.as_slice(), input.as_bytes()); assert_eq!(bytes.as_slice(), input.as_bytes());
} }
@ -132,7 +134,9 @@ mod test {
assert_matches!(result, Ok((_, result)) => assert_eq!(expected, result)); assert_matches!(result, Ok((_, result)) => assert_eq!(expected, result));
let mut bytes = vec![]; let mut bytes = vec![];
sync_future(expected.write_async(&mut bytes)).unwrap().unwrap(); sync_future(expected.write_async(&mut bytes))
.unwrap()
.unwrap();
assert_eq!(bytes.as_slice(), input.as_bytes()); assert_eq!(bytes.as_slice(), input.as_bytes());
} }
@ -146,7 +150,9 @@ mod test {
assert_matches!(result, Ok((_, result)) => assert_eq!(expected, result)); assert_matches!(result, Ok((_, result)) => assert_eq!(expected, result));
let mut bytes = vec![]; let mut bytes = vec![];
sync_future(expected.write_async(&mut bytes)).unwrap().unwrap(); sync_future(expected.write_async(&mut bytes))
.unwrap()
.unwrap();
assert_eq!(bytes.as_slice(), input.as_bytes()); assert_eq!(bytes.as_slice(), input.as_bytes());
} }

View File

@ -158,7 +158,7 @@ pub enum ServerMessageBody {
N904SaslFail { N904SaslFail {
nick: Str, nick: Str,
text: Str, text: Str,
}, }
} }
impl ServerMessageBody { impl ServerMessageBody {
@ -273,7 +273,11 @@ impl ServerMessageBody {
writer.write_all(b" :").await?; writer.write_all(b" :").await?;
writer.write_all(msg.as_bytes()).await?; writer.write_all(msg.as_bytes()).await?;
} }
ServerMessageBody::N332Topic { client, chat, topic } => { ServerMessageBody::N332Topic {
client,
chat,
topic,
} => {
writer.write_all(b"332 ").await?; writer.write_all(b"332 ").await?;
writer.write_all(client.as_bytes()).await?; writer.write_all(client.as_bytes()).await?;
writer.write_all(b" ").await?; writer.write_all(b" ").await?;
@ -311,14 +315,20 @@ impl ServerMessageBody {
writer.write_all(b" ").await?; writer.write_all(b" ").await?;
writer.write_all(realname.as_bytes()).await?; writer.write_all(realname.as_bytes()).await?;
} }
ServerMessageBody::N353NamesReply { client, chan, members } => { ServerMessageBody::N353NamesReply {
client,
chan,
members,
} => {
writer.write_all(b"353 ").await?; writer.write_all(b"353 ").await?;
writer.write_all(client.as_bytes()).await?; writer.write_all(client.as_bytes()).await?;
writer.write_all(b" = ").await?; writer.write_all(b" = ").await?;
chan.write_async(writer).await?; chan.write_async(writer).await?;
writer.write_all(b" :").await?; writer.write_all(b" :").await?;
for member in members { for member in members {
writer.write_all(member.prefix.to_string().as_bytes()).await?; writer
.write_all(member.prefix.to_string().as_bytes())
.await?;
writer.write_all(member.nick.as_bytes()).await?; writer.write_all(member.nick.as_bytes()).await?;
writer.write_all(b" ").await?; writer.write_all(b" ").await?;
} }
@ -330,7 +340,11 @@ impl ServerMessageBody {
chan.write_async(writer).await?; chan.write_async(writer).await?;
writer.write_all(b" :End of /NAMES list").await?; writer.write_all(b" :End of /NAMES list").await?;
} }
ServerMessageBody::N474BannedFromChan { client, chan, message } => { ServerMessageBody::N474BannedFromChan {
client,
chan,
message,
} => {
writer.write_all(b"474 ").await?; writer.write_all(b"474 ").await?;
writer.write_all(client.as_bytes()).await?; writer.write_all(client.as_bytes()).await?;
writer.write_all(b" ").await?; writer.write_all(b" ").await?;
@ -345,12 +359,7 @@ impl ServerMessageBody {
writer.write_all(b" :").await?; writer.write_all(b" :").await?;
writer.write_all(message.as_bytes()).await?; writer.write_all(message.as_bytes()).await?;
} }
ServerMessageBody::N900LoggedIn { ServerMessageBody::N900LoggedIn { nick, address, account, message } => {
nick,
address,
account,
message,
} => {
writer.write_all(b"900 ").await?; writer.write_all(b"900 ").await?;
writer.write_all(nick.as_bytes()).await?; writer.write_all(nick.as_bytes()).await?;
writer.write_all(b" ").await?; writer.write_all(b" ").await?;
@ -395,7 +404,7 @@ fn server_message_body(input: &str) -> IResult<&str, ServerMessageBody> {
server_message_body_notice, server_message_body_notice,
server_message_body_ping, server_message_body_ping,
server_message_body_pong, server_message_body_pong,
server_message_body_cap, server_message_body_cap
))(input) ))(input)
} }

View File

@ -42,19 +42,27 @@ impl Display for Jid {
impl Jid { impl Jid {
pub fn from_string(i: &str) -> Result<Jid> { pub fn from_string(i: &str) -> Result<Jid> {
use lazy_static::lazy_static;
use regex::Regex; use regex::Regex;
use lazy_static::lazy_static;
lazy_static! { lazy_static! {
static ref RE: Regex = Regex::new(r"^(([a-zA-Z]+)@)?([a-zA-Z.]+)(/([a-zA-Z\-]+))?$").unwrap(); static ref RE: Regex = Regex::new(r"^(([a-zA-Z]+)@)?([a-zA-Z.]+)(/([a-zA-Z\-]+))?$").unwrap();
} }
let m = RE.captures(i).ok_or(anyhow!("Incorrectly format jid: {i}"))?; let m = RE
.captures(i)
.ok_or(anyhow!("Incorrectly format jid: {i}"))?;
let name = m.get(2).map(|name| Name(name.as_str().into())); let name = m.get(2).map(|name| Name(name.as_str().into()));
let server = m.get(3).unwrap(); let server = m.get(3).unwrap();
let server = Server(server.as_str().into()); let server = Server(server.as_str().into());
let resource = m.get(5).map(|resource| Resource(resource.as_str().into())); let resource = m
.get(5)
.map(|resource| Resource(resource.as_str().into()));
Ok(Jid { name, server, resource }) Ok(Jid {
name,
server,
resource,
})
} }
} }
@ -129,7 +137,9 @@ pub struct BindResponse(pub Jid);
impl ToXml for BindResponse { impl ToXml for BindResponse {
fn serialize(&self, events: &mut Vec<Event<'static>>) { fn serialize(&self, events: &mut Vec<Event<'static>>) {
events.extend_from_slice(&[ events.extend_from_slice(&[
Event::Start(BytesStart::new(r#"bind xmlns="urn:ietf:params:xml:ns:xmpp-bind""#)), Event::Start(BytesStart::new(
r#"bind xmlns="urn:ietf:params:xml:ns:xmpp-bind""#,
)),
Event::Start(BytesStart::new(r#"jid"#)), Event::Start(BytesStart::new(r#"jid"#)),
Event::Text(BytesText::new(self.0.to_string().as_str()).into_owned()), Event::Text(BytesText::new(self.0.to_string().as_str()).into_owned()),
Event::End(BytesEnd::new("jid")), Event::End(BytesEnd::new("jid")),
@ -146,16 +156,23 @@ mod tests {
#[tokio::test] #[tokio::test]
async fn parse_message() { async fn parse_message() {
let input = r#"<bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"><resource>mobile</resource></bind>"#; let input =
r#"<bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"><resource>mobile</resource></bind>"#;
let mut reader = NsReader::from_reader(input.as_bytes()); let mut reader = NsReader::from_reader(input.as_bytes());
let mut buf = vec![]; let mut buf = vec![];
let (ns, event) = reader.read_resolved_event_into_async(&mut buf).await.unwrap(); let (ns, event) = reader
.read_resolved_event_into_async(&mut buf)
.await
.unwrap();
let mut parser = BindRequest::parse().consume(ns, &event); let mut parser = BindRequest::parse().consume(ns, &event);
let result = loop { let result = loop {
match parser { match parser {
Continuation::Final(res) => break res, Continuation::Final(res) => break res,
Continuation::Continue(next) => { Continuation::Continue(next) => {
let (ns, event) = reader.read_resolved_event_into_async(&mut buf).await.unwrap(); let (ns, event) = reader
.read_resolved_event_into_async(&mut buf)
.await
.unwrap();
parser = next.consume(ns, &event); parser = next.consume(ns, &event);
} }
} }

View File

@ -2,8 +2,8 @@ use quick_xml::events::attributes::Attribute;
use quick_xml::events::{BytesEnd, BytesStart, Event}; use quick_xml::events::{BytesEnd, BytesStart, Event};
use quick_xml::name::{QName, ResolveResult}; use quick_xml::name::{QName, ResolveResult};
use anyhow::{Result, anyhow as ffail};
use crate::xml::*; use crate::xml::*;
use anyhow::{anyhow as ffail, Result};
use super::bind::Jid; use super::bind::Jid;
@ -174,7 +174,11 @@ impl FromXml for Identity {
let Some(r#type) = r#type else { let Some(r#type) = r#type else {
return Err(ffail!("No type provided")); return Err(ffail!("No type provided"));
}; };
let item = Identity { category, name, r#type }; let item = Identity {
category,
name,
r#type,
};
if end { if end {
return Ok(item); return Ok(item);
} }

View File

@ -1,16 +1,21 @@
#![feature(coroutines, coroutine_trait, type_alias_impl_trait, impl_trait_in_assoc_type)] #![feature(
coroutines,
coroutine_trait,
type_alias_impl_trait,
impl_trait_in_assoc_type
)]
pub mod bind; pub mod bind;
pub mod client; pub mod client;
pub mod disco; pub mod disco;
pub mod muc; pub mod muc;
mod prelude;
pub mod roster; pub mod roster;
pub mod sasl; pub mod sasl;
pub mod session; pub mod session;
pub mod stanzaerror; pub mod stanzaerror;
pub mod stream; pub mod stream;
pub mod tls; pub mod tls;
mod prelude;
pub mod xml; pub mod xml;
// Implemented as a macro instead of a fn due to borrowck limitations // Implemented as a macro instead of a fn due to borrowck limitations

View File

@ -52,6 +52,9 @@ impl FromXmlTag for RosterQuery {
impl ToXml for RosterQuery { impl ToXml for RosterQuery {
fn serialize(&self, events: &mut Vec<Event<'static>>) { fn serialize(&self, events: &mut Vec<Event<'static>>) {
events.push(Event::Empty(BytesStart::new(format!(r#"query xmlns="{}""#, XMLNS)))); events.push(Event::Empty(BytesStart::new(format!(
r#"query xmlns="{}""#,
XMLNS
))));
} }
} }

View File

@ -25,7 +25,9 @@ impl Parser for SessionParser {
) -> Continuation<Self, Self::Output> { ) -> Continuation<Self, Self::Output> {
match self.0 { match self.0 {
SessionParserInner::Initial => match event { SessionParserInner::Initial => match event {
Event::Start(_) => Continuation::Continue(SessionParser(SessionParserInner::InSession)), Event::Start(_) => {
Continuation::Continue(SessionParser(SessionParserInner::InSession))
}
Event::Empty(_) => Continuation::Final(Ok(Session)), Event::Empty(_) => Continuation::Final(Ok(Session)),
_ => Continuation::Final(Err(anyhow!("Unexpected XML event: {event:?}"))), _ => Continuation::Final(Err(anyhow!("Unexpected XML event: {event:?}"))),
}, },
@ -52,6 +54,9 @@ impl FromXmlTag for Session {
impl ToXml for Session { impl ToXml for Session {
fn serialize(&self, events: &mut Vec<Event<'static>>) { fn serialize(&self, events: &mut Vec<Event<'static>>) {
events.push(Event::Empty(BytesStart::new(format!(r#"session xmlns="{}""#, XMLNS)))); events.push(Event::Empty(BytesStart::new(format!(
r#"session xmlns="{}""#,
XMLNS
))));
} }
} }

View File

@ -6,8 +6,8 @@ use tokio::io::{AsyncBufRead, AsyncWrite};
use super::skip_text; use super::skip_text;
use crate::xml::ToXml;
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Result};
use crate::xml::ToXml;
pub static XMLNS: &'static str = "http://etherx.jabber.org/streams"; pub static XMLNS: &'static str = "http://etherx.jabber.org/streams";
pub static PREFIX: &'static str = "stream"; pub static PREFIX: &'static str = "stream";
@ -44,7 +44,10 @@ impl ClientStreamStart {
let value = attr.unescape_value()?; let value = attr.unescape_value()?;
to = Some(value.to_string()); to = Some(value.to_string());
} }
(ResolveResult::Bound(Namespace(b"http://www.w3.org/XML/1998/namespace")), b"lang") => { (
ResolveResult::Bound(Namespace(b"http://www.w3.org/XML/1998/namespace")),
b"lang",
) => {
let value = attr.unescape_value()?; let value = attr.unescape_value()?;
lang = Some(value.to_string()); lang = Some(value.to_string());
} }
@ -121,15 +124,21 @@ pub struct Features {
} }
impl Features { impl Features {
pub async fn write_xml(&self, writer: &mut Writer<impl AsyncWrite + Unpin>) -> Result<()> { pub async fn write_xml(&self, writer: &mut Writer<impl AsyncWrite + Unpin>) -> Result<()> {
writer.write_event_async(Event::Start(BytesStart::new("stream:features"))).await?; writer
.write_event_async(Event::Start(BytesStart::new("stream:features")))
.await?;
if self.start_tls { if self.start_tls {
writer writer
.write_event_async(Event::Start(BytesStart::new( .write_event_async(Event::Start(BytesStart::new(
r#"starttls xmlns="urn:ietf:params:xml:ns:xmpp-tls""#, r#"starttls xmlns="urn:ietf:params:xml:ns:xmpp-tls""#,
))) )))
.await?; .await?;
writer.write_event_async(Event::Empty(BytesStart::new("required"))).await?; writer
writer.write_event_async(Event::End(BytesEnd::new("starttls"))).await?; .write_event_async(Event::Empty(BytesStart::new("required")))
.await?;
writer
.write_event_async(Event::End(BytesEnd::new("starttls")))
.await?;
} }
if self.mechanisms { if self.mechanisms {
writer writer
@ -137,10 +146,18 @@ impl Features {
r#"mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl""#, r#"mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl""#,
))) )))
.await?; .await?;
writer.write_event_async(Event::Start(BytesStart::new(r#"mechanism"#))).await?; writer
writer.write_event_async(Event::Text(BytesText::new("PLAIN"))).await?; .write_event_async(Event::Start(BytesStart::new(r#"mechanism"#)))
writer.write_event_async(Event::End(BytesEnd::new("mechanism"))).await?; .await?;
writer.write_event_async(Event::End(BytesEnd::new("mechanisms"))).await?; writer
.write_event_async(Event::Text(BytesText::new("PLAIN")))
.await?;
writer
.write_event_async(Event::End(BytesEnd::new("mechanism")))
.await?;
writer
.write_event_async(Event::End(BytesEnd::new("mechanisms")))
.await?;
} }
if self.bind { if self.bind {
writer writer
@ -149,7 +166,9 @@ impl Features {
))) )))
.await?; .await?;
} }
writer.write_event_async(Event::End(BytesEnd::new("stream:features"))).await?; writer
.write_event_async(Event::End(BytesEnd::new("stream:features")))
.await?;
Ok(()) Ok(())
} }
} }
@ -163,7 +182,9 @@ mod test {
let input = r###"<stream:stream xmlns:stream="http://etherx.jabber.org/streams" to="vlnv.dev" version="1.0" xmlns="jabber:client" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace">"###; let input = r###"<stream:stream xmlns:stream="http://etherx.jabber.org/streams" to="vlnv.dev" version="1.0" xmlns="jabber:client" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace">"###;
let mut reader = NsReader::from_reader(input.as_bytes()); let mut reader = NsReader::from_reader(input.as_bytes());
let mut buf = vec![]; let mut buf = vec![];
let res = ClientStreamStart::parse(&mut reader, &mut buf).await.unwrap(); let res = ClientStreamStart::parse(&mut reader, &mut buf)
.await
.unwrap();
assert_eq!( assert_eq!(
res, res,
ClientStreamStart { ClientStreamStart {

View File

@ -12,7 +12,10 @@ pub static XMLNS: &'static str = "urn:ietf:params:xml:ns:xmpp-tls";
pub struct StartTLS; pub struct StartTLS;
impl StartTLS { impl StartTLS {
pub async fn parse(reader: &mut NsReader<impl AsyncBufRead + Unpin>, buf: &mut Vec<u8>) -> Result<StartTLS> { pub async fn parse(
reader: &mut NsReader<impl AsyncBufRead + Unpin>,
buf: &mut Vec<u8>,
) -> Result<StartTLS> {
let incoming = skip_text!(reader, buf); let incoming = skip_text!(reader, buf);
if let Event::Empty(ref e) = incoming { if let Event::Empty(ref e) = incoming {
if e.name().0 == b"starttls" { if e.name().0 == b"starttls" {

View File

@ -15,7 +15,11 @@ enum IgnoreParserInner {
impl Parser for IgnoreParser { impl Parser for IgnoreParser {
type Output = Result<Ignore>; type Output = Result<Ignore>;
fn consume<'a>(self: Self, _: ResolveResult, event: &Event<'a>) -> Continuation<Self, Self::Output> { fn consume<'a>(
self: Self,
_: ResolveResult,
event: &Event<'a>,
) -> Continuation<Self, Self::Output> {
match self.0 { match self.0 {
IgnoreParserInner::Initial => match event { IgnoreParserInner::Initial => match event {
Event::Start(bytes) => { Event::Start(bytes) => {
@ -30,7 +34,13 @@ impl Parser for IgnoreParser {
if depth == 0 { if depth == 0 {
Continuation::Final(Ok(Ignore)) Continuation::Final(Ok(Ignore))
} else { } else {
Continuation::Continue(IgnoreParserInner::InTag { name, depth: depth - 1 }.into()) Continuation::Continue(
IgnoreParserInner::InTag {
name,
depth: depth - 1,
}
.into(),
)
} }
} }
_ => Continuation::Continue(IgnoreParserInner::InTag { name, depth }.into()), _ => Continuation::Continue(IgnoreParserInner::InTag { name, depth }.into()),

View File

@ -1,9 +1,9 @@
use std::ops::Coroutine; use std::ops::Coroutine;
use std::pin::Pin; use std::pin::Pin;
use quick_xml::NsReader;
use quick_xml::events::Event; use quick_xml::events::Event;
use quick_xml::name::ResolveResult; use quick_xml::name::ResolveResult;
use quick_xml::NsReader;
use anyhow::Result; use anyhow::Result;
@ -28,16 +28,25 @@ pub trait FromXmlTag: FromXml {
pub trait Parser: Sized { pub trait Parser: Sized {
type Output; type Output;
fn consume<'a>(self: Self, namespace: ResolveResult, event: &Event<'a>) -> Continuation<Self, Self::Output>; fn consume<'a>(
self: Self,
namespace: ResolveResult,
event: &Event<'a>,
) -> Continuation<Self, Self::Output>;
} }
impl<T, Out> Parser for T impl<T, Out> Parser for T
where where
T: Coroutine<(ResolveResult<'static>, &'static Event<'static>), Yield = (), Return = Out> + Unpin, T: Coroutine<(ResolveResult<'static>, &'static Event<'static>), Yield = (), Return = Out>
+ Unpin,
{ {
type Output = Out; type Output = Out;
fn consume<'a>(mut self: Self, namespace: ResolveResult, event: &Event<'a>) -> Continuation<Self, Self::Output> { fn consume<'a>(
mut self: Self,
namespace: ResolveResult,
event: &Event<'a>,
) -> Continuation<Self, Self::Output> {
let s = Pin::new(&mut self); let s = Pin::new(&mut self);
// this is a very rude workaround fixing the fact that rust coroutines // this is a very rude workaround fixing the fact that rust coroutines
// 1. don't support higher-kinded lifetimes (i.e. no `impl for <'a> Coroutine<Event<'a>>) // 1. don't support higher-kinded lifetimes (i.e. no `impl for <'a> Coroutine<Event<'a>>)

View File

@ -1 +1 @@
nightly-2024-03-20 nightly-2024-02-08

View File

@ -1,2 +1 @@
max_width = 120 max_width = 120
chain_width = 120

View File

@ -62,14 +62,7 @@ async fn main() -> Result<()> {
storage.clone(), storage.clone(),
) )
.await?; .await?;
let xmpp = projection_xmpp::launch( let xmpp = projection_xmpp::launch(xmpp_config, players.clone(), rooms.clone(), metrics.clone(), storage.clone()).await?;
xmpp_config,
players.clone(),
rooms.clone(),
metrics.clone(),
storage.clone(),
)
.await?;
tracing::info!("Started"); tracing::info!("Started");
sleep.await; sleep.await;