Move server network code to separate file

VMelnalksnis · VMelnalksnis · commit 82d4e5b2c6d3 · 2025-04-06T15:58:23.000+03:00
diff --git a/minigolf_server/src/main.rs b/minigolf_server/src/main.rs
@@ -3,6 +3,8 @@ fn main() {
     panic!("this example is not available on WASM");
 }
 
+#[cfg(not(target_family = "wasm"))]
+mod network;
 #[cfg(not(target_family = "wasm"))]
 mod server;
 
diff --git a/minigolf_server/src/network.rs b/minigolf_server/src/network.rs
@@ -0,0 +1,148 @@
+use {
+    crate::server::Args,
+    aeronet::io::{
+        Session,
+        connection::{DisconnectReason, Disconnected, LocalAddr},
+        server::Server,
+    },
+    aeronet_replicon::server::{AeronetRepliconServer, AeronetRepliconServerPlugin},
+    aeronet_websocket::server::{WebSocketServer, WebSocketServerPlugin},
+    aeronet_webtransport::{
+        cert,
+        server::{SessionRequest, SessionResponse, WebTransportServer, WebTransportServerPlugin},
+        wtransport,
+    },
+    bevy::prelude::*,
+    bevy_replicon::prelude::*,
+    core::time::Duration,
+};
+
+/// Sets up minigolf server networking.
+#[derive(Debug)]
+pub(crate) struct ServerNetworkPlugin;
+
+impl Plugin for ServerNetworkPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins((WebTransportServerPlugin, WebSocketServerPlugin))
+            .add_plugins((
+                RepliconPlugins.set(ServerPlugin {
+                    // 1 frame lasts `1.0 / TICK_RATE` anyway
+                    tick_policy: TickPolicy::Manual,
+                    ..Default::default()
+                }),
+                AeronetRepliconServerPlugin,
+            ))
+            .add_observer(on_opened)
+            .add_observer(on_session_request)
+            .add_observer(on_connected)
+            .add_observer(on_disconnected)
+            .add_systems(Startup, (open_web_transport_server, open_web_socket_server));
+    }
+}
+
+//
+// WebTransport
+//
+
+fn open_web_transport_server(mut commands: Commands, args: Res<Args>) {
+    let identity = wtransport::Identity::self_signed(["localhost", "127.0.0.1", "::1"])
+        .expect("all given SANs should be valid DNS names");
+    let cert = &identity.certificate_chain().as_slice()[0];
+    let spki_fingerprint = cert::spki_fingerprint_b64(cert).expect("should be a valid certificate");
+    let cert_hash = cert::hash_to_b64(cert.hash());
+    info!("************************");
+    info!("SPKI FINGERPRINT");
+    info!("  {spki_fingerprint}");
+    info!("CERTIFICATE HASH");
+    info!("  {cert_hash}");
+    info!("************************");
+
+    let config = web_transport_config(identity, &args);
+    let server = commands
+        .spawn((Name::new("WebTransport Server"), AeronetRepliconServer))
+        .queue(WebTransportServer::open(config))
+        .id();
+    info!("Opening WebTransport server {server}");
+}
+
+type WebTransportServerConfig = aeronet_webtransport::server::ServerConfig;
+
+fn web_transport_config(identity: wtransport::Identity, args: &Args) -> WebTransportServerConfig {
+    WebTransportServerConfig::builder()
+        .with_bind_default(args.wt_port)
+        .with_identity(identity)
+        .keep_alive_interval(Some(Duration::from_secs(1)))
+        .max_idle_timeout(Some(Duration::from_secs(5)))
+        .expect("should be a valid idle timeout")
+        .build()
+}
+
+//
+// WebSocket
+//
+
+type WebSocketServerConfig = aeronet_websocket::server::ServerConfig;
+
+fn open_web_socket_server(mut commands: Commands, args: Res<Args>) {
+    let config = web_socket_config(&args);
+    let server = commands
+        .spawn((Name::new("WebSocket Server"), AeronetRepliconServer))
+        .queue(WebSocketServer::open(config))
+        .id();
+    info!("Opening WebSocket server {server}");
+}
+
+fn web_socket_config(args: &Args) -> WebSocketServerConfig {
+    WebSocketServerConfig::builder()
+        .with_bind_default(args.ws_port)
+        .with_no_encryption()
+}
+
+fn on_opened(trigger: Trigger<OnAdd, Server>, servers: Query<&LocalAddr>) {
+    let server = trigger.entity();
+    let local_addr = servers
+        .get(server)
+        .expect("opened server should have a binding socket `LocalAddr`");
+    info!("{server} opened on {}", **local_addr);
+}
+
+fn on_session_request(mut request: Trigger<SessionRequest>, clients: Query<&Parent>) {
+    let client = request.entity();
+    let Ok(server) = clients.get(client).map(Parent::get) else {
+        return;
+    };
+
+    info!("{client} connecting to {server} with headers:");
+    for (header_key, header_value) in &request.headers {
+        info!("  {header_key}: {header_value}");
+    }
+
+    request.respond(SessionResponse::Accepted);
+}
+
+fn on_connected(trigger: Trigger<OnAdd, Session>, clients: Query<&Parent>) {
+    let client = trigger.entity();
+    let Ok(server) = clients.get(client).map(Parent::get) else {
+        return;
+    };
+    info!("{client} connected to {server}");
+}
+
+fn on_disconnected(trigger: Trigger<Disconnected>, clients: Query<&Parent>) {
+    let client = trigger.entity();
+    let Ok(server) = clients.get(client).map(Parent::get) else {
+        return;
+    };
+
+    match &trigger.reason {
+        DisconnectReason::User(reason) => {
+            info!("{client} disconnected from {server} by user: {reason}");
+        }
+        DisconnectReason::Peer(reason) => {
+            info!("{client} disconnected from {server} by peer: {reason}");
+        }
+        DisconnectReason::Error(err) => {
+            warn!("{client} disconnected from {server} due to error: {err:?}");
+        }
+    }
+}
diff --git a/minigolf_server/src/server.rs b/minigolf_server/src/server.rs
@@ -1,16 +1,6 @@
 use {
-    aeronet::io::{
-        Session,
-        connection::{DisconnectReason, Disconnected, LocalAddr},
-        server::Server,
-    },
-    aeronet_replicon::server::{AeronetRepliconServer, AeronetRepliconServerPlugin},
-    aeronet_websocket::server::{WebSocketServer, WebSocketServerPlugin},
-    aeronet_webtransport::{
-        cert,
-        server::{SessionRequest, SessionResponse, WebTransportServer, WebTransportServerPlugin},
-        wtransport,
-    },
+    crate::network::ServerNetworkPlugin,
+    aeronet::io::{Session, connection::Disconnected},
     avian3d::prelude::*,
     bevy::{
         app::ScheduleRunnerPlugin,
@@ -19,7 +9,7 @@ use {
         render::{RenderPlugin, settings::WgpuSettings},
         winit::WinitPlugin,
     },
-    bevy_replicon::prelude::*,
+    bevy_replicon::{prelude::*, server::increment_tick},
     core::time::Duration,
     minigolf::{LevelMesh, MinigolfPlugin, Player, PlayerInput, TICK_RATE},
 };
@@ -37,13 +27,13 @@ enum GameLayer {
 
 /// `move_box` demo server
 #[derive(Debug, Resource, clap::Parser)]
-struct Args {
+pub(crate) struct Args {
     /// Port to listen for WebTransport connections on
     #[arg(long, default_value_t = WEB_TRANSPORT_PORT)]
-    wt_port: u16,
+    pub(crate) wt_port: u16,
     /// Port to listen for WebSocket connections on
     #[arg(long, default_value_t = WEB_SOCKET_PORT)]
-    ws_port: u16,
+    pub(crate) ws_port: u16,
 }
 
 impl FromWorld for Args {
@@ -52,6 +42,11 @@ impl FromWorld for Args {
     }
 }
 
+#[derive(Component, Reflect)]
+struct PlayerSession {
+    player: Entity,
+}
+
 pub fn main() -> AppExit {
     App::new()
         .init_resource::<Args>()
@@ -68,38 +63,20 @@ pub fn main() -> AppExit {
                 .disable::<WinitPlugin>(),
         )
         .add_plugins((
-            // transport
-            WebTransportServerPlugin,
-            WebSocketServerPlugin,
-            // replication
-            RepliconPlugins.set(ServerPlugin {
-                // 1 frame lasts `1.0 / TICK_RATE` anyway
-                tick_policy: TickPolicy::Manual,
-                ..Default::default()
-            }),
-            AeronetRepliconServerPlugin,
-            // game
+            ServerNetworkPlugin,
             MinigolfPlugin,
             PhysicsPlugins::default(),
         ))
         .add_plugins(ScheduleRunnerPlugin::run_loop(Duration::from_secs_f64(
             1.0 / f64::from(TICK_RATE),
         )))
-        .add_systems(
-            Startup,
-            (open_web_transport_server, open_web_socket_server, setup),
-        )
-        .add_observer(on_opened)
-        .add_observer(on_session_request)
+        .add_systems(Startup, setup)
         .add_observer(on_connected)
         .add_observer(on_disconnected)
         .insert_resource(Time::<Fixed>::from_hz(128.0))
-        .add_systems(
-            FixedUpdate,
-            recv_input.chain().run_if(server_or_singleplayer),
-        )
+        .add_systems(FixedUpdate, recv_input.run_if(server_or_singleplayer))
         .add_systems(FixedUpdate, reset)
-        .add_systems(FixedPreUpdate, bevy_replicon::server::increment_tick)
+        .add_systems(FixedPreUpdate, increment_tick)
         .run()
 }
 
@@ -181,96 +158,12 @@ fn recv_input(
     }
 }
 
-//
-// WebTransport
-//
-
-fn open_web_transport_server(mut commands: Commands, args: Res<Args>) {
-    let identity = wtransport::Identity::self_signed(["localhost", "127.0.0.1", "::1"])
-        .expect("all given SANs should be valid DNS names");
-    let cert = &identity.certificate_chain().as_slice()[0];
-    let spki_fingerprint = cert::spki_fingerprint_b64(cert).expect("should be a valid certificate");
-    let cert_hash = cert::hash_to_b64(cert.hash());
-    info!("************************");
-    info!("SPKI FINGERPRINT");
-    info!("  {spki_fingerprint}");
-    info!("CERTIFICATE HASH");
-    info!("  {cert_hash}");
-    info!("************************");
-
-    let config = web_transport_config(identity, &args);
-    let server = commands
-        .spawn((Name::new("WebTransport Server"), AeronetRepliconServer))
-        .queue(WebTransportServer::open(config))
-        .id();
-    info!("Opening WebTransport server {server}");
-}
-
-type WebTransportServerConfig = aeronet_webtransport::server::ServerConfig;
-
-fn web_transport_config(identity: wtransport::Identity, args: &Args) -> WebTransportServerConfig {
-    WebTransportServerConfig::builder()
-        .with_bind_default(args.wt_port)
-        .with_identity(identity)
-        .keep_alive_interval(Some(Duration::from_secs(1)))
-        .max_idle_timeout(Some(Duration::from_secs(5)))
-        .expect("should be a valid idle timeout")
-        .build()
-}
-
-fn on_session_request(mut request: Trigger<SessionRequest>, clients: Query<&Parent>) {
-    let client = request.entity();
-    let Ok(server) = clients.get(client).map(Parent::get) else {
-        return;
-    };
-
-    info!("{client} connecting to {server} with headers:");
-    for (header_key, header_value) in &request.headers {
-        info!("  {header_key}: {header_value}");
-    }
-
-    request.respond(SessionResponse::Accepted);
-}
-
-//
-// WebSocket
-//
-
-type WebSocketServerConfig = aeronet_websocket::server::ServerConfig;
-
-fn open_web_socket_server(mut commands: Commands, args: Res<Args>) {
-    let config = web_socket_config(&args);
-    let server = commands
-        .spawn((Name::new("WebSocket Server"), AeronetRepliconServer))
-        .queue(WebSocketServer::open(config))
-        .id();
-    info!("Opening WebSocket server {server}");
-}
-
-fn web_socket_config(args: &Args) -> WebSocketServerConfig {
-    WebSocketServerConfig::builder()
-        .with_bind_default(args.ws_port)
-        .with_no_encryption()
-}
-
 //
 // server logic
 //
 
-fn on_opened(trigger: Trigger<OnAdd, Server>, servers: Query<&LocalAddr>) {
-    let server = trigger.entity();
-    let local_addr = servers
-        .get(server)
-        .expect("opened server should have a binding socket `LocalAddr`");
-    info!("{server} opened on {}", **local_addr);
-}
-
-fn on_connected(trigger: Trigger<OnAdd, Session>, clients: Query<&Parent>, mut commands: Commands) {
+fn on_connected(trigger: Trigger<OnAdd, Session>, mut commands: Commands) {
     let client = trigger.entity();
-    let Ok(server) = clients.get(client).map(Parent::get) else {
-        return;
-    };
-    info!("{client} connected to {server}");
 
     let player = commands
         .spawn((
@@ -292,34 +185,12 @@ fn on_connected(trigger: Trigger<OnAdd, Session>, clients: Query<&Parent>, mut c
     commands.entity(client).insert(PlayerSession { player });
 }
 
-#[derive(Component, Reflect)]
-struct PlayerSession {
-    player: Entity,
-}
-
 fn on_disconnected(
     trigger: Trigger<Disconnected>,
-    clients: Query<&Parent>,
     sessions: Query<&PlayerSession>,
     mut commands: Commands,
 ) {
     let client = trigger.entity();
-    let Ok(server) = clients.get(client).map(Parent::get) else {
-        return;
-    };
-
-    match &trigger.reason {
-        DisconnectReason::User(reason) => {
-            info!("{client} disconnected from {server} by user: {reason}");
-        }
-        DisconnectReason::Peer(reason) => {
-            info!("{client} disconnected from {server} by peer: {reason}");
-        }
-        DisconnectReason::Error(err) => {
-            warn!("{client} disconnected from {server} due to error: {err:?}");
-        }
-    }
-
     let Ok(session) = sessions.get(client) else {
         return;
     };

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,8 @@ fn main() {`
`3`	`3`	`panic!("this example is not available on WASM");`
`4`	`4`	`}`
`5`	`5`
	`6`	`+#[cfg(not(target_family = "wasm"))]`
	`7`	`+mod network;`
`6`	`8`	`#[cfg(not(target_family = "wasm"))]`
`7`	`9`	`mod server;`
`8`	`10`