lavina/crates/projection-xmpp/src/presence.rs

//! Handling of all client2server presence stanzas

use anyhow::Result;
use quick_xml::events::Event;
use serde::Serialize;

use lavina_core::room::RoomId;
use proto_xmpp::bind::{Jid, Name, Resource, Server};
use proto_xmpp::client::Presence;
use proto_xmpp::muc::{Delay, XUser, XmppHistoryMessage};
use proto_xmpp::xml::{Ignore, ToXml};

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 {
            None => {
                self.self_presence(output, p.r#type.as_deref()).await;
            }
            Some(Jid {
                name: Some(name),
                server,
                // resources in MUCs are members' personas – not implemented (yet?)
                resource: Some(_),
            }) if server.0 == self.hostname_rooms => {
                let muc_presence = self.retrieve_muc_presence(&name).await?;
                muc_presence.serialize(output);

                let messages = self.retrieve_message_history(&name).await?;
                for message in messages {
                    message.serialize(output)
                }
            }
            _ => {
                // TODO other presence cases
                let response = Presence::<()>::default();
                response.serialize(output);
            }
        }
        Ok(())
    }

    async fn self_presence(&mut self, output: &mut Vec<Event<'static>>, r#type: Option<&str>) {
        match r#type {
            Some("unavailable") => {
                // do not print anything
            }
            None => {
                let response = Presence::<()> {
                    to: Some(Jid {
                        name: Some(self.user.xmpp_name.clone()),
                        server: Server(self.hostname.clone()),
                        resource: Some(self.user.xmpp_resource.clone()),
                    }),
                    from: Some(Jid {
                        name: Some(self.user.xmpp_name.clone()),
                        server: Server(self.hostname.clone()),
                        resource: Some(self.user.xmpp_resource.clone()),
                    }),
                    ..Default::default()
                };
                response.serialize(output);
            }
            _ => todo!(),
        }
    }

    async fn retrieve_muc_presence(&mut self, name: &Name) -> Result<(Presence<XUser>)> {
        let a = self.user_handle.join_room(RoomId::try_from(name.0.clone())?).await?;
        // TODO handle bans
        let response = Presence {
            to: Some(Jid {
                name: Some(self.user.xmpp_name.clone()),
                server: Server(self.hostname.clone()),
                resource: Some(self.user.xmpp_resource.clone()),
            }),
            from: Some(Jid {
                name: Some(name.clone()),
                server: Server(self.hostname_rooms.clone()),
                resource: Some(self.user.xmpp_muc_name.clone()),
            }),
            custom: vec![XUser],
            ..Default::default()
        };
        Ok(response)
    }

    /*
       Retrieve a room's message history. The output can be serialized into a stream of XML stanzas.

       Example of such a stanza:

           <message from="duqedadi@conference.oflor.me/misha" xml:lang="en" to="misha@oflor.me/tux" type="groupchat" id="7ca7cb14-b2af-49c9-bd90-05dabb1113a5">
               <delay xmlns="urn:xmpp:delay" stamp="2024-05-17T16:05:28.440337Z" from="duqedadi@conference.oflor.me"/>
               <body></body>
           </message>
    */
    async fn retrieve_message_history(&self, room_name: &Name) -> Result<(Vec<XmppHistoryMessage>)> {
        let room_id = RoomId::try_from(room_name.0.clone())?;
        let history_messages = self.user_handle.get_room_message_history(room_id).await?;
        let mut response = vec![];

        for history_message in history_messages.into_iter() {
            response.push(XmppHistoryMessage {
                id: history_message.id.to_string(),
                to: Jid {
                    name: Option::from(Name(self.user.xmpp_muc_name.0.clone().into())),
                    server: Server(self.hostname.clone()),
                    resource: None,
                },
                from: Jid {
                    name: Option::from(room_name.clone()),
                    server: Server(self.hostname_rooms.clone()),
                    resource: Option::from(Resource(history_message.author.name.clone().into())),
                },
                delay: Delay::new(
                    Jid {
                        name: Option::from(Name(history_message.author.name.clone().into())),
                        server: Server(self.hostname_rooms.clone()),
                        resource: None,
                    },
                    history_message.created_at.to_rfc3339(),
                ),
                body: history_message.content.clone(),
            });
            tracing::info!(
                "Retrieved message: {:?} {:?}",
                history_message.author,
                history_message.content.clone()
            );
        }

        return Ok(response);
    }
}

#[cfg(test)]
mod tests {
    use anyhow::Result;

    use lavina_core::player::PlayerId;
    use proto_xmpp::bind::{Jid, Name, Resource, Server};
    use proto_xmpp::client::Presence;
    use proto_xmpp::muc::XUser;

    use crate::testkit::{expect_user_authenticated, TestServer};
    use crate::Authenticated;

    #[tokio::test]
    async fn test_muc_joining() -> Result<()> {
        let server = TestServer::start().await.unwrap();

        server.core.create_player(&PlayerId::from("tester")?).await?;

        let player_id = PlayerId::from("tester").unwrap();
        let user = Authenticated {
            player_id,
            xmpp_name: Name("tester".into()),
            xmpp_resource: Resource("tester".into()),
            xmpp_muc_name: Resource("tester".into()),
        };

        let mut player_conn = server.core.connect_to_player(&user.player_id).await;
        let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();

        let response = conn.retrieve_muc_presence(&user.xmpp_name).await.unwrap();
        let expected = Presence {
            to: Some(Jid {
                name: Some(conn.user.xmpp_name.clone()),
                server: Server(conn.hostname.clone()),
                resource: Some(conn.user.xmpp_resource.clone()),
            }),
            from: Some(Jid {
                name: Some(user.xmpp_name.clone()),
                server: Server(conn.hostname_rooms.clone()),
                resource: Some(conn.user.xmpp_muc_name.clone()),
            }),
            custom: vec![XUser],
            ..Default::default()
        };
        assert_eq!(expected, response);

        server.shutdown().await.unwrap();
        Ok(())
    }

    // Test that joining a room second time after a server restart,
    // i.e. in-memory cache of memberships is cleaned, does not cause any issues.
    #[tokio::test]
    async fn test_muc_joining_twice() -> Result<()> {
        let server = TestServer::start().await.unwrap();

        server.core.create_player(&PlayerId::from("tester")?).await?;

        let player_id = PlayerId::from("tester").unwrap();
        let user = Authenticated {
            player_id,
            xmpp_name: Name("tester".into()),
            xmpp_resource: Resource("tester".into()),
            xmpp_muc_name: Resource("tester".into()),
        };

        let mut player_conn = server.core.connect_to_player(&user.player_id).await;
        let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();

        let response = conn.retrieve_muc_presence(&user.xmpp_name).await.unwrap();
        let expected = Presence {
            to: Some(Jid {
                name: Some(conn.user.xmpp_name.clone()),
                server: Server(conn.hostname.clone()),
                resource: Some(conn.user.xmpp_resource.clone()),
            }),
            from: Some(Jid {
                name: Some(user.xmpp_name.clone()),
                server: Server(conn.hostname_rooms.clone()),
                resource: Some(conn.user.xmpp_muc_name.clone()),
            }),
            custom: vec![XUser],
            ..Default::default()
        };
        assert_eq!(expected, response);

        drop(conn);
        let server = server.reboot().await.unwrap();

        let mut player_conn = server.core.connect_to_player(&user.player_id).await;
        let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();

        let response = conn.retrieve_muc_presence(&user.xmpp_name).await.unwrap();
        assert_eq!(expected, response);

        server.shutdown().await.unwrap();
        Ok(())
    }
}
-												xmpp: split off stanza and update handling into modules (#27)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/27

											
										
										
											2023-10-13 20:09:08 +00:00
+								//! Handling of all client2server presence stanzas
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								use anyhow::Result;
-												xmpp: split off stanza and update handling into modules (#27)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/27

											
										
										
											2023-10-13 20:09:08 +00:00
+								use quick_xml::events::Event;
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								use serde::Serialize;
-												xmpp: split off stanza and update handling into modules (#27)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/27

											
										
										
											2023-10-13 20:09:08 +00:00
 								use lavina_core::room::RoomId;
-												Sketch message response

											
										
										
											2024-05-18 18:18:42 +00:00
+								use proto_xmpp::bind::{Jid, Name, Resource, Server};
-												xmpp: split off stanza and update handling into modules (#27)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/27

											
										
										
											2023-10-13 20:09:08 +00:00
+								use proto_xmpp::client::Presence;
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								use proto_xmpp::muc::{Delay, XUser, XmppHistoryMessage};
-												xmpp: split off stanza and update handling into modules (#27)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/27

											
										
										
											2023-10-13 20:09:08 +00:00
+								use proto_xmpp::xml::{Ignore, ToXml};
 								use crate::XmppConnection;
 								impl<'a> XmppConnection<'a> {
 								    pub async fn handle_presence(&mut self, output: &mut Vec<Event<'static>>, p: Presence<Ignore>) -> Result<()> {
-												xmpp: use the Jid type in IQs' to and from fields, separate presence handling

											
										
										
											2024-04-15 16:18:51 +00:00
+								        match p.to {
 								            None => {
-												xmpp: handle correctly unavailable self-presence and improve basic test scenario

											
										
										
											2024-04-28 13:43:22 +00:00
+								                self.self_presence(output, p.r#type.as_deref()).await;
-												xmpp: split off stanza and update handling into modules (#27)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/27

											
										
										
											2023-10-13 20:09:08 +00:00
+								            }
-												xmpp: use the Jid type in IQs' to and from fields, separate presence handling

											
										
										
											2024-04-15 16:18:51 +00:00
+								            Some(Jid {
 								                name: Some(name),
 								                server,
 								                // resources in MUCs are members' personas – not implemented (yet?)
 								                resource: Some(_),
 								            }) if server.0 == self.hostname_rooms => {
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								                let muc_presence = self.retrieve_muc_presence(&name).await?;
 								                muc_presence.serialize(output);
-												Sketch message response

											
										
										
											2024-05-18 18:18:42 +00:00
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								                let messages = self.retrieve_message_history(&name).await?;
 								                for message in messages {
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								                    message.serialize(output)
 								                }
-												xmpp: split off stanza and update handling into modules (#27)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/27

											
										
										
											2023-10-13 20:09:08 +00:00
+								            }
-												xmpp: use the Jid type in IQs' to and from fields, separate presence handling

											
										
										
											2024-04-15 16:18:51 +00:00
+								            _ => {
 								                // TODO other presence cases
 								                let response = Presence::<()>::default();
 								                response.serialize(output);
 								            }
 								        }
 								        Ok(())
 								    }
-												xmpp: handle correctly unavailable self-presence and improve basic test scenario

											
										
										
											2024-04-28 13:43:22 +00:00
+								    async fn self_presence(&mut self, output: &mut Vec<Event<'static>>, r#type: Option<&str>) {
 								        match r#type {
 								            Some("unavailable") => {
 								                // do not print anything
 								            }
 								            None => {
 								                let response = Presence::<()> {
 								                    to: Some(Jid {
 								                        name: Some(self.user.xmpp_name.clone()),
 								                        server: Server(self.hostname.clone()),
 								                        resource: Some(self.user.xmpp_resource.clone()),
 								                    }),
 								                    from: Some(Jid {
 								                        name: Some(self.user.xmpp_name.clone()),
 								                        server: Server(self.hostname.clone()),
 								                        resource: Some(self.user.xmpp_resource.clone()),
 								                    }),
 								                    ..Default::default()
 								                };
 								                response.serialize(output);
 								            }
 								            _ => todo!(),
 								        }
-												xmpp: use the Jid type in IQs' to and from fields, separate presence handling

											
										
										
											2024-04-15 16:18:51 +00:00
+								    }
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								    async fn retrieve_muc_presence(&mut self, name: &Name) -> Result<(Presence<XUser>)> {
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								        let a = self.user_handle.join_room(RoomId::try_from(name.0.clone())?).await?;
-												xmpp: use the Jid type in IQs' to and from fields, separate presence handling

											
										
										
											2024-04-15 16:18:51 +00:00
+								        // TODO handle bans
-												xmpp: add x-user element to muc presence response (#67)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/67

											
										
										
											2024-05-14 14:44:49 +00:00
+								        let response = Presence {
-												xmpp: use the Jid type in IQs' to and from fields, separate presence handling

											
										
										
											2024-04-15 16:18:51 +00:00
+								            to: Some(Jid {
 								                name: Some(self.user.xmpp_name.clone()),
 								                server: Server(self.hostname.clone()),
 								                resource: Some(self.user.xmpp_resource.clone()),
 								            }),
 								            from: Some(Jid {
 								                name: Some(name.clone()),
 								                server: Server(self.hostname_rooms.clone()),
 								                resource: Some(self.user.xmpp_muc_name.clone()),
 								            }),
-												xmpp: add x-user element to muc presence response (#67)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/67

											
										
										
											2024-05-14 14:44:49 +00:00
+								            custom: vec![XUser],
-												xmpp: use the Jid type in IQs' to and from fields, separate presence handling

											
										
										
											2024-04-15 16:18:51 +00:00
+								            ..Default::default()
-												xmpp: split off stanza and update handling into modules (#27)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/27

											
										
										
											2023-10-13 20:09:08 +00:00
+								        };
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								        Ok(response)
 								    }
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
 								    /*
 								       Retrieve a room's message history. The output can be serialized into a stream of XML stanzas.
 								       Example of such a stanza:
 								           <message from="duqedadi@conference.oflor.me/misha" xml:lang="en" to="misha@oflor.me/tux" type="groupchat" id="7ca7cb14-b2af-49c9-bd90-05dabb1113a5">
 								               <delay xmlns="urn:xmpp:delay" stamp="2024-05-17T16:05:28.440337Z" from="duqedadi@conference.oflor.me"/>
 								               <body></body>
 								           </message>
 								    */
 								    async fn retrieve_message_history(&self, room_name: &Name) -> Result<(Vec<XmppHistoryMessage>)> {
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								        let room_id = RoomId::try_from(room_name.0.clone())?;
 								        let history_messages = self.user_handle.get_room_message_history(room_id).await?;
 								        let mut response = vec![];
 								        for history_message in history_messages.into_iter() {
 								            response.push(XmppHistoryMessage {
-												Read and serve

											
										
										
											2024-05-23 18:52:03 +00:00
+								                id: history_message.id.to_string(),
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								                to: Jid {
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								                    name: Option::from(Name(self.user.xmpp_muc_name.0.clone().into())),
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								                    server: Server(self.hostname.clone()),
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								                    resource: None,
-												Sketch message response

											
										
										
											2024-05-18 18:18:42 +00:00
+								                },
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								                from: Jid {
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								                    name: Option::from(room_name.clone()),
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								                    server: Server(self.hostname_rooms.clone()),
-												Read and serve

											
										
										
											2024-05-23 18:52:03 +00:00
+								                    resource: Option::from(Resource(history_message.author.name.clone().into())),
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								                },
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								                delay: Delay::new(
 								                    Jid {
-												Read and serve

											
										
										
											2024-05-23 18:52:03 +00:00
+								                        name: Option::from(Name(history_message.author.name.clone().into())),
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								                        server: Server(self.hostname_rooms.clone()),
 								                        resource: None,
 								                    },
 								                    history_message.created_at.to_rfc3339(),
 								                ),
-												Read and serve

											
										
										
											2024-05-23 18:52:03 +00:00
+								                body: history_message.content.clone(),
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								            });
-												Read and serve

											
										
										
											2024-05-23 18:52:03 +00:00
+								            tracing::info!(
 								                "Retrieved message: {:?} {:?}",
 								                history_message.author,
 								                history_message.content.clone()
 								            );
-												Use vectors and commands

											
										
										
											2024-05-23 12:35:52 +00:00
+								        }
 								        return Ok(response);
-												Sketch message response

											
										
										
											2024-05-18 18:18:42 +00:00
+								    }
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								}
 								#[cfg(test)]
 								mod tests {
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								    use anyhow::Result;
-												Sketch message response

											
										
										
											2024-05-18 18:18:42 +00:00
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								    use lavina_core::player::PlayerId;
-												move repo methods into submodules and clean up warnings

											
										
										
											2024-05-10 21:50:34 +00:00
+								    use proto_xmpp::bind::{Jid, Name, Resource, Server};
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								    use proto_xmpp::client::Presence;
-												xmpp: add x-user element to muc presence response (#67)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/67

											
										
										
											2024-05-14 14:44:49 +00:00
+								    use proto_xmpp::muc::XUser;
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
-												Sketch message response

											
										
										
											2024-05-18 18:18:42 +00:00
+								    use crate::testkit::{expect_user_authenticated, TestServer};
 								    use crate::Authenticated;
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								    #[tokio::test]
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								    async fn test_muc_joining() -> Result<()> {
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								        let server = TestServer::start().await.unwrap();
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								        server.core.create_player(&PlayerId::from("tester")?).await?;
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
 								        let player_id = PlayerId::from("tester").unwrap();
 								        let user = Authenticated {
 								            player_id,
 								            xmpp_name: Name("tester".into()),
 								            xmpp_resource: Resource("tester".into()),
 								            xmpp_muc_name: Resource("tester".into()),
 								        };
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								        let mut player_conn = server.core.connect_to_player(&user.player_id).await;
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								        let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								        let response = conn.retrieve_muc_presence(&user.xmpp_name).await.unwrap();
-												xmpp: add x-user element to muc presence response (#67)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/67

											
										
										
											2024-05-14 14:44:49 +00:00
+								        let expected = Presence {
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								            to: Some(Jid {
 								                name: Some(conn.user.xmpp_name.clone()),
 								                server: Server(conn.hostname.clone()),
 								                resource: Some(conn.user.xmpp_resource.clone()),
 								            }),
 								            from: Some(Jid {
 								                name: Some(user.xmpp_name.clone()),
 								                server: Server(conn.hostname_rooms.clone()),
 								                resource: Some(conn.user.xmpp_muc_name.clone()),
 								            }),
-												xmpp: add x-user element to muc presence response (#67)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/67

											
										
										
											2024-05-14 14:44:49 +00:00
+								            custom: vec![XUser],
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								            ..Default::default()
 								        };
 								        assert_eq!(expected, response);
 								        server.shutdown().await.unwrap();
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								        Ok(())
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								    }
 								    // Test that joining a room second time after a server restart,
 								    // i.e. in-memory cache of memberships is cleaned, does not cause any issues.
 								    #[tokio::test]
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								    async fn test_muc_joining_twice() -> Result<()> {
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								        let server = TestServer::start().await.unwrap();
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								        server.core.create_player(&PlayerId::from("tester")?).await?;
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
 								        let player_id = PlayerId::from("tester").unwrap();
 								        let user = Authenticated {
 								            player_id,
 								            xmpp_name: Name("tester".into()),
 								            xmpp_resource: Resource("tester".into()),
 								            xmpp_muc_name: Resource("tester".into()),
 								        };
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								        let mut player_conn = server.core.connect_to_player(&user.player_id).await;
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								        let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								        let response = conn.retrieve_muc_presence(&user.xmpp_name).await.unwrap();
-												xmpp: add x-user element to muc presence response (#67)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/67

											
										
										
											2024-05-14 14:44:49 +00:00
+								        let expected = Presence {
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								            to: Some(Jid {
 								                name: Some(conn.user.xmpp_name.clone()),
 								                server: Server(conn.hostname.clone()),
 								                resource: Some(conn.user.xmpp_resource.clone()),
 								            }),
 								            from: Some(Jid {
 								                name: Some(user.xmpp_name.clone()),
 								                server: Server(conn.hostname_rooms.clone()),
 								                resource: Some(conn.user.xmpp_muc_name.clone()),
 								            }),
-												xmpp: add x-user element to muc presence response (#67)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/67

											
										
										
											2024-05-14 14:44:49 +00:00
+								            custom: vec![XUser],
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								            ..Default::default()
 								        };
 								        assert_eq!(expected, response);
 								        drop(conn);
 								        let server = server.reboot().await.unwrap();
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								        let mut player_conn = server.core.connect_to_player(&user.player_id).await;
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								        let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();
-												Rename and remove commented

											
										
										
											2024-05-23 17:09:51 +00:00
+								        let response = conn.retrieve_muc_presence(&user.xmpp_name).await.unwrap();
-												xmpp: unit-tests for resource bind it and muc presence

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/64
Co-authored-by: Mikhail <mikhail@liamets.dev>
Co-committed-by: Mikhail <mikhail@liamets.dev>

											
										
										
											2024-05-10 13:35:34 +00:00
+								        assert_eq!(expected, response);
 								        server.shutdown().await.unwrap();
-												core: separate the model from the logic implementation (#66)

This separates the core in two layers – the model objects and the `LavinaCore` service. Service is responsible for implementing the application logic and exposing it as core's public API to projections, while the model objects will be independent of each other and responsible only for managing and owning in-memory data.

The model objects include:
1. `Storage` – the open connection to the SQLite DB.
2. `PlayerRegistry` – creates, stores refs to, and stops player actors.
3. `RoomRegistry` – manages active rooms.
4. `DialogRegistry` – manages active dialogs.
5. `Broadcasting` – manages subscriptions of players to rooms on remote cluster nodes.
6. `LavinaClient` – manages HTTP connections to remote cluster nodes.
7. `ClusterMetadata` – read-only configuration of the cluster metadata, i.e. allocation of entities to nodes.

As a result:
1. Model objects will be fully independent of each other, e.g. it's no longer necessary to provide a `Storage` to all registries, or to provide `PlayerRegistry` and `DialogRegistry` to each other.
2. Model objects will no longer be `Arc`-wrapped; instead the whole `Services` object will be `Arc`ed and provided to projections.
3. The public API of `lavina-core` will be properly delimited by the APIs of `LavinaCore`, `PlayerConnection` and so on.
4. `LavinaCore` and `PlayerConnection` will also contain APIs of all features, unlike it was previously with `RoomRegistry` and `DialogRegistry`. This is unfortunate, but it could be improved in future.

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/66

											
										
										
											2024-05-13 14:32:45 +00:00
+								        Ok(())
-												xmpp: split off stanza and update handling into modules (#27)

Reviewed-on: https://git.vilunov.me/lavina/lavina/pulls/27

											
										
										
											2023-10-13 20:09:08 +00:00
+								    }
 								}