Implement admin action to set target sequence number

Author: davidsteiner

crates/hotfix/src/session.rs

@@ -568,6 +568,27 @@ where
                 warn!("resetting sequence numbers on next logon");
                 self.reset_on_next_logon = true;
             }
+            AdminRequest::SetNextTargetSeqNum { seq_num, responder } => {
+                let current = self.state.as_status();
+                let response = if matches!(self.state, SessionState::Disconnected(_)) {
+                    self.ctx
+                        .store
+                        .set_target_seq_number(seq_num.get() - 1)
+                        .await
+                        .map_err(SetNextTargetSeqNumError::from)
+                } else {
+                    warn!(
+                        ?current,
+                        seq_num = seq_num.get(),
+                        "rejecting SetNextTargetSeqNum outside Disconnected state"
+                    );
+                    Err(SetNextTargetSeqNumError::InvalidState { current })
+                };
+
+                if responder.send(response).is_err() {
+                    error!("failed to respond to SetNextTargetSeqNum request");
+                }
+            }
         }
     }
 

crates/hotfix/src/session/admin_request.rs

@@ -1,4 +1,6 @@
 use crate::session::SessionInfo;
+use crate::session::error::SetNextTargetSeqNumError;
+use std::num::NonZeroU64;
 use tokio::sync::oneshot;
 
 /// Administrative actions exposed to users of the engine to control the session.
@@ -13,4 +15,10 @@ pub enum AdminRequest {
     /// which can be used to re-synchronise our state with the counterparty in
     /// unfortunate scenarios where such drastic recover is required.
     ResetSequenceNumbersOnNextLogon,
+    /// Set the next expected target sequence number. Permitted only while the
+    /// session is `Disconnected` — see `SetNextTargetSeqNumError::InvalidState`.
+    SetNextTargetSeqNum {
+        seq_num: NonZeroU64,
+        responder: oneshot::Sender<Result<(), SetNextTargetSeqNumError>>,
+    },
 }

crates/hotfix/src/session/session_handle.rs

@@ -1,7 +1,8 @@
 use crate::session::admin_request::AdminRequest;
-use crate::session::error::{SendError, SendOutcome};
+use crate::session::error::{SendError, SendOutcome, SetNextTargetSeqNumError};
 use crate::session::session_ref::OutboundRequest;
 use crate::session::{InternalSessionRef, SessionInfo};
+use std::num::NonZeroU64;
 use tokio::sync::{mpsc, oneshot};
 
 /// A public handle to the session that can be used to interact with the session.
@@ -66,6 +67,26 @@ impl<Outbound> SessionHandle<Outbound> {
             .await?;
         Ok(())
     }
+
+    /// Sets the next expected target sequence number.
+    ///
+    /// Permitted only while the session is `Disconnected`. Use this to realign
+    /// after a counterparty-initiated sequence reset without forcing a bilateral
+    /// reset — the peer's subsequent `ResendRequest` is handled by the existing
+    /// resend/gap-fill logic.
+    pub async fn set_next_target_seq_num(
+        &self,
+        seq_num: NonZeroU64,
+    ) -> Result<(), SetNextTargetSeqNumError> {
+        let (responder, receiver) = oneshot::channel();
+        self.admin_request_sender
+            .send(AdminRequest::SetNextTargetSeqNum { seq_num, responder })
+            .await
+            .map_err(|_| SetNextTargetSeqNumError::Send(SendError::SessionGone))?;
+        receiver
+            .await
+            .map_err(|_| SetNextTargetSeqNumError::Send(SendError::SessionGone))?
+    }
 }
 
 impl<M> From<InternalSessionRef<M>> for SessionHandle<M> {

crates/hotfix/tests/session_test_cases/admin_request_tests.rs

@@ -5,6 +5,7 @@ use crate::common::setup::given_an_active_session;
 use hotfix::session::Status;
 use hotfix_message::Part;
 use hotfix_message::fix44::{MsgType, RESET_SEQ_NUM_FLAG};
+use std::num::NonZeroU64;
 
 /// Tests that we can request the session to reset sequence numbers once.
 ///
@@ -72,3 +73,24 @@ async fn test_reset_sequence_numbers_once() {
 
     finally(&session, &mut counterparty).disconnect().await;
 }
+
+/// Happy path: while `Disconnected`, setting the next expected target sequence
+/// number succeeds and the new value is visible via session info.
+#[tokio::test]
+async fn test_set_next_target_seq_num_while_disconnected() {
+    let session = crate::common::setup::given_a_disconnected_session();
+
+    let new_target = NonZeroU64::new(42).expect("42 is non-zero");
+    session
+        .session_handle()
+        .set_next_target_seq_num(new_target)
+        .await
+        .expect("set_next_target_seq_num to succeed");
+
+    let info = session
+        .session_handle()
+        .get_session_info()
+        .await
+        .expect("session info");
+    assert_eq!(info.next_target_seq_number, 42);
+}