.pre-commit-config.yaml

@@ -1,21 +0,0 @@
-repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
-    hooks:
-      - id: check-toml
-      - id: end-of-file-fixer
-      - id: fix-byte-order-marker
-      - id: mixed-line-ending
-      - id: trailing-whitespace
-
-  - repo: local
-    hooks:
-      - id: fmt
-        name: fmt
-        description: Format
-        entry: cargo fmt
-        language: system
-        args:
-          - --all
-        types: [ rust ]
-        pass_filenames: false

Cargo.lock

@@ -45,21 +45,6 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
 
-[[package]]
-name = "android-tzdata"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
-
-[[package]]
-name = "android_system_properties"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "anstream"
 version = "0.6.13"
@@ -231,20 +216,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
-[[package]]
-name = "chrono"
-version = "0.4.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
-dependencies = [
- "android-tzdata",
- "iana-time-zone",
- "js-sys",
- "num-traits",
- "wasm-bindgen",
- "windows-targets 0.52.4",
-]
-
 [[package]]
 name = "clap"
 version = "4.5.3"
@@ -303,12 +274,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
 
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
-
 [[package]]
 name = "cpufeatures"
 version = "0.2.12"
@@ -764,29 +729,6 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "iana-time-zone"
-version = "0.1.60"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
-dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "iana-time-zone-haiku",
- "js-sys",
- "wasm-bindgen",
- "windows-core",
-]
-
-[[package]]
-name = "iana-time-zone-haiku"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "idna"
 version = "0.5.0"
@@ -876,7 +818,6 @@ name = "lavina-core"
 version = "0.0.2-dev"
 dependencies = [
  "anyhow",
- "chrono",
  "prometheus",
  "serde",
  "sqlx",
@@ -2442,15 +2383,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
-[[package]]
-name = "windows-core"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
-dependencies = [
- "windows-targets 0.52.4",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.48.0"

config.toml

@@ -9,7 +9,6 @@ server_name = "irc.localhost"
 listen_on = "127.0.0.1:5222"
 cert = "./certs/xmpp.pem"
 key = "./certs/xmpp.key"
-hostname = "localhost"
 
 [storage]
 db_path = "db.sqlite"

crates/lavina-core/Cargo.toml

@@ -10,4 +10,3 @@ serde.workspace = true
 tokio.workspace = true
 tracing.workspace = true
 prometheus.workspace = true
-chrono = "0.4.37"

crates/lavina-core/migrations/2_created_at_for_messages.sql

@@ -1 +0,0 @@
-alter table messages add column created_at text;

crates/lavina-core/src/player.rs

@@ -7,16 +7,16 @@
 //!
 //! A player actor is a serial handler of commands from a single player. It is preferable to run all per-player validations in the player actor,
 //! so that they don't overload the room actor.
-use std::collections::{HashMap, HashSet};
+use std::{
-use std::sync::Arc;
+    collections::{HashMap, HashSet},
+    sync::{Arc, RwLock},
+};
 
 use prometheus::{IntGauge, Registry as MetricsRegistry};
 use serde::Serialize;
 use tokio::sync::mpsc::{channel, Receiver, Sender};
-use tokio::sync::RwLock;
 
 use crate::prelude::*;
-use crate::repo::Storage;
 use crate::room::{RoomHandle, RoomId, RoomInfo, RoomRegistry};
 use crate::table::{AnonTable, Key as AnonKey};
 
@@ -208,41 +208,36 @@ pub enum Updates {
 #[derive(Clone)]
 pub struct PlayerRegistry(Arc<RwLock<PlayerRegistryInner>>);
 impl PlayerRegistry {
-    pub fn empty(
+    pub fn empty(room_registry: RoomRegistry, metrics: &mut MetricsRegistry) -> Result<PlayerRegistry> {
-        room_registry: RoomRegistry,
-        storage: Storage,
-        metrics: &mut MetricsRegistry,
-    ) -> Result<PlayerRegistry> {
         let metric_active_players = IntGauge::new("chat_players_active", "Number of alive player actors")?;
         metrics.register(Box::new(metric_active_players.clone()))?;
         let inner = PlayerRegistryInner {
             room_registry,
-            storage,
             players: HashMap::new(),
             metric_active_players,
         };
         Ok(PlayerRegistry(Arc::new(RwLock::new(inner))))
     }
 
-    pub async fn get_or_launch_player(&mut self, id: &PlayerId) -> PlayerHandle {
+    pub async fn get_or_create_player(&mut self, id: PlayerId) -> PlayerHandle {
-        let mut inner = self.0.write().await;
+        let mut inner = self.0.write().unwrap();
-        if let Some((handle, _)) = inner.players.get(id) {
+        if let Some((handle, _)) = inner.players.get(&id) {
             handle.clone()
         } else {
-            let (handle, fiber) = Player::launch(id.clone(), inner.room_registry.clone(), inner.storage.clone()).await;
+            let (handle, fiber) = Player::launch(id.clone(), inner.room_registry.clone());
-            inner.players.insert(id.clone(), (handle.clone(), fiber));
+            inner.players.insert(id, (handle.clone(), fiber));
             inner.metric_active_players.inc();
             handle
         }
     }
 
-    pub async fn connect_to_player(&mut self, id: &PlayerId) -> PlayerConnection {
+    pub async fn connect_to_player(&mut self, id: PlayerId) -> PlayerConnection {
-        let player_handle = self.get_or_launch_player(id).await;
+        let player_handle = self.get_or_create_player(id).await;
         player_handle.subscribe().await
     }
 
     pub async fn shutdown_all(&mut self) -> Result<()> {
-        let mut inner = self.0.write().await;
+        let mut inner = self.0.write().unwrap();
         for (i, (k, j)) in inner.players.drain() {
             k.send(ActorCommand::Stop).await;
             drop(k);
@@ -257,8 +252,6 @@ impl PlayerRegistry {
 /// The player registry state representation.
 struct PlayerRegistryInner {
     room_registry: RoomRegistry,
-    storage: Storage,
-    /// Active player actors.
     players: HashMap<PlayerId, (PlayerHandle, JoinHandle<Player>)>,
     metric_active_players: IntGauge,
 }
@@ -266,49 +259,32 @@ struct PlayerRegistryInner {
 /// Player actor inner state representation.
 struct Player {
     player_id: PlayerId,
-    storage_id: u32,
     connections: AnonTable<Sender<Updates>>,
     my_rooms: HashMap<RoomId, RoomHandle>,
     banned_from: HashSet<RoomId>,
     rx: Receiver<ActorCommand>,
     handle: PlayerHandle,
     rooms: RoomRegistry,
-    storage: Storage,
 }
 impl Player {
-    async fn launch(player_id: PlayerId, rooms: RoomRegistry, storage: Storage) -> (PlayerHandle, JoinHandle<Player>) {
+    fn launch(player_id: PlayerId, rooms: RoomRegistry) -> (PlayerHandle, JoinHandle<Player>) {
         let (tx, rx) = channel(32);
         let handle = PlayerHandle { tx };
         let handle_clone = handle.clone();
-        let storage_id = storage.retrieve_user_id_by_name(player_id.as_inner()).await.unwrap().unwrap();
         let player = Player {
             player_id,
-            storage_id,
-            // connections are empty when the actor is just started
             connections: AnonTable::new(),
-            // room handlers will be loaded later in the started task
             my_rooms: HashMap::new(),
-            // TODO implement and load bans
+            banned_from: HashSet::from([RoomId::from("Empty").unwrap()]),
-            banned_from: HashSet::new(),
             rx,
             handle,
             rooms,
-            storage,
         };
         let fiber = tokio::task::spawn(player.main_loop());
         (handle_clone, fiber)
     }
 
     async fn main_loop(mut self) -> Self {
-        let rooms = self.storage.get_rooms_of_a_user(self.storage_id).await.unwrap();
-        for room_id in rooms {
-            let room = self.rooms.get_room(&room_id).await;
-            if let Some(room) = room {
-                self.my_rooms.insert(room_id, room);
-            } else {
-                tracing::error!("Room #{room_id:?} not found");
-            }
-        }
         while let Some(cmd) = self.rx.recv().await {
             match cmd {
                 ActorCommand::AddConnection { sender, promise } => {
@@ -396,8 +372,7 @@ impl Player {
                 todo!();
             }
         };
-        room.add_member(&self.player_id, self.storage_id).await;
+        room.subscribe(self.player_id.clone(), self.handle.clone()).await;
-        room.subscribe(&self.player_id, self.handle.clone()).await;
         self.my_rooms.insert(room_id.clone(), room.clone());
         let room_info = room.get_room_info().await;
         let update = Updates::RoomJoined {
@@ -412,7 +387,6 @@ impl Player {
         let room = self.my_rooms.remove(&room_id);
         if let Some(room) = room {
             room.unsubscribe(&self.player_id).await;
-            room.remove_member(&self.player_id, self.storage_id).await;
         }
         let update = Updates::RoomLeft {
             room_id,
@@ -422,11 +396,12 @@ impl Player {
     }
 
     async fn send_message(&mut self, connection_id: ConnectionId, room_id: RoomId, body: Str) {
-        let Some(room) = self.my_rooms.get(&room_id) else {
+        let room = self.rooms.get_room(&room_id).await;
+        if let Some(room) = room {
+            room.send_message(self.player_id.clone(), body.clone()).await;
+        } else {
             tracing::info!("no room found");
-            return;
+        }
-        };
-        room.send_message(&self.player_id, body.clone()).await;
         let update = Updates::NewMessage {
             room_id,
             author_id: self.player_id.clone(),
@@ -436,11 +411,12 @@ impl Player {
     }
 
     async fn change_topic(&mut self, connection_id: ConnectionId, room_id: RoomId, new_topic: Str) {
-        let Some(room) = self.my_rooms.get(&room_id) else {
+        let room = self.rooms.get_room(&room_id).await;
+        if let Some(mut room) = room {
+            room.set_topic(self.player_id.clone(), new_topic.clone()).await;
+        } else {
             tracing::info!("no room found");
-            return;
+        }
-        };
-        room.set_topic(&self.player_id, new_topic.clone()).await;
         let update = Updates::RoomTopicChanged { room_id, new_topic };
         self.broadcast_update(update, connection_id).await;
     }

crates/lavina-core/src/repo/mod.rs

@@ -11,9 +11,6 @@ use tokio::sync::Mutex;
 
 use crate::prelude::*;
 
-mod room;
-mod user;
-
 #[derive(Deserialize, Debug, Clone)]
 pub struct StorageConfig {
     pub db_path: String,
@@ -51,7 +48,7 @@ impl Storage {
         Ok(res)
     }
 
-    pub async fn retrieve_room_by_name(&self, name: &str) -> Result<Option<StoredRoom>> {
+    pub async fn retrieve_room_by_name(&mut self, name: &str) -> Result<Option<StoredRoom>> {
         let mut executor = self.conn.lock().await;
         let res = sqlx::query_as(
             "select id, name, topic, message_count
@@ -90,15 +87,14 @@ impl Storage {
             return Err(anyhow!("No such user"));
         };
         sqlx::query(
-            "insert into messages(room_id, id, content, author_id, created_at)
+            "insert into messages(room_id, id, content, author_id)
-            values (?, ?, ?, ?, ?);
+            values (?, ?, ?, ?);
             update rooms set message_count = message_count + 1 where id = ?;",
         )
         .bind(room_id)
         .bind(id)
         .bind(content)
         .bind(author_id)
-        .bind(chrono::Utc::now().to_string())
         .bind(room_id)
         .execute(&mut *executor)
         .await?;

crates/lavina-core/src/repo/room.rs

@@ -1,48 +0,0 @@
-use anyhow::Result;
-
-use crate::repo::Storage;
-
-impl Storage {
-    pub async fn add_room_member(&self, room_id: u32, player_id: u32) -> Result<()> {
-        let mut executor = self.conn.lock().await;
-        sqlx::query(
-            "insert into memberships(user_id, room_id, status)
-            values (?, ?, 1);",
-        )
-        .bind(player_id)
-        .bind(room_id)
-        .execute(&mut *executor)
-        .await?;
-
-        Ok(())
-    }
-
-    pub async fn remove_room_member(&self, room_id: u32, player_id: u32) -> Result<()> {
-        let mut executor = self.conn.lock().await;
-        sqlx::query(
-            "delete from memberships
-            where user_id = ? and room_id = ?;",
-        )
-        .bind(player_id)
-        .bind(room_id)
-        .execute(&mut *executor)
-        .await?;
-
-        Ok(())
-    }
-
-    pub async fn set_room_topic(&mut self, id: u32, topic: &str) -> Result<()> {
-        let mut executor = self.conn.lock().await;
-        sqlx::query(
-            "update rooms
-            set topic = ?
-            where id = ?;",
-        )
-        .bind(topic)
-        .bind(id)
-        .fetch_optional(&mut *executor)
-        .await?;
-
-        Ok(())
-    }
-}

crates/lavina-core/src/repo/user.rs

@@ -1,30 +0,0 @@
-use anyhow::Result;
-
-use crate::repo::Storage;
-use crate::room::RoomId;
-
-impl Storage {
-    pub async fn retrieve_user_id_by_name(&self, name: &str) -> Result<Option<u32>> {
-        let mut executor = self.conn.lock().await;
-        let res: Option<(u32,)> = sqlx::query_as("select u.id from users u where u.name = ?;")
-            .bind(name)
-            .fetch_optional(&mut *executor)
-            .await?;
-
-        Ok(res.map(|(id,)| id))
-    }
-
-    pub async fn get_rooms_of_a_user(&self, user_id: u32) -> Result<Vec<RoomId>> {
-        let mut executor = self.conn.lock().await;
-        let res: Vec<(String,)> = sqlx::query_as(
-            "select r.name
-            from memberships m inner join rooms r on m.room_id = r.id
-            where m.user_id = ?;",
-        )
-        .bind(user_id)
-        .fetch_all(&mut *executor)
-        .await?;
-
-        res.into_iter().map(|(room_id,)| RoomId::from(room_id)).collect()
-    }
-}

crates/lavina-core/src/room.rs

@@ -1,5 +1,4 @@
 //! Domain of rooms — chats with multiple participants.
-use std::collections::HashSet;
 use std::{collections::HashMap, hash::Hash, sync::Arc};
 
 use prometheus::{IntGauge, Registry as MetricRegistry};
@@ -49,9 +48,27 @@ impl RoomRegistry {
 
     pub async fn get_or_create_room(&mut self, room_id: RoomId) -> Result<RoomHandle> {
         let mut inner = self.0.write().await;
-        if let Some(room_handle) = inner.get_or_load_room(&room_id).await? {
+        if let Some(room_handle) = inner.rooms.get(&room_id) {
+            // room was already loaded into memory
+            log::debug!("Room {} was loaded already", &room_id.0);
             Ok(room_handle.clone())
+        } else if let Some(stored_room) = inner.storage.retrieve_room_by_name(&*room_id.0).await? {
+            // room exists, but was not loaded
+            log::debug!("Loading room {}...", &room_id.0);
+            let room = Room {
+                storage_id: stored_room.id,
+                room_id: room_id.clone(),
+                subscriptions: HashMap::new(), // TODO figure out how to populate subscriptions
+                topic: stored_room.topic.into(),
+                message_count: stored_room.message_count,
+                storage: inner.storage.clone(),
+            };
+            let room_handle = RoomHandle(Arc::new(AsyncRwLock::new(room)));
+            inner.rooms.insert(room_id, room_handle.clone());
+            inner.metric_active_rooms.inc();
+            Ok(room_handle)
         } else {
+            // room does not exist, create it and load
             log::debug!("Creating room {}...", &room_id.0);
             let topic = "New room";
             let id = inner.storage.create_new_room(&*room_id.0, &*topic).await?;
@@ -59,7 +76,6 @@ impl RoomRegistry {
                 storage_id: id,
                 room_id: room_id.clone(),
                 subscriptions: HashMap::new(),
-                members: HashSet::new(),
                 topic: topic.into(),
                 message_count: 0,
                 storage: inner.storage.clone(),
@@ -72,8 +88,9 @@ impl RoomRegistry {
     }
 
     pub async fn get_room(&self, room_id: &RoomId) -> Option<RoomHandle> {
-        let mut inner = self.0.write().await;
+        let inner = self.0.read().await;
-        inner.get_or_load_room(room_id).await.unwrap()
+        let res = inner.rooms.get(room_id);
+        res.map(|r| r.clone())
     }
 
     pub async fn get_all_rooms(&self) -> Vec<RoomInfo> {
@@ -96,66 +113,17 @@ struct RoomRegistryInner {
     storage: Storage,
 }
 
-impl RoomRegistryInner {
-    async fn get_or_load_room(&mut self, room_id: &RoomId) -> Result<Option<RoomHandle>> {
-        if let Some(room_handle) = self.rooms.get(room_id) {
-            log::debug!("Room {} was loaded already", &room_id.0);
-            Ok(Some(room_handle.clone()))
-        } else if let Some(stored_room) = self.storage.retrieve_room_by_name(&*room_id.0).await? {
-            log::debug!("Loading room {}...", &room_id.0);
-            let room = Room {
-                storage_id: stored_room.id,
-                room_id: room_id.clone(),
-                subscriptions: HashMap::new(),
-                members: HashSet::new(), // TODO load members from storage
-                topic: stored_room.topic.into(),
-                message_count: stored_room.message_count,
-                storage: self.storage.clone(),
-            };
-            let room_handle = RoomHandle(Arc::new(AsyncRwLock::new(room)));
-            self.rooms.insert(room_id.clone(), room_handle.clone());
-            self.metric_active_rooms.inc();
-            Ok(Some(room_handle))
-        } else {
-            tracing::debug!("Room {} does not exist", &room_id.0);
-            Ok(None)
-        }
-    }
-}
-
 #[derive(Clone)]
 pub struct RoomHandle(Arc<AsyncRwLock<Room>>);
 impl RoomHandle {
-    pub async fn subscribe(&self, player_id: &PlayerId, player_handle: PlayerHandle) {
+    pub async fn subscribe(&self, player_id: PlayerId, player_handle: PlayerHandle) {
         let mut lock = self.0.write().await;
-        tracing::info!("Adding a subscriber to a room");
+        lock.add_subscriber(player_id, player_handle).await;
-        lock.subscriptions.insert(player_id.clone(), player_handle);
-    }
-
-    pub async fn add_member(&self, player_id: &PlayerId, player_storage_id: u32) {
-        let mut lock = self.0.write().await;
-        tracing::info!("Adding a new member to a room");
-        let room_storage_id = lock.storage_id;
-        lock.storage.add_room_member(room_storage_id, player_storage_id).await.unwrap();
-        lock.members.insert(player_id.clone());
-        let update = Updates::RoomJoined {
-            room_id: lock.room_id.clone(),
-            new_member_id: player_id.clone(),
-        };
-        lock.broadcast_update(update, player_id).await;
     }
 
     pub async fn unsubscribe(&self, player_id: &PlayerId) {
         let mut lock = self.0.write().await;
         lock.subscriptions.remove(player_id);
-    }
-
-    pub async fn remove_member(&self, player_id: &PlayerId, player_storage_id: u32) {
-        let mut lock = self.0.write().await;
-        tracing::info!("Removing a member from a room");
-        let room_storage_id = lock.storage_id;
-        lock.storage.remove_room_member(room_storage_id, player_storage_id).await.unwrap();
-        lock.members.remove(player_id);
         let update = Updates::RoomLeft {
             room_id: lock.room_id.clone(),
             former_member_id: player_id.clone(),
@@ -163,7 +131,7 @@ impl RoomHandle {
         lock.broadcast_update(update, player_id).await;
     }
 
-    pub async fn send_message(&self, player_id: &PlayerId, body: Str) {
+    pub async fn send_message(&self, player_id: PlayerId, body: Str) {
         let mut lock = self.0.write().await;
         let res = lock.send_message(player_id, body).await;
         if let Err(err) = res {
@@ -180,16 +148,14 @@ impl RoomHandle {
         }
     }
 
-    pub async fn set_topic(&self, changer_id: &PlayerId, new_topic: Str) {
+    pub async fn set_topic(&mut self, changer_id: PlayerId, new_topic: Str) {
         let mut lock = self.0.write().await;
-        let storage_id = lock.storage_id;
         lock.topic = new_topic.clone();
-        lock.storage.set_room_topic(storage_id, &new_topic).await.unwrap();
         let update = Updates::RoomTopicChanged {
             room_id: lock.room_id.clone(),
             new_topic: new_topic.clone(),
         };
-        lock.broadcast_update(update, changer_id).await;
+        lock.broadcast_update(update, &changer_id).await;
     }
 }
 
@@ -200,15 +166,23 @@ struct Room {
     room_id: RoomId,
     /// Player actors on the local node which are subscribed to this room's updates.
     subscriptions: HashMap<PlayerId, PlayerHandle>,
-    /// Members of the room.
-    members: HashSet<PlayerId>,
     /// The total number of messages. Used to calculate the id of the new message.
     message_count: u32,
     topic: Str,
     storage: Storage,
 }
 impl Room {
-    async fn send_message(&mut self, author_id: &PlayerId, body: Str) -> Result<()> {
+    async fn add_subscriber(&mut self, player_id: PlayerId, player_handle: PlayerHandle) {
+        tracing::info!("Adding a subscriber to room");
+        self.subscriptions.insert(player_id.clone(), player_handle);
+        let update = Updates::RoomJoined {
+            room_id: self.room_id.clone(),
+            new_member_id: player_id.clone(),
+        };
+        self.broadcast_update(update, &player_id).await;
+    }
+
+    async fn send_message(&mut self, author_id: PlayerId, body: Str) -> Result<()> {
         tracing::info!("Adding a message to room");
         self.storage.insert_message(self.storage_id, self.message_count, &body, &*author_id.as_inner()).await?;
         self.message_count += 1;
@@ -217,7 +191,7 @@ impl Room {
             author_id: author_id.clone(),
             body,
         };
-        self.broadcast_update(update, author_id).await;
+        self.broadcast_update(update, &author_id).await;
         Ok(())
     }
 

crates/projection-irc/src/lib.rs

@@ -86,249 +86,6 @@ async fn handle_socket(
     Ok(())
 }
 
-struct RegistrationState {
-    /// The last received `NICK` message.
-    future_nickname: Option<Str>,
-    /// The last received `USER` message.
-    future_username: Option<(Str, Str)>,
-    enabled_capabilities: Capabilities,
-    /// `CAP LS` or `CAP REQ` was received, but not `CAP END`.
-    cap_negotiation_in_progress: bool,
-    /// The last received `PASS` message.
-    pass: Option<Str>,
-    authentication_started: bool,
-    validated_user: Option<Str>,
-}
-
-impl RegistrationState {
-    fn new() -> RegistrationState {
-        RegistrationState {
-            future_nickname: None,
-            future_username: None,
-            enabled_capabilities: Capabilities::None,
-            cap_negotiation_in_progress: false,
-            pass: None,
-            authentication_started: false,
-            validated_user: None,
-        }
-    }
-
-    /// Handle an incoming message from the client during the registration process.
-    ///
-    /// Returns `Some` if the user is fully registered, `None` if the registration is still in progress.
-    async fn handle_msg(
-        &mut self,
-        msg: ClientMessage,
-        writer: &mut BufWriter<WriteHalf<'_>>,
-        storage: &mut Storage,
-        config: &ServerConfig,
-    ) -> Result<Option<RegisteredUser>> {
-        match msg {
-            ClientMessage::Pass { password } => {
-                self.pass = Some(password);
-                Ok(None)
-            }
-            ClientMessage::Capability { subcommand } => match subcommand {
-                CapabilitySubcommand::List { code: _ } => {
-                    self.cap_negotiation_in_progress = true;
-                    ServerMessage {
-                        tags: vec![],
-                        sender: Some(config.server_name.clone().into()),
-                        body: ServerMessageBody::Cap {
-                            target: self.future_nickname.clone().unwrap_or_else(|| "*".into()),
-                            subcmd: CapSubBody::Ls("sasl=PLAIN".into()),
-                        },
-                    }
-                    .write_async(writer)
-                    .await?;
-                    writer.flush().await?;
-                    Ok(None)
-                }
-                CapabilitySubcommand::Req(caps) => {
-                    self.cap_negotiation_in_progress = true;
-                    let mut acked = vec![];
-                    let mut naked = vec![];
-                    for cap in caps {
-                        if &*cap.name == "sasl" {
-                            if cap.to_disable {
-                                self.enabled_capabilities &= !Capabilities::Sasl;
-                            } else {
-                                self.enabled_capabilities |= Capabilities::Sasl;
-                            }
-                            acked.push(cap);
-                        } else {
-                            naked.push(cap);
-                        }
-                    }
-                    let mut ack_body = String::new();
-                    for cap in acked {
-                        if cap.to_disable {
-                            ack_body.push('-');
-                        }
-                        ack_body += &*cap.name;
-                    }
-                    ServerMessage {
-                        tags: vec![],
-                        sender: Some(config.server_name.clone().into()),
-                        body: ServerMessageBody::Cap {
-                            target: self.future_nickname.clone().unwrap_or_else(|| "*".into()),
-                            subcmd: CapSubBody::Ack(ack_body.into()),
-                        },
-                    }
-                    .write_async(writer)
-                    .await?;
-                    writer.flush().await?;
-                    Ok(None)
-                }
-                CapabilitySubcommand::End => {
-                    let Some((ref username, ref realname)) = self.future_username else {
-                        self.cap_negotiation_in_progress = false;
-                        return Ok(None);
-                    };
-                    let Some(nickname) = self.future_nickname.clone() else {
-                        self.cap_negotiation_in_progress = false;
-                        return Ok(None);
-                    };
-                    let username = username.clone();
-                    let realname = realname.clone();
-                    let candidate_user = RegisteredUser {
-                        nickname: nickname.clone(),
-                        username,
-                        realname,
-                    };
-                    self.finalize_auth(candidate_user, writer, storage, config).await
-                }
-            },
-            ClientMessage::Nick { nickname } => {
-                if self.cap_negotiation_in_progress {
-                    self.future_nickname = Some(nickname);
-                    Ok(None)
-                } else if let Some((username, realname)) = &self.future_username.clone() {
-                    let candidate_user = RegisteredUser {
-                        nickname: nickname.clone(),
-                        username: username.clone(),
-                        realname: realname.clone(),
-                    };
-                    self.finalize_auth(candidate_user, writer, storage, config).await
-                } else {
-                    self.future_nickname = Some(nickname);
-                    Ok(None)
-                }
-            }
-            ClientMessage::User { username, realname } => {
-                if self.cap_negotiation_in_progress {
-                    self.future_username = Some((username, realname));
-                    Ok(None)
-                } else if let Some(nickname) = self.future_nickname.clone() {
-                    let candidate_user = RegisteredUser {
-                        nickname: nickname.clone(),
-                        username,
-                        realname,
-                    };
-                    self.finalize_auth(candidate_user, writer, storage, config).await
-                } else {
-                    self.future_username = Some((username, realname));
-                    Ok(None)
-                }
-            }
-            ClientMessage::Authenticate(body) => {
-                if !self.authentication_started {
-                    tracing::debug!("Received authentication request");
-                    if &*body == "PLAIN" {
-                        tracing::debug!("Authentication request with method PLAIN");
-                        self.authentication_started = true;
-                        ServerMessage {
-                            tags: vec![],
-                            sender: Some(config.server_name.clone().into()),
-                            body: ServerMessageBody::Authenticate("+".into()),
-                        }
-                        .write_async(writer)
-                        .await?;
-                        writer.flush().await?;
-                        Ok(None)
-                    } else {
-                        let target = self.future_nickname.clone().unwrap_or_else(|| "*".into());
-                        sasl_fail_message(config.server_name.clone(), target, "Unsupported mechanism".into())
-                            .write_async(writer)
-                            .await?;
-                        writer.flush().await?;
-                        Ok(None)
-                    }
-                } else {
-                    let body = AuthBody::from_str(body.as_bytes())?;
-                    if let Err(e) = auth_user(storage, &body.login, &body.password).await {
-                        tracing::warn!("Authentication failed: {:?}", e);
-                        let target = self.future_nickname.clone().unwrap_or_else(|| "*".into());
-                        sasl_fail_message(config.server_name.clone(), target, "Bad credentials".into())
-                            .write_async(writer)
-                            .await?;
-                        writer.flush().await?;
-                        Ok(None)
-                    } else {
-                        let login: Str = body.login.into();
-                        self.validated_user = Some(login.clone());
-                        ServerMessage {
-                            tags: vec![],
-                            sender: Some(config.server_name.clone().into()),
-                            body: ServerMessageBody::N900LoggedIn {
-                                nick: login.clone(),
-                                address: login.clone(),
-                                account: login.clone(),
-                                message: format!("You are now logged in as {}", login).into(),
-                            },
-                        }
-                        .write_async(writer)
-                        .await?;
-                        ServerMessage {
-                            tags: vec![],
-                            sender: Some(config.server_name.clone().into()),
-                            body: ServerMessageBody::N903SaslSuccess {
-                                nick: login.clone(),
-                                message: "SASL authentication successful".into(),
-                            },
-                        }
-                        .write_async(writer)
-                        .await?;
-                        writer.flush().await?;
-                        Ok(None)
-                    }
-                }
-
-                // TODO handle abortion of authentication
-            }
-            _ => Ok(None),
-        }
-    }
-
-    async fn finalize_auth(
-        &mut self,
-        candidate_user: RegisteredUser,
-        writer: &mut BufWriter<WriteHalf<'_>>,
-        storage: &mut Storage,
-        config: &ServerConfig,
-    ) -> Result<Option<RegisteredUser>> {
-        if self.enabled_capabilities.contains(Capabilities::Sasl)
-            && self.validated_user.as_ref() == Some(&candidate_user.nickname)
-        {
-            Ok(Some(candidate_user))
-        } else {
-            let Some(candidate_password) = &self.pass else {
-                sasl_fail_message(
-                    config.server_name.clone(),
-                    candidate_user.nickname.clone(),
-                    "User credentials was not provided".into(),
-                )
-                .write_async(writer)
-                .await?;
-                writer.flush().await?;
-                return Ok(None);
-            };
-            auth_user(storage, &*candidate_user.nickname, &*candidate_password).await?;
-            Ok(Some(candidate_user))
-        }
-    }
-}
-
 async fn handle_registration<'a>(
     reader: &mut BufReader<ReadHalf<'a>>,
     writer: &mut BufWriter<WriteHalf<'a>>,
@@ -337,7 +94,14 @@ async fn handle_registration<'a>(
 ) -> Result<RegisteredUser> {
     let mut buffer = vec![];
 
-    let mut state = RegistrationState::new();
+    let mut future_nickname: Option<Str> = None;
+    let mut future_username: Option<(Str, Str)> = None;
+    let mut enabled_capabilities = Capabilities::None;
+    let mut cap_negotiation_in_progress = false; // if true, expect `CAP END` to complete registration
+
+    let mut pass: Option<Str> = None;
+    let mut authentication_started = false;
+    let mut validated_user = None;
 
     let user = loop {
         let res = read_irc_message(reader, &mut buffer).await;
@@ -368,8 +132,218 @@ async fn handle_registration<'a>(
             }
         };
         tracing::debug!("Incoming IRC message: {msg:?}");
-        if let Some(user) = state.handle_msg(msg, writer, storage, config).await? {
+        match msg {
-            break Ok(user);
+            ClientMessage::Pass { password } => {
+                pass = Some(password);
+            }
+            ClientMessage::Capability { subcommand } => match subcommand {
+                CapabilitySubcommand::List { code: _ } => {
+                    cap_negotiation_in_progress = true;
+                    ServerMessage {
+                        tags: vec![],
+                        sender: Some(config.server_name.clone().into()),
+                        body: ServerMessageBody::Cap {
+                            target: future_nickname.clone().unwrap_or_else(|| "*".into()),
+                            subcmd: CapSubBody::Ls("sasl=PLAIN".into()),
+                        },
+                    }
+                    .write_async(writer)
+                    .await?;
+                    writer.flush().await?;
+                }
+                CapabilitySubcommand::Req(caps) => {
+                    cap_negotiation_in_progress = true;
+                    let mut acked = vec![];
+                    let mut naked = vec![];
+                    for cap in caps {
+                        if &*cap.name == "sasl" {
+                            if cap.to_disable {
+                                enabled_capabilities &= !Capabilities::Sasl;
+                            } else {
+                                enabled_capabilities |= Capabilities::Sasl;
+                            }
+                            acked.push(cap);
+                        } else {
+                            naked.push(cap);
+                        }
+                    }
+                    let mut ack_body = String::new();
+                    for cap in acked {
+                        if cap.to_disable {
+                            ack_body.push('-');
+                        }
+                        ack_body += &*cap.name;
+                    }
+                    ServerMessage {
+                        tags: vec![],
+                        sender: Some(config.server_name.clone().into()),
+                        body: ServerMessageBody::Cap {
+                            target: future_nickname.clone().unwrap_or_else(|| "*".into()),
+                            subcmd: CapSubBody::Ack(ack_body.into()),
+                        },
+                    }
+                    .write_async(writer)
+                    .await?;
+                    writer.flush().await?;
+                }
+                CapabilitySubcommand::End => {
+                    let Some((ref username, ref realname)) = future_username else {
+                        todo!();
+                    };
+                    let Some(nickname) = future_nickname.clone() else {
+                        todo!();
+                    };
+                    let username = username.clone();
+                    let realname = realname.clone();
+                    let candidate_user = RegisteredUser {
+                        nickname: nickname.clone(),
+                        username,
+                        realname,
+                    };
+                    if enabled_capabilities.contains(Capabilities::Sasl)
+                        && validated_user.as_ref() == Some(&candidate_user.nickname)
+                    {
+                        break Ok(candidate_user);
+                    } else {
+                        let Some(candidate_password) = pass else {
+                            sasl_fail_message(
+                                config.server_name.clone(),
+                                nickname.clone(),
+                                "User credentials was not provided".into(),
+                            )
+                            .write_async(writer)
+                            .await?;
+                            writer.flush().await?;
+                            continue;
+                        };
+                        auth_user(storage, &*candidate_user.nickname, &*candidate_password).await?;
+                        break Ok(candidate_user);
+                    }
+                }
+            },
+            ClientMessage::Nick { nickname } => {
+                if cap_negotiation_in_progress {
+                    future_nickname = Some(nickname);
+                } else if let Some((username, realname)) = future_username.clone() {
+                    let candidate_user = RegisteredUser {
+                        nickname: nickname.clone(),
+                        username,
+                        realname,
+                    };
+                    let Some(candidate_password) = pass else {
+                        sasl_fail_message(
+                            config.server_name.clone(),
+                            nickname.clone(),
+                            "User credentials was not provided".into(),
+                        )
+                        .write_async(writer)
+                        .await?;
+                        writer.flush().await?;
+                        continue;
+                    };
+                    auth_user(storage, &*candidate_user.nickname, &*candidate_password).await?;
+                    break Ok(candidate_user);
+                } else {
+                    future_nickname = Some(nickname);
+                }
+            }
+            ClientMessage::User { username, realname } => {
+                if cap_negotiation_in_progress {
+                    future_username = Some((username, realname));
+                } else if let Some(nickname) = future_nickname.clone() {
+                    let candidate_user = RegisteredUser {
+                        nickname: nickname.clone(),
+                        username,
+                        realname,
+                    };
+                    let Some(candidate_password) = pass else {
+                        sasl_fail_message(
+                            config.server_name.clone(),
+                            nickname.clone(),
+                            "User credentials was not provided".into(),
+                        )
+                        .write_async(writer)
+                        .await?;
+                        writer.flush().await?;
+                        continue;
+                    };
+                    auth_user(storage, &*candidate_user.nickname, &*candidate_password).await?;
+                    break Ok(candidate_user);
+                } else {
+                    future_username = Some((username, realname));
+                }
+            }
+            ClientMessage::Authenticate(body) => {
+                if !authentication_started {
+                    tracing::debug!("Received authentication request");
+                    if &*body == "PLAIN" {
+                        tracing::debug!("Authentication request with method PLAIN");
+                        authentication_started = true;
+                        ServerMessage {
+                            tags: vec![],
+                            sender: Some(config.server_name.clone().into()),
+                            body: ServerMessageBody::Authenticate("+".into()),
+                        }
+                        .write_async(writer)
+                        .await?;
+                        writer.flush().await?;
+                    } else {
+                        if let Some(nickname) = future_nickname.clone() {
+                            sasl_fail_message(
+                                config.server_name.clone(),
+                                nickname.clone(),
+                                "Unsupported mechanism".into(),
+                            )
+                            .write_async(writer)
+                            .await?;
+                            writer.flush().await?;
+                        } else {
+                            break Err(anyhow::Error::msg("Wrong authentication sequence"));
+                        }
+                    }
+                } else {
+                    let body = AuthBody::from_str(body.as_bytes())?;
+                    if let Err(e) = auth_user(storage, &body.login, &body.password).await {
+                        tracing::warn!("Authentication failed: {:?}", e);
+                        if let Some(nickname) = future_nickname.clone() {
+                            sasl_fail_message(config.server_name.clone(), nickname.clone(), "Bad credentials".into())
+                                .write_async(writer)
+                                .await?;
+                            writer.flush().await?;
+                        } else {
+                        }
+                    } else {
+                        let login: Str = body.login.into();
+                        validated_user = Some(login.clone());
+                        ServerMessage {
+                            tags: vec![],
+                            sender: Some(config.server_name.clone().into()),
+                            body: ServerMessageBody::N900LoggedIn {
+                                nick: login.clone(),
+                                address: login.clone(),
+                                account: login.clone(),
+                                message: format!("You are now logged in as {}", login).into(),
+                            },
+                        }
+                        .write_async(writer)
+                        .await?;
+                        ServerMessage {
+                            tags: vec![],
+                            sender: Some(config.server_name.clone().into()),
+                            body: ServerMessageBody::N903SaslSuccess {
+                                nick: login.clone(),
+                                message: "SASL authentication successful".into(),
+                            },
+                        }
+                        .write_async(writer)
+                        .await?;
+                        writer.flush().await?;
+                    }
+                }
+
+                // TODO handle abortion of authentication
+            }
+            _ => {}
         }
         buffer.clear();
     }?;
@@ -418,7 +392,7 @@ async fn handle_registered_socket<'a>(
     log::info!("Handling registered user: {user:?}");
 
     let player_id = PlayerId::from(user.nickname.clone())?;
-    let mut connection = players.connect_to_player(&player_id).await;
+    let mut connection = players.connect_to_player(player_id.clone()).await;
     let text: Str = format!("Welcome to {} Server", &config.server_name).into();
 
     ServerMessage {

crates/projection-irc/tests/lib.rs

@@ -111,36 +111,7 @@ impl TestServer {
         })
         .await?;
         let rooms = RoomRegistry::new(&mut metrics, storage.clone()).unwrap();
-        let players = PlayerRegistry::empty(rooms.clone(), storage.clone(), &mut metrics).unwrap();
+        let players = PlayerRegistry::empty(rooms.clone(), &mut metrics).unwrap();
-        let server = launch(config, players.clone(), rooms.clone(), metrics.clone(), storage.clone()).await.unwrap();
-        Ok(TestServer {
-            metrics,
-            storage,
-            rooms,
-            players,
-            server,
-        })
-    }
-
-    async fn reboot(mut self) -> Result<TestServer> {
-        let config = ServerConfig {
-            listen_on: "127.0.0.1:0".parse().unwrap(),
-            server_name: "testserver".into(),
-        };
-        let TestServer {
-            mut metrics,
-            mut storage,
-            rooms,
-            mut players,
-            server,
-        } = self;
-        server.terminate().await?;
-        players.shutdown_all().await.unwrap();
-        drop(players);
-        drop(rooms);
-        let mut metrics = MetricsRegistry::new();
-        let rooms = RoomRegistry::new(&mut metrics, storage.clone()).unwrap();
-        let players = PlayerRegistry::empty(rooms.clone(), storage.clone(), &mut metrics).unwrap();
         let server = launch(config, players.clone(), rooms.clone(), metrics.clone(), storage.clone()).await.unwrap();
         Ok(TestServer {
             metrics,
@@ -181,76 +152,6 @@ async fn scenario_basic() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test]
-async fn scenario_join_and_reboot() -> Result<()> {
-    let mut server = TestServer::start().await?;
-
-    // test scenario
-
-    server.storage.create_user("tester").await?;
-    server.storage.set_password("tester", "password").await?;
-
-    let mut stream = TcpStream::connect(server.server.addr).await?;
-    let mut s = TestScope::new(&mut stream);
-
-    // Open a connection and join a channel
-
-    s.send("PASS password").await?;
-    s.send("NICK tester").await?;
-    s.send("USER UserName 0 * :Real Name").await?;
-    s.expect_server_introduction("tester").await?;
-    s.expect_nothing().await?;
-    s.send("JOIN #test").await?;
-    s.expect(":tester JOIN #test").await?;
-    s.expect(":testserver 332 tester #test :New room").await?;
-    s.expect(":testserver 353 tester = #test :tester").await?;
-    s.expect(":testserver 366 tester #test :End of /NAMES list").await?;
-    s.send("PRIVMSG #test :Hello").await?;
-    s.send("QUIT :Leaving").await?;
-    s.expect(":testserver ERROR :Leaving the server").await?;
-    s.expect_eof().await?;
-    stream.shutdown().await?;
-
-    // Open a new connection and expect to be force-joined to the channel
-
-    let mut stream = TcpStream::connect(server.server.addr).await?;
-    let mut s = TestScope::new(&mut stream);
-
-    async fn test(s: &mut TestScope<'_>) -> Result<()> {
-        s.send("PASS password").await?;
-        s.send("NICK tester").await?;
-        s.send("USER UserName 0 * :Real Name").await?;
-        s.expect_server_introduction("tester").await?;
-        s.expect(":tester JOIN #test").await?;
-        s.expect(":testserver 332 tester #test :New room").await?;
-        s.expect(":testserver 353 tester = #test :tester").await?;
-        s.expect(":testserver 366 tester #test :End of /NAMES list").await?;
-        s.send("QUIT :Leaving").await?;
-        s.expect(":testserver ERROR :Leaving the server").await?;
-        s.expect_eof().await?;
-        Ok(())
-    }
-    test(&mut s).await?;
-    stream.shutdown().await?;
-
-    // Reboot the server
-
-    let server = server.reboot().await?;
-
-    // Open a new connection and expect to be force-joined to the channel
-
-    let mut stream = TcpStream::connect(server.server.addr).await?;
-    let mut s = TestScope::new(&mut stream);
-
-    test(&mut s).await?;
-    stream.shutdown().await?;
-
-    // wrap up
-
-    server.server.terminate().await?;
-    Ok(())
-}
-
 #[tokio::test]
 async fn scenario_force_join_msg() -> Result<()> {
     let mut server = TestServer::start().await?;
@@ -421,45 +322,6 @@ async fn scenario_cap_full_negotiation() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test]
-async fn scenario_cap_full_negotiation_nick_last() -> Result<()> {
-    let mut server = TestServer::start().await?;
-
-    // test scenario
-
-    server.storage.create_user("tester").await?;
-    server.storage.set_password("tester", "password").await?;
-
-    let mut stream = TcpStream::connect(server.server.addr).await?;
-    let mut s = TestScope::new(&mut stream);
-
-    s.send("CAP LS 302").await?;
-    s.expect(":testserver CAP * LS :sasl=PLAIN").await?;
-    s.send("CAP REQ :sasl").await?;
-    s.expect(":testserver CAP * ACK :sasl").await?;
-    s.send("AUTHENTICATE PLAIN").await?;
-    s.expect(":testserver AUTHENTICATE +").await?;
-    s.send("AUTHENTICATE dGVzdGVyAHRlc3RlcgBwYXNzd29yZA==").await?; // base64-encoded 'tester\x00tester\x00password'
-    s.expect(":testserver 900 tester tester tester :You are now logged in as tester").await?;
-    s.expect(":testserver 903 tester :SASL authentication successful").await?;
-    s.send("CAP END").await?;
-    s.send("USER UserName 0 * :Real Name").await?;
-    s.send("NICK tester").await?;
-
-    s.expect_server_introduction("tester").await?;
-    s.expect_nothing().await?;
-    s.send("QUIT :Leaving").await?;
-    s.expect(":testserver ERROR :Leaving the server").await?;
-    s.expect_eof().await?;
-
-    stream.shutdown().await?;
-
-    // wrap up
-
-    server.server.terminate().await?;
-    Ok(())
-}
-
 #[tokio::test]
 async fn scenario_cap_short_negotiation() -> Result<()> {
     let mut server = TestServer::start().await?;
@@ -545,6 +407,7 @@ async fn scenario_cap_sasl_fail() -> Result<()> {
 #[tokio::test]
 async fn terminate_socket_scenario() -> Result<()> {
     let mut server = TestServer::start().await?;
+    let address: SocketAddr = ("127.0.0.1:0".parse().unwrap());
 
     // test scenario
 

crates/projection-xmpp/src/iq.rs

@@ -2,8 +2,8 @@
 
 use quick_xml::events::Event;
 
-use lavina_core::room::{RoomId, RoomRegistry};
+use lavina_core::room::RoomRegistry;
-use proto_xmpp::bind::{BindResponse, Jid, Name, Server};
+use proto_xmpp::bind::{BindResponse, Jid, Name, Resource, Server};
 use proto_xmpp::client::{Iq, IqError, IqErrorType, IqType};
 use proto_xmpp::disco::{Feature, Identity, InfoQuery, Item, ItemQuery};
 use proto_xmpp::roster::RosterQuery;
@@ -17,16 +17,16 @@ use proto_xmpp::xml::ToXml;
 impl<'a> XmppConnection<'a> {
     pub async fn handle_iq(&self, output: &mut Vec<Event<'static>>, iq: Iq<IqClientBody>) {
         match iq.body {
-            IqClientBody::Bind(_) => {
+            IqClientBody::Bind(b) => {
                 let req = Iq {
                     from: None,
                     id: iq.id,
                     to: None,
                     r#type: IqType::Result,
                     body: BindResponse(Jid {
-                        name: Some(self.user.xmpp_name.clone()),
+                        name: Some(Name("darova".into())),
-                        server: Server(self.hostname.clone()),
+                        server: Server("localhost".into()),
-                        resource: Some(self.user.xmpp_resource.clone()),
+                        resource: Some(Resource("kek".into())),
                     }),
                 };
                 req.serialize(output);
@@ -52,9 +52,7 @@ impl<'a> XmppConnection<'a> {
                 req.serialize(output);
             }
             IqClientBody::DiscoInfo(info) => {
-                let response = self.disco_info(iq.to.as_ref(), &info).await;
+                let response = disco_info(iq.to.as_deref(), &info);
-                match response {
-                    Ok(response) => {
                 let req = Iq {
                     from: iq.to,
                     id: iq.id,
@@ -64,20 +62,8 @@ impl<'a> XmppConnection<'a> {
                 };
                 req.serialize(output);
             }
-                    Err(response) => {
-                        let req = Iq {
-                            from: iq.to,
-                            id: iq.id,
-                            to: None,
-                            r#type: IqType::Error,
-                            body: response,
-                        };
-                        req.serialize(output);
-                    }
-                }
-            }
             IqClientBody::DiscoItem(item) => {
-                let response = self.disco_items(iq.to.as_ref(), &item, self.rooms).await;
+                let response = disco_items(iq.to.as_deref(), &item, self.rooms).await;
                 let req = Iq {
                     from: iq.to,
                     id: iq.id,
@@ -101,17 +87,13 @@ impl<'a> XmppConnection<'a> {
             }
         }
     }
+}
 
-    async fn disco_info(&self, to: Option<&Jid>, req: &InfoQuery) -> Result<InfoQuery, IqError> {
+fn disco_info(to: Option<&str>, req: &InfoQuery) -> InfoQuery {
     let identity;
     let feature;
-
     match to {
-            Some(Jid {
+        Some("localhost") => {
-                name: None,
-                server,
-                resource: None,
-            }) if server.0 == self.hostname => {
             identity = vec![Identity {
                 category: "server".into(),
                 name: None,
@@ -124,11 +106,7 @@ impl<'a> XmppConnection<'a> {
                 Feature::new("presence"),
             ]
         }
-            Some(Jid {
+        Some("rooms.localhost") => {
-                name: None,
-                server,
-                resource: None,
-            }) if server.0 == self.hostname_rooms => {
             identity = vec![Identity {
                 category: "conference".into(),
                 name: Some("Chat rooms".into()),
@@ -140,75 +118,39 @@ impl<'a> XmppConnection<'a> {
                 Feature::new("http://jabber.org/protocol/muc"),
             ]
         }
-            Some(Jid {
-                name: Some(room_name),
-                server,
-                resource: None,
-            }) if server.0 == self.hostname_rooms => {
-                let room_id = RoomId::from(room_name.0.clone()).unwrap();
-                let Some(_) = self.rooms.get_room(&room_id).await else {
-                    // TODO should return item-not-found
-                    // example:
-                    // <error type="cancel">
-                    // <item-not-found xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/>
-                    // <text xmlns="urn:ietf:params:xml:ns:xmpp-stanzas" xml:lang="en">Conference room does not exist</text>
-                    // </error>
-                    return Err(IqError {
-                        r#type: IqErrorType::Cancel,
-                    });
-                };
-                identity = vec![Identity {
-                    category: "conference".into(),
-                    name: Some(room_id.into_inner().to_string()),
-                    r#type: "text".into(),
-                }];
-                feature = vec![
-                    Feature::new("http://jabber.org/protocol/disco#info"),
-                    Feature::new("http://jabber.org/protocol/disco#items"),
-                    Feature::new("http://jabber.org/protocol/muc"),
-                ]
-            }
         _ => {
             identity = vec![];
             feature = vec![];
         }
     };
-        Ok(InfoQuery {
+    InfoQuery {
         node: None,
         identity,
         feature,
-        })
+    }
 }
 
-    async fn disco_items(&self, to: Option<&Jid>, req: &ItemQuery, rooms: &RoomRegistry) -> ItemQuery {
+async fn disco_items(to: Option<&str>, req: &ItemQuery, rooms: &RoomRegistry) -> ItemQuery {
     let item = match to {
-            Some(Jid {
+        Some("localhost") => {
-                name: None,
-                server,
-                resource: None,
-            }) if server.0 == self.hostname => {
             vec![Item {
                 jid: Jid {
                     name: None,
-                        server: Server(self.hostname_rooms.clone()),
+                    server: Server("rooms.localhost".into()),
                     resource: None,
                 },
                 name: None,
                 node: None,
             }]
         }
-            Some(Jid {
+        Some("rooms.localhost") => {
-                name: None,
-                server,
-                resource: None,
-            }) if server.0 == self.hostname_rooms => {
             let room_list = rooms.get_all_rooms().await;
             room_list
                 .into_iter()
                 .map(|room_info| Item {
                     jid: Jid {
                         name: Some(Name(room_info.id.into_inner())),
-                            server: Server(self.hostname_rooms.clone()),
+                        server: Server("rooms.localhost".into()),
                         resource: None,
                     },
                     name: None,
@@ -220,4 +162,3 @@ impl<'a> XmppConnection<'a> {
     };
     ItemQuery { item }
 }
-}

crates/projection-xmpp/src/lib.rs

@@ -9,6 +9,7 @@ use std::net::SocketAddr;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use anyhow::anyhow;
 use futures_util::future::join_all;
 use prometheus::Registry as MetricsRegistry;
 use quick_xml::events::{BytesDecl, Event};
@@ -43,7 +44,6 @@ pub struct ServerConfig {
     pub listen_on: SocketAddr,
     pub cert: PathBuf,
     pub key: PathBuf,
-    pub hostname: Str,
 }
 
 struct LoadedConfig {
@@ -52,17 +52,9 @@ struct LoadedConfig {
 }
 
 struct Authenticated {
-    /// Identifier of the authenticated player.
-    ///
-    /// Used when communicating with lavina-core on behalf of the player.
     player_id: PlayerId,
-    /// The user's XMPP name.
-    ///
-    /// Used in `to` and `from` fields of XMPP messages.
     xmpp_name: Name,
-    /// The resource given to this user by the server.
     xmpp_resource: Resource,
-    /// The resource used by this user when joining MUCs.
     xmpp_muc_name: Resource,
 }
 
@@ -125,12 +117,11 @@ pub async fn launch(
                             let players = players.clone();
                             let rooms = rooms.clone();
                             let storage = storage.clone();
-                            let hostname = config.hostname.clone();
                             let terminator = Terminator::spawn(|termination| {
                                 let stopped_tx = stopped_tx.clone();
                                 let loaded_config = loaded_config.clone();
                                 async move {
-                                    match handle_socket(loaded_config, stream, &socket_addr, players, rooms, storage, hostname, termination).await {
+                                    match handle_socket(loaded_config, stream, &socket_addr, players, rooms, storage, termination).await {
                                         Ok(_) => log::info!("Connection terminated"),
                                         Err(err) => log::warn!("Connection failed: {err}"),
                                     }
@@ -165,13 +156,12 @@ pub async fn launch(
 }
 
 async fn handle_socket(
-    cert_config: Arc<LoadedConfig>,
+    config: Arc<LoadedConfig>,
     mut stream: TcpStream,
     socket_addr: &SocketAddr,
     mut players: PlayerRegistry,
     rooms: RoomRegistry,
     mut storage: Storage,
-    hostname: Str,
     termination: Deferred<()>, // TODO use it to stop the connection gracefully
 ) -> Result<()> {
     log::info!("Received an XMPP connection from {socket_addr}");
@@ -180,12 +170,12 @@ async fn handle_socket(
     let mut buf_reader = BufReader::new(reader);
     let mut buf_writer = BufWriter::new(writer);
 
-    socket_force_tls(&mut buf_reader, &mut buf_writer, &mut reader_buf, &hostname).await?;
+    socket_force_tls(&mut buf_reader, &mut buf_writer, &mut reader_buf).await?;
 
     let mut config = tokio_rustls::rustls::ServerConfig::builder()
         .with_safe_defaults()
         .with_no_client_auth()
-        .with_single_cert(vec![cert_config.cert.clone()], cert_config.key.clone())?;
+        .with_single_cert(vec![config.cert.clone()], config.key.clone())?;
     config.key_log = Arc::new(tokio_rustls::rustls::KeyLogFile::new());
 
     log::debug!("Accepting TLS connection...");
@@ -204,10 +194,10 @@ async fn handle_socket(
             log::info!("Socket handling was terminated");
             return Ok(())
         },
-        authenticated = socket_auth(&mut xml_reader, &mut xml_writer, &mut reader_buf, &mut storage, &hostname) => {
+        authenticated = socket_auth(&mut xml_reader, &mut xml_writer, &mut reader_buf, &mut storage) => {
             match authenticated {
                 Ok(authenticated) => {
-                    let mut connection = players.connect_to_player(&authenticated.player_id).await;
+                    let mut connection = players.connect_to_player(authenticated.player_id.clone()).await;
                     socket_final(
                         &mut xml_reader,
                         &mut xml_writer,
@@ -215,7 +205,6 @@ async fn handle_socket(
                         &authenticated,
                         &mut connection,
                         &rooms,
-                        &hostname,
                     )
                     .await?;
                 },
@@ -236,18 +225,16 @@ async fn socket_force_tls(
     reader: &mut (impl AsyncBufRead + Unpin),
     writer: &mut (impl AsyncWrite + Unpin),
     reader_buf: &mut Vec<u8>,
-    hostname: &Str,
 ) -> Result<()> {
     use proto_xmpp::tls::*;
     let xml_reader = &mut NsReader::from_reader(reader);
     let xml_writer = &mut Writer::new(writer);
-    // TODO validate the server hostname received in the stream start
     let _ = ClientStreamStart::parse(xml_reader, reader_buf).await?;
 
     let event = Event::Decl(BytesDecl::new("1.0", None, None));
     xml_writer.write_event_async(event).await?;
     let msg = ServerStreamStart {
-        from: hostname.to_string(),
+        from: "localhost".into(),
         lang: "en".into(),
         id: uuid::Uuid::new_v4().to_string(),
         version: "1.0".into(),
@@ -272,14 +259,12 @@ async fn socket_auth(
     xml_writer: &mut Writer<(impl AsyncWrite + Unpin)>,
     reader_buf: &mut Vec<u8>,
     storage: &mut Storage,
-    hostname: &Str,
 ) -> Result<Authenticated> {
-    // TODO validate the server hostname received in the stream start
     let _ = ClientStreamStart::parse(xml_reader, reader_buf).await?;
 
     xml_writer.write_event_async(Event::Decl(BytesDecl::new("1.0", None, None))).await?;
     ServerStreamStart {
-        from: hostname.to_string(),
+        from: "localhost".into(),
         lang: "en".into(),
         id: uuid::Uuid::new_v4().to_string(),
         version: "1.0".into(),
@@ -322,13 +307,11 @@ async fn socket_auth(
                 return Err(fail("passwords do not match"));
             }
 
-            let name: Str = name.as_str().into();
-
             Ok(Authenticated {
-                player_id: PlayerId::from(name.clone())?,
+                player_id: PlayerId::from(name.as_str())?,
-                xmpp_name: Name(name.clone()),
+                xmpp_name: Name(name.to_string().into()),
-                xmpp_resource: Resource(name.clone()),
+                xmpp_resource: Resource(name.to_string().into()),
-                xmpp_muc_name: Resource(name.clone()),
+                xmpp_muc_name: Resource(name.to_string().into()),
             })
         }
         Err(e) => return Err(e),
@@ -342,14 +325,12 @@ async fn socket_final(
     authenticated: &Authenticated,
     user_handle: &mut PlayerConnection,
     rooms: &RoomRegistry,
-    hostname: &Str,
 ) -> Result<()> {
-    // TODO validate the server hostname received in the stream start
     let _ = ClientStreamStart::parse(xml_reader, reader_buf).await?;
 
     xml_writer.write_event_async(Event::Decl(BytesDecl::new("1.0", None, None))).await?;
     ServerStreamStart {
-        from: hostname.to_string(),
+        from: "localhost".into(),
         lang: "en".into(),
         id: uuid::Uuid::new_v4().to_string(),
         version: "1.0".into(),
@@ -375,15 +356,13 @@ async fn socket_final(
             user: authenticated,
             user_handle,
             rooms,
-            hostname: hostname.clone(),
-            hostname_rooms: format!("rooms.{}", hostname).into(),
         };
         let should_recreate_xml_future = select! {
             biased;
             res = &mut next_xml_event => 's: {
                 let (ns, event) = res?;
                 if let Event::Text(ref e) = event {
-                    if e.iter().all(|x| *x == b'\n' || *x == b' ') {
+                    if e.iter().all(|x| *x == 0xA) {
                         break 's true;
                     }
                 }
@@ -433,8 +412,6 @@ struct XmppConnection<'a> {
     user: &'a Authenticated,
     user_handle: &'a mut PlayerConnection,
     rooms: &'a RoomRegistry,
-    hostname: Str,
-    hostname_rooms: Str,
 }
 
 impl<'a> XmppConnection<'a> {

crates/projection-xmpp/src/message.rs

@@ -18,17 +18,17 @@ impl<'a> XmppConnection<'a> {
             resource: _,
         }) = m.to
         {
-            if server.0.as_ref() == &*self.hostname_rooms && m.r#type == MessageType::Groupchat {
+            if server.0.as_ref() == "rooms.localhost" && m.r#type == MessageType::Groupchat {
                 self.user_handle.send_message(RoomId::from(name.0.clone())?, m.body.clone().into()).await?;
                 Message::<()> {
                     to: Some(Jid {
                         name: Some(self.user.xmpp_name.clone()),
-                        server: Server(self.hostname.clone()),
+                        server: Server("localhost".into()),
                         resource: Some(self.user.xmpp_resource.clone()),
                     }),
                     from: Some(Jid {
                         name: Some(name),
-                        server: Server(self.hostname_rooms.clone()),
+                        server: Server("rooms.localhost".into()),
                         resource: Some(self.user.xmpp_muc_name.clone()),
                     }),
                     id: m.id,

crates/projection-xmpp/src/presence.rs

@@ -4,7 +4,7 @@ use quick_xml::events::Event;
 
 use lavina_core::prelude::*;
 use lavina_core::room::RoomId;
-use proto_xmpp::bind::{Jid, Name, Server};
+use proto_xmpp::bind::{Jid, Server};
 use proto_xmpp::client::Presence;
 use proto_xmpp::xml::{Ignore, ToXml};
 
@@ -12,59 +12,42 @@ use crate::XmppConnection;
 
 impl<'a> XmppConnection<'a> {
     pub async fn handle_presence(&mut self, output: &mut Vec<Event<'static>>, p: Presence<Ignore>) -> Result<()> {
-        match p.to {
+        let response = if p.to.is_none() {
-            None => {
+            Presence::<()> {
-                self.self_presence(output).await;
-            }
-            Some(Jid {
-                name: Some(name),
-                server,
-                // resources in MUCs are members' personas – not implemented (yet?)
-                resource: Some(_),
-            }) if server.0 == self.hostname_rooms => {
-                self.muc_presence(name, output).await?;
-            }
-            _ => {
-                // TODO other presence cases
-                let response = Presence::<()>::default();
-                response.serialize(output);
-            }
-        }
-        Ok(())
-    }
-
-    async fn self_presence(&mut self, output: &mut Vec<Event<'static>>) {
-        let response = Presence::<()> {
                 to: Some(Jid {
                     name: Some(self.user.xmpp_name.clone()),
-                server: Server(self.hostname.clone()),
+                    server: Server("localhost".into()),
                     resource: Some(self.user.xmpp_resource.clone()),
                 }),
                 from: Some(Jid {
                     name: Some(self.user.xmpp_name.clone()),
-                server: Server(self.hostname.clone()),
+                    server: Server("localhost".into()),
                     resource: Some(self.user.xmpp_resource.clone()),
                 }),
                 ..Default::default()
-        };
-        response.serialize(output);
             }
-
+        } else if let Some(Jid {
-    async fn muc_presence(&mut self, name: Name, output: &mut Vec<Event<'static>>) -> Result<()> {
+            name: Some(name),
+            server,
+            resource: Some(resource),
+        }) = p.to
+        {
             let a = self.user_handle.join_room(RoomId::from(name.0.clone())?).await?;
-        // TODO handle bans
+            Presence::<()> {
-        let response = Presence::<()> {
                 to: Some(Jid {
                     name: Some(self.user.xmpp_name.clone()),
-                server: Server(self.hostname.clone()),
+                    server: Server("localhost".into()),
                     resource: Some(self.user.xmpp_resource.clone()),
                 }),
                 from: Some(Jid {
                     name: Some(name.clone()),
-                server: Server(self.hostname_rooms.clone()),
+                    server: Server("rooms.localhost".into()),
                     resource: Some(self.user.xmpp_muc_name.clone()),
                 }),
                 ..Default::default()
+            }
+        } else {
+            Presence::<()>::default()
         };
         response.serialize(output);
         Ok(())

crates/projection-xmpp/src/updates.rs

@@ -21,12 +21,12 @@ impl<'a> XmppConnection<'a> {
                 Message::<()> {
                     to: Some(Jid {
                         name: Some(self.user.xmpp_name.clone()),
-                        server: Server(self.hostname.clone()),
+                        server: Server("localhost".into()),
                         resource: Some(self.user.xmpp_resource.clone()),
                     }),
                     from: Some(Jid {
                         name: Some(Name(room_id.into_inner().into())),
-                        server: Server(self.hostname_rooms.clone()),
+                        server: Server("rooms.localhost".into()),
                         resource: Some(Resource(author_id.into_inner().into())),
                     }),
                     id: None,

crates/projection-xmpp/tests/lib.rs

@@ -1,4 +1,5 @@
 use std::io::ErrorKind;
+use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -19,7 +20,7 @@ use tokio_rustls::TlsConnector;
 use lavina_core::player::PlayerRegistry;
 use lavina_core::repo::{Storage, StorageConfig};
 use lavina_core::room::RoomRegistry;
-use projection_xmpp::{launch, RunningServer, ServerConfig};
+use projection_xmpp::{launch, ServerConfig};
 use proto_xmpp::xml::{Continuation, FromXml, Parser};
 
 pub async fn read_irc_message(reader: &mut BufReader<ReadHalf<'_>>, buf: &mut Vec<u8>) -> Result<usize> {
@@ -121,21 +122,13 @@ impl ServerCertVerifier for IgnoreCertVerification {
     }
 }
 
-struct TestServer {
+#[tokio::test]
-    metrics: MetricsRegistry,
+async fn scenario_basic() -> Result<()> {
-    storage: Storage,
+    tracing_subscriber::fmt::try_init();
-    rooms: RoomRegistry,
-    players: PlayerRegistry,
-    server: RunningServer,
-}
-impl TestServer {
-    async fn start() -> Result<TestServer> {
-        let _ = tracing_subscriber::fmt::try_init();
     let config = ServerConfig {
         listen_on: "127.0.0.1:0".parse().unwrap(),
         cert: "tests/certs/xmpp.pem".parse().unwrap(),
         key: "tests/certs/xmpp.key".parse().unwrap(),
-            hostname: "localhost".into(),
     };
     let mut metrics = MetricsRegistry::new();
     let mut storage = Storage::open(StorageConfig {
@@ -143,28 +136,15 @@ impl TestServer {
     })
     .await?;
     let rooms = RoomRegistry::new(&mut metrics, storage.clone()).unwrap();
-        let players = PlayerRegistry::empty(rooms.clone(), storage.clone(), &mut metrics).unwrap();
+    let players = PlayerRegistry::empty(rooms.clone(), &mut metrics).unwrap();
-        let server = launch(config, players.clone(), rooms.clone(), metrics.clone(), storage.clone()).await.unwrap();
+    let server = launch(config, players, rooms, metrics, storage.clone()).await.unwrap();
-        Ok(TestServer {
-            metrics,
-            storage,
-            rooms,
-            players,
-            server,
-        })
-    }
-}
-
-#[tokio::test]
-async fn scenario_basic() -> Result<()> {
-    let mut server = TestServer::start().await?;
 
     // test scenario
 
-    server.storage.create_user("tester").await?;
+    storage.create_user("tester").await?;
-    server.storage.set_password("tester", "password").await?;
+    storage.set_password("tester", "password").await?;
 
-    let mut stream = TcpStream::connect(server.server.addr).await?;
+    let mut stream = TcpStream::connect(server.addr).await?;
     let mut s = TestScope::new(&mut stream);
     tracing::info!("TCP connection established");
 
@@ -189,7 +169,7 @@ async fn scenario_basic() -> Result<()> {
             .with_no_client_auth(),
     ));
     tracing::info!("Initiating TLS connection...");
-    let mut stream = connector.connect(ServerName::IpAddress(server.server.addr.ip()), stream).await?;
+    let mut stream = connector.connect(ServerName::IpAddress(server.addr.ip()), stream).await?;
     tracing::info!("TLS connection established");
 
     let mut s = TestScopeTls::new(&mut stream, buffer);
@@ -203,20 +183,33 @@ async fn scenario_basic() -> Result<()> {
 
     // wrap up
 
-    server.server.terminate().await?;
+    server.terminate().await?;
     Ok(())
 }
 
 #[tokio::test]
 async fn scenario_basic_without_headers() -> Result<()> {
-    let mut server = TestServer::start().await?;
+    tracing_subscriber::fmt::try_init();
+    let config = ServerConfig {
+        listen_on: "127.0.0.1:0".parse().unwrap(),
+        cert: "tests/certs/xmpp.pem".parse().unwrap(),
+        key: "tests/certs/xmpp.key".parse().unwrap(),
+    };
+    let mut metrics = MetricsRegistry::new();
+    let mut storage = Storage::open(StorageConfig {
+        db_path: ":memory:".into(),
+    })
+    .await?;
+    let rooms = RoomRegistry::new(&mut metrics, storage.clone()).unwrap();
+    let players = PlayerRegistry::empty(rooms.clone(), &mut metrics).unwrap();
+    let server = launch(config, players, rooms, metrics, storage.clone()).await.unwrap();
 
     // test scenario
 
-    server.storage.create_user("tester").await?;
+    storage.create_user("tester").await?;
-    server.storage.set_password("tester", "password").await?;
+    storage.set_password("tester", "password").await?;
 
-    let mut stream = TcpStream::connect(server.server.addr).await?;
+    let mut stream = TcpStream::connect(server.addr).await?;
     let mut s = TestScope::new(&mut stream);
     tracing::info!("TCP connection established");
 
@@ -240,7 +233,7 @@ async fn scenario_basic_without_headers() -> Result<()> {
             .with_no_client_auth(),
     ));
     tracing::info!("Initiating TLS connection...");
-    let mut stream = connector.connect(ServerName::IpAddress(server.server.addr.ip()), stream).await?;
+    let mut stream = connector.connect(ServerName::IpAddress(server.addr.ip()), stream).await?;
     tracing::info!("TLS connection established");
 
     let mut s = TestScopeTls::new(&mut stream, buffer);
@@ -253,20 +246,33 @@ async fn scenario_basic_without_headers() -> Result<()> {
 
     // wrap up
 
-    server.server.terminate().await?;
+    server.terminate().await?;
     Ok(())
 }
 
 #[tokio::test]
 async fn terminate_socket() -> Result<()> {
-    let mut server = TestServer::start().await?;
+    tracing_subscriber::fmt::try_init();
-
+    let config = ServerConfig {
+        listen_on: "127.0.0.1:0".parse().unwrap(),
+        cert: "tests/certs/xmpp.pem".parse().unwrap(),
+        key: "tests/certs/xmpp.key".parse().unwrap(),
+    };
+    let mut metrics = MetricsRegistry::new();
+    let mut storage = Storage::open(StorageConfig {
+        db_path: ":memory:".into(),
+    })
+    .await?;
+    let rooms = RoomRegistry::new(&mut metrics, storage.clone()).unwrap();
+    let players = PlayerRegistry::empty(rooms.clone(), &mut metrics).unwrap();
+    let server = launch(config, players, rooms, metrics, storage.clone()).await.unwrap();
+    let address: SocketAddr = ("127.0.0.1:0".parse().unwrap());
     // test scenario
 
-    server.storage.create_user("tester").await?;
+    storage.create_user("tester").await?;
-    server.storage.set_password("tester", "password").await?;
+    storage.set_password("tester", "password").await?;
 
-    let mut stream = TcpStream::connect(server.server.addr).await?;
+    let mut stream = TcpStream::connect(server.addr).await?;
     let mut s = TestScope::new(&mut stream);
     tracing::info!("TCP connection established");
 
@@ -282,6 +288,7 @@ async fn terminate_socket() -> Result<()> {
     assert_matches!(s.next_xml_event().await?, Event::End(b) => assert_eq!(b.local_name().into_inner(), b"features"));
     s.send(r#"<starttls/>"#).await?;
     assert_matches!(s.next_xml_event().await?, Event::Empty(b) => assert_eq!(b.local_name().into_inner(), b"proceed"));
+    let buffer = s.buffer;
 
     let connector = TlsConnector::from(Arc::new(
         ClientConfig::builder()
@@ -291,10 +298,10 @@ async fn terminate_socket() -> Result<()> {
     ));
 
     tracing::info!("Initiating TLS connection...");
-    let mut stream = connector.connect(ServerName::IpAddress(server.server.addr.ip()), stream).await?;
+    let mut stream = connector.connect(ServerName::IpAddress(server.addr.ip()), stream).await?;
     tracing::info!("TLS connection established");
 
-    server.server.terminate().await?;
+    server.terminate().await?;
 
     assert_eq!(stream.read_u8().await.unwrap_err().kind(), ErrorKind::UnexpectedEof);
 

crates/proto-xmpp/src/bind.rs

@@ -11,15 +11,12 @@ pub const XMLNS: &'static str = "urn:ietf:params:xml:ns:xmpp-bind";
 
 // TODO remove `pub` in newtypes, introduce validation
 
-/// Name (node identifier) of an XMPP entity. Placed before the `@` in a JID.
 #[derive(PartialEq, Eq, Debug, Clone)]
 pub struct Name(pub Str);
 
-/// Server name of an XMPP entity. Placed after the `@` and before the `/` in a JID.
 #[derive(PartialEq, Eq, Debug, Clone)]
 pub struct Server(pub Str);
 
-/// Resource of an XMPP entity. Placed after the `/` in a JID.
 #[derive(PartialEq, Eq, Debug, Clone)]
 pub struct Resource(pub Str);
 

crates/proto-xmpp/src/client.rs

@@ -295,9 +295,9 @@ impl ToXml for IqError {
 
 #[derive(PartialEq, Eq, Debug)]
 pub struct Iq<T> {
-    pub from: Option<Jid>,
+    pub from: Option<String>,
     pub id: String,
-    pub to: Option<Jid>,
+    pub to: Option<String>,
     pub r#type: IqType,
     pub body: T,
 }
@@ -323,9 +323,9 @@ enum IqParserInner<T: FromXml> {
     Final(IqParserState<T>),
 }
 struct IqParserState<T> {
-    pub from: Option<Jid>,
+    pub from: Option<String>,
     pub id: Option<String>,
-    pub to: Option<Jid>,
+    pub to: Option<String>,
     pub r#type: Option<IqType>,
     pub body: Option<T>,
 }
@@ -348,15 +348,13 @@ impl<T: FromXml> Parser for IqParser<T> {
                         let attr = fail_fast!(attr);
                         if attr.key.0 == b"from" {
                             let value = fail_fast!(std::str::from_utf8(&*attr.value));
-                            let value = fail_fast!(Jid::from_string(value));
+                            state.from = Some(value.to_string())
-                            state.from = Some(value)
                         } else if attr.key.0 == b"id" {
                             let value = fail_fast!(std::str::from_utf8(&*attr.value));
                             state.id = Some(value.to_string())
                         } else if attr.key.0 == b"to" {
                             let value = fail_fast!(std::str::from_utf8(&*attr.value));
-                            let value = fail_fast!(Jid::from_string(value));
+                            state.to = Some(value.to_string())
-                            state.to = Some(value)
                         } else if attr.key.0 == b"type" {
                             let value = fail_fast!(IqType::from_str(&*attr.value));
                             state.r#type = Some(value);
@@ -433,17 +431,15 @@ impl<T: ToXml> ToXml for Iq<T> {
         let mut start = BytesStart::new(start);
         let mut attrs = vec![];
         if let Some(ref from) = self.from {
-            let value = from.to_string().into_bytes();
             attrs.push(Attribute {
                 key: QName(b"from"),
-                value: value.into(),
+                value: from.as_bytes().into(),
             });
         };
         if let Some(ref to) = self.to {
-            let value = to.to_string().into_bytes();
             attrs.push(Attribute {
                 key: QName(b"to"),
-                value: value.into(),
+                value: to.as_bytes().into(),
             });
         }
         attrs.push(Attribute {

docs/cheatsheet.md

@@ -8,12 +8,11 @@ Some useful commands for development and testing.
 
 Following commands require `OpenSSL` to be installed. It is provided as `openssl` package in Arch Linux.
 
-Generate self-signed TLS certificate. Mind the common name (CN) field, it should match the domain name of the server.
+Generate self-signed TLS certificate:
-Example for localhost:
 
     openssl req -x509 -newkey rsa:4096 -sha256 -days 365 -noenc \
     -keyout certs/xmpp.key -out certs/xmpp.pem \
-    -subj "/CN=localhost"
+    -subj "/CN=example.com"
 
 Print content of a TLS certificate:
 

docs/running.md

@@ -19,7 +19,6 @@ server_name = "irc.localhost"
 listen_on = "127.0.0.1:5222"
 cert = "./certs/xmpp.pem"
 key = "./certs/xmpp.key"
-hostname = "localhost"
 
 [storage]
 db_path = "db.sqlite"

src/main.rs

@@ -52,7 +52,7 @@ async fn main() -> Result<()> {
     let mut metrics = MetricsRegistry::new();
     let storage = Storage::open(storage_config).await?;
     let rooms = RoomRegistry::new(&mut metrics, storage.clone())?;
-    let mut players = PlayerRegistry::empty(rooms.clone(), storage.clone(), &mut metrics)?;
+    let mut players = PlayerRegistry::empty(rooms.clone(), &mut metrics)?;
     let telemetry_terminator = http::launch(telemetry_config, metrics.clone(), rooms.clone(), storage.clone()).await?;
     let irc = projection_irc::launch(
         irc_config,