Push on_disconnect down to SessionState

Author: davidsteiner

crates/hotfix/src/session.rs

@@ -333,21 +333,8 @@ where
     }
 
     async fn on_disconnect(&mut self, reason: String) {
-        let transition = match self.state {
-            SessionState::Active(_)
-            | SessionState::AwaitingLogon(_)
-            | SessionState::AwaitingResend(_) => {
-                self.state.disconnect_writer().await;
-                TransitionResult::TransitionTo(SessionState::new_disconnected(true, &reason))
-            }
-            SessionState::Disconnected(_) => {
-                warn!("disconnect message was received, but the session is already disconnected");
-                TransitionResult::Stay
-            }
-            SessionState::AwaitingLogout(AwaitingLogoutState { reconnect, .. }) => {
-                TransitionResult::TransitionTo(SessionState::new_disconnected(reconnect, &reason))
-            }
-        };
+        self.state.disconnect_writer().await;
+        let transition = self.state.on_disconnect(&reason);
         self.apply_transition(transition).await;
     }
 

crates/hotfix/src/session/state.rs

@@ -63,6 +63,23 @@ impl SessionState {
         })
     }
 
+    /// Returns the transition to apply when the transport layer reports a disconnect.
+    /// Each state determines its own reconnect policy.
+    pub(crate) fn on_disconnect(&self, reason: &str) -> TransitionResult {
+        match self {
+            Self::Active(_) | Self::AwaitingLogon(_) | Self::AwaitingResend(_) => {
+                TransitionResult::TransitionTo(Self::new_disconnected(true, reason))
+            }
+            Self::AwaitingLogout(AwaitingLogoutState { reconnect, .. }) => {
+                TransitionResult::TransitionTo(Self::new_disconnected(*reconnect, reason))
+            }
+            Self::Disconnected(_) => {
+                warn!("disconnect message was received, but the session is already disconnected");
+                TransitionResult::Stay
+            }
+        }
+    }
+
     /// Let the current state decide whether an inbound message should be processed,
     /// queued for later, or rejected before verification and dispatch.
     pub(crate) fn pre_process_inbound(&mut self, message: Message) -> PreProcessDecision {