Rename RepliconServer into ServerMessages

Because it holds only messages now.

Author: Shatur

CHANGELOG.md

@@ -34,6 +34,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Rename `IntoComponentRule::register_component` to `IntoComponentRule::into_rule` and move it to the `shared::replication::rules::component` module.
 - Rename `NetworkStats` to `ClientStats` and move it from `shared::backend::connected_client` to `shared::backend`. It's also now a separate resource from `RepliconClient`.
 - Rename `RepliconClient` into `ClientMessages`. It holds only messages now.
+- Rename `RepliconServer` into `ServerMessages`. It holds only messages now.
 - Replace `IntoReplicationRule` with `IntoComponentRules`, which returns only `Vec<ComponentRule>`.
 - Replace `ReplicationBundle` with `BundleRules`, which returns only `Vec<ComponentRule>` and uses an associated constant to customize the priority.
 - Hide `ServerEntityMap` mutation methods from public API.

bevy_replicon_example_backend/src/server.rs

@@ -48,8 +48,8 @@ fn set_stopped(mut state: ResMut<NextState<ServerState>>) {
 
 fn receive_packets(
     mut commands: Commands,
+    mut messages: ResMut<ServerMessages>,
     server: Res<ExampleServer>,
-    mut replicon_server: ResMut<RepliconServer>,
     mut clients: Query<(Entity, &mut ExampleConnection, Option<&ConditionerConfig>)>,
     global_config: Option<Res<ConditionerConfig>>,
 ) {
@@ -115,18 +115,18 @@ fn receive_packets(
         }
 
         while let Some((channel_id, message)) = connection.conditioner.pop(now) {
-            replicon_server.insert_received(client, channel_id, message)
+            messages.insert_received(client, channel_id, message)
         }
     }
 }
 
 fn send_packets(
     mut commands: Commands,
     mut disconnect_events: EventReader<DisconnectRequest>,
-    mut replicon_server: ResMut<RepliconServer>,
+    mut messages: ResMut<ServerMessages>,
     mut clients: Query<&mut ExampleConnection>,
 ) {
-    for (client, channel_id, message) in replicon_server.drain_sent() {
+    for (client, channel_id, message) in messages.drain_sent() {
         let mut connection = clients
             .get_mut(client)
             .expect("all connected clients should have streams");

src/lib.rs

@@ -713,7 +713,7 @@ pub mod prelude {
                 channels::{Channel, RepliconChannels},
                 client_messages::ClientMessages,
                 connected_client::ConnectedClient,
-                replicon_server::RepliconServer,
+                server_messages::ServerMessages,
             },
             client_id::ClientId,
             event::{

src/server.rs

@@ -81,7 +81,7 @@ impl Plugin for ServerPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<DespawnBuffer>()
             .init_resource::<RemovalBuffer>()
-            .init_resource::<RepliconServer>()
+            .init_resource::<ServerMessages>()
             .init_resource::<ServerTick>()
             .init_resource::<EntityBuffer>()
             .init_resource::<BufferedServerEvents>()
@@ -171,9 +171,9 @@ impl Plugin for ServerPlugin {
 
     fn finish(&self, app: &mut App) {
         app.world_mut()
-            .resource_scope(|world, mut server: Mut<RepliconServer>| {
+            .resource_scope(|world, mut messages: Mut<ServerMessages>| {
                 let channels = world.resource::<RepliconChannels>();
-                server.setup_client_channels(channels.client_channels().len());
+                messages.setup_client_channels(channels.client_channels().len());
             });
     }
 }
@@ -194,10 +194,10 @@ fn handle_connects(
 
 fn handle_disconnects(
     trigger: Trigger<OnRemove, ConnectedClient>,
-    mut server: ResMut<RepliconServer>,
+    mut messages: ResMut<ServerMessages>,
 ) {
     debug!("client `{}` disconnected", trigger.target());
-    server.remove_client(trigger.target());
+    messages.remove_client(trigger.target());
 }
 
 fn check_protocol(
@@ -242,11 +242,11 @@ fn cleanup_acks(
 
 fn receive_acks(
     change_tick: SystemChangeTick,
-    mut server: ResMut<RepliconServer>,
+    mut messages: ResMut<ServerMessages>,
     mut clients: Query<&mut ClientTicks>,
     mut entity_buffer: ResMut<EntityBuffer>,
 ) {
-    for (client, mut message) in server.receive(ClientChannel::MutationAcks) {
+    for (client, mut message) in messages.receive(ClientChannel::MutationAcks) {
         while message.has_remaining() {
             match postcard_utils::from_buf(&mut message) {
                 Ok(mutate_index) => {
@@ -316,7 +316,7 @@ fn send_replication(
     mut removal_buffer: ResMut<RemovalBuffer>,
     mut entity_buffer: ResMut<EntityBuffer>,
     mut despawn_buffer: ResMut<DespawnBuffer>,
-    mut server: ResMut<RepliconServer>,
+    mut messages: ResMut<ServerMessages>,
     track_mutate_messages: Res<TrackMutateMessages>,
     registry: Res<ReplicationRegistry>,
     type_registry: Res<AppTypeRegistry>,
@@ -349,7 +349,7 @@ fn send_replication(
 
     send_messages(
         &mut clients,
-        &mut server,
+        &mut messages,
         **server_tick,
         **track_mutate_messages,
         &mut serialized,
@@ -364,13 +364,13 @@ fn send_replication(
 
 fn reset(
     mut commands: Commands,
-    mut server: ResMut<RepliconServer>,
+    mut messages: ResMut<ServerMessages>,
     mut server_tick: ResMut<ServerTick>,
     mut related_entities: ResMut<RelatedEntities>,
     clients: Query<Entity, With<ConnectedClient>>,
     mut buffered_events: ResMut<BufferedServerEvents>,
 ) {
-    server.clear();
+    messages.clear();
     *server_tick = Default::default();
     buffered_events.clear();
     related_entities.clear();
@@ -391,7 +391,7 @@ fn send_messages(
         &mut PriorityMap,
         &mut ClientVisibility,
     )>,
-    server: &mut RepliconServer,
+    messages: &mut ServerMessages,
     server_tick: RepliconTick,
     track_mutate_messages: bool,
     serialized: &mut SerializedData,
@@ -407,15 +407,15 @@ fn send_messages(
             let server_tick_range =
                 write_tick_cached(&mut server_tick_range, serialized, server_tick)?;
 
-            updates.send(server, client_entity, serialized, server_tick_range)?;
+            updates.send(messages, client_entity, serialized, server_tick_range)?;
         }
 
         if !mutations.is_empty() || track_mutate_messages {
             let server_tick_range =
                 write_tick_cached(&mut server_tick_range, serialized, server_tick)?;
 
             mutations.send(
-                server,
+                messages,
                 client_entity,
                 &mut ticks,
                 entity_buffer,
@@ -798,7 +798,7 @@ pub enum ServerSet {
     ///
     /// Runs in [`PreUpdate`].
     ReceivePackets,
-    /// Systems that receive data from [`RepliconServer`].
+    /// Systems that read data from [`ServerMessages`].
     ///
     /// Runs in [`PreUpdate`].
     Receive,
@@ -809,7 +809,7 @@ pub enum ServerSet {
     ///
     /// Runs in [`OnEnter`] for [`ServerState::Running`].
     ReadRelations,
-    /// Systems that send data to [`RepliconServer`].
+    /// Systems that write data to [`ServerMessages`].
     ///
     /// Runs in [`PostUpdate`] on server tick, see [`TickPolicy`].
     Send,

src/server/event.rs

@@ -117,7 +117,7 @@ impl Plugin for ServerEventPlugin {
 
 fn send_or_buffer(
     server_events: FilteredResources,
-    mut server: ResMut<RepliconServer>,
+    mut messages: ResMut<ServerMessages>,
     mut buffered_events: ResMut<BufferedServerEvents>,
     type_registry: Res<AppTypeRegistry>,
     event_registry: Res<RemoteEventRegistry>,
@@ -138,7 +138,7 @@ fn send_or_buffer(
             event.send_or_buffer(
                 &mut ctx,
                 &server_events,
-                &mut server,
+                &mut messages,
                 &clients,
                 &mut buffered_events,
             );
@@ -147,18 +147,18 @@ fn send_or_buffer(
 }
 
 fn send_buffered(
-    mut server: ResMut<RepliconServer>,
+    mut messages: ResMut<ServerMessages>,
     mut buffered_events: ResMut<BufferedServerEvents>,
     clients: Query<(Entity, Option<&ClientTicks>), With<ConnectedClient>>,
 ) {
     buffered_events
-        .send_all(&mut server, &clients)
+        .send_all(&mut messages, &clients)
         .expect("buffered server events should send");
 }
 
 fn receive(
     mut client_events: FilteredResourcesMut,
-    mut server: ResMut<RepliconServer>,
+    mut messages: ResMut<ServerMessages>,
     type_registry: Res<AppTypeRegistry>,
     event_registry: Res<RemoteEventRegistry>,
 ) {
@@ -172,7 +172,7 @@ fn receive(
             .expect("client events resource should be accessible");
 
         // SAFETY: passed pointer was obtained using this event data.
-        unsafe { event.receive(&mut ctx, client_events.into_inner(), &mut server) };
+        unsafe { event.receive(&mut ctx, client_events.into_inner(), &mut messages) };
     }
 }
 

src/server/replication_messages/mutations.rs

@@ -154,7 +154,7 @@ impl Mutations {
     /// using the last up-to-date mutations to avoid re-sending old values.
     pub(crate) fn send(
         &mut self,
-        server: &mut RepliconServer,
+        messages: &mut ServerMessages,
         client: Entity,
         ticks: &mut ClientTicks,
         entity_buffer: &mut EntityBuffer,
@@ -246,7 +246,7 @@ impl Mutations {
 
             debug_assert_eq!(message.len(), message_size);
 
-            server.send(client, ServerChannel::Mutations, message);
+            messages.send(client, ServerChannel::Mutations, message);
         }
 
         Ok(self.messages.len())
@@ -446,7 +446,7 @@ mod tests {
         track_mutate_messages: bool,
     ) -> usize {
         let mut serialized = SerializedData::default();
-        let mut server = RepliconServer::default();
+        let mut messages = ServerMessages::default();
         let mut mutations = Mutations::default();
 
         mutations.resize_related(related.len());
@@ -463,7 +463,7 @@ mod tests {
 
         mutations
             .send(
-                &mut server,
+                &mut messages,
                 Entity::PLACEHOLDER,
                 &mut Default::default(),
                 &mut Default::default(),

src/server/replication_messages/updates.rs

@@ -181,7 +181,7 @@ impl Updates {
     /// on deserialization just consume all remaining bytes.
     pub(crate) fn send(
         &self,
-        server: &mut RepliconServer,
+        messages: &mut ServerMessages,
         client: Entity,
         serialized: &SerializedData,
         server_tick_range: Range<usize>,
@@ -272,7 +272,7 @@ impl Updates {
 
         debug_assert_eq!(message.len(), message_size);
 
-        server.send(client, ServerChannel::Updates, message);
+        messages.send(client, ServerChannel::Updates, message);
 
         Ok(())
     }

src/shared/backend.rs

@@ -5,7 +5,7 @@
 //! - Create channels defined in the [`RepliconChannels`](channels::RepliconChannels) resource.
 //!   This can be done via an extension trait that provides a conversion which the user needs to call manually to get channels for the backend.
 //! - Manage the [`ClientState`] and [`ServerState`] states.
-//! - Update the [`RepliconServer`](replicon_server::RepliconServer) and [`ClientMessages`](client_messages::ClientMessages) resources.
+//! - Update the [`ServerMessages`](server_messages::ServerMessages) and [`ClientMessages`](client_messages::ClientMessages) resources.
 //! - Spawn and despawn entities with [`ConnectedClient`](connected_client::ConnectedClient) component.
 //! - React on [`DisconnectRequest`] event.
 //! - Optionally update statistic in [`ClientStats`] resource and components.
@@ -25,7 +25,7 @@
 pub mod channels;
 pub mod client_messages;
 pub mod connected_client;
-pub mod replicon_server;
+pub mod server_messages;
 
 use bevy::prelude::*;
 
@@ -123,14 +123,14 @@ mod tests {
             client_messages.send(ClientChannel::MutationAcks, message);
         }
 
-        let mut server = RepliconServer::default();
-        server.setup_client_channels(channels.client_channels().len());
+        let mut server_messages = ServerMessages::default();
+        server_messages.setup_client_channels(channels.client_channels().len());
 
         for (channel_id, message) in client_messages.drain_sent() {
-            server.insert_received(Entity::PLACEHOLDER, channel_id, message);
+            server_messages.insert_received(Entity::PLACEHOLDER, channel_id, message);
         }
 
-        let messages: Vec<_> = server
+        let messages: Vec<_> = server_messages
             .receive(ClientChannel::MutationAcks)
             .map(|(_, message)| message)
             .collect();
@@ -140,18 +140,18 @@ mod tests {
     #[test]
     fn server_to_client() {
         let channels = RepliconChannels::default();
-        let mut server = RepliconServer::default();
-        server.setup_client_channels(channels.client_channels().len());
+        let mut server_messages = ServerMessages::default();
+        server_messages.setup_client_channels(channels.client_channels().len());
 
         const MESSAGES: &[&[u8]] = &[&[0], &[1]];
         for &message in MESSAGES {
-            server.send(Entity::PLACEHOLDER, ServerChannel::Mutations, message);
+            server_messages.send(Entity::PLACEHOLDER, ServerChannel::Mutations, message);
         }
 
         let mut client_messages = ClientMessages::default();
         client_messages.setup_server_channels(channels.server_channels().len());
 
-        for (_, channel_id, message) in server.drain_sent() {
+        for (_, channel_id, message) in server_messages.drain_sent() {
             client_messages.insert_received(channel_id, message);
         }
 

src/shared/backend/replicon_server.rs renamed to src/shared/backend/server_messages.rs

@@ -2,17 +2,17 @@ use bevy::prelude::*;
 use bytes::Bytes;
 use log::trace;
 
-/// Stores information about the server independent from the messaging backend.
+/// Sent and received messages for exchange between Replicon and the messaging backend.
 ///
 /// The messaging backend is responsible for updating this resource:
-/// - For receiving messages, [`Self::insert_received`] should be used.
-///   A system to forward messages from the backend to Replicon should run in [`ServerSet::ReceivePackets`](crate::server::ServerSet::ReceivePackets).
-/// - For sending messages, [`Self::drain_sent`] should be used to drain all sent messages.
-///   A system to forward messages from Replicon to the backend should run in [`ServerSet::SendPackets`](crate::server::ServerSet::SendPackets).
+/// - Received messages should be forwarded to Replicon via [`Self::insert_received`] in
+///   [`ServerSet::ReceivePackets`](crate::prelude::ServerSet::ReceivePackets).
+/// - Replicon messages needs to be forwarded to the backend via [`Self::drain_sent`] in
+///   [`ServerSet::SendPackets`](crate::prelude::ServerSet::SendPackets).
 ///
 /// Inserted as resource by [`ServerPlugin`](crate::server::ServerPlugin).
 #[derive(Resource, Default)]
-pub struct RepliconServer {
+pub struct ServerMessages {
     /// List of received messages for each channel.
     ///
     /// Top index is channel ID.
@@ -23,7 +23,7 @@ pub struct RepliconServer {
     sent_messages: Vec<(Entity, usize, Bytes)>,
 }
 
-impl RepliconServer {
+impl ServerMessages {
     /// Changes the size of the receive messages storage according to the number of client channels.
     pub(crate) fn setup_client_channels(&mut self, channels_count: usize) {
         self.received_messages.resize(channels_count, Vec::new());