Delegate on_logon logic to AwaitingLogon state

Author: davidsteiner

crates/hotfix/src/session.rs

@@ -339,20 +339,8 @@ where
     }
 
     async fn on_logon(&mut self) -> Result<(), SessionOperationError> {
-        if let SessionState::AwaitingLogon(AwaitingLogonState { writer, .. }) = &self.state {
-            let writer = writer.clone();
-            // happy logon flow, the session is now active
-            self.apply_transition(TransitionResult::TransitionTo(SessionState::new_active(
-                writer,
-                self.ctx.config.heartbeat_interval,
-            )))
-            .await;
-            self.ctx.application.on_logon().await;
-            self.ctx.store.increment_target_seq_number().await?;
-        } else {
-            error!("received unexpected logon message");
-        }
-
+        let transition = self.state.on_peer_logon(&mut self.ctx).await?;
+        self.apply_transition(transition).await;
         Ok(())
     }
 

crates/hotfix/src/session/state.rs

@@ -63,6 +63,21 @@ impl SessionState {
         })
     }
 
+    /// Handles a Logon message from the peer. Only AwaitingLogon produces a
+    /// transition — all other states log an error and stay.
+    pub(crate) async fn on_peer_logon<A: Application, S: MessageStore>(
+        &self,
+        ctx: &mut SessionCtx<A, S>,
+    ) -> Result<TransitionResult, SessionOperationError> {
+        match self {
+            Self::AwaitingLogon(state) => state.on_peer_logon(ctx).await,
+            _ => {
+                error!("received unexpected logon message");
+                Ok(TransitionResult::Stay)
+            }
+        }
+    }
+
     /// Returns the transition to apply when a Logout message is received from the peer.
     /// Each state determines its own reconnect policy and disconnect reason.
     pub(crate) fn on_peer_logout(&self) -> TransitionResult {

crates/hotfix/src/session/state/awaiting_logon.rs

@@ -38,6 +38,18 @@ impl AwaitingLogonState {
         }
     }
 
+    pub(crate) async fn on_peer_logon<A: Application, S: MessageStore>(
+        &self,
+        ctx: &mut SessionCtx<A, S>,
+    ) -> Result<TransitionResult, SessionOperationError> {
+        ctx.application.on_logon().await;
+        ctx.store.increment_target_seq_number().await?;
+        Ok(TransitionResult::TransitionTo(SessionState::new_active(
+            self.writer.clone(),
+            ctx.config.heartbeat_interval,
+        )))
+    }
+
     pub(crate) async fn handle_verification_issue<A: Application, S: MessageStore>(
         &self,
         ctx: &mut SessionCtx<A, S>,