Add API to get information on the session

Author: davidsteiner

crates/hotfix/src/session.rs

@@ -1,4 +1,5 @@
 mod event;
+mod info;
 mod state;
 
 use anyhow::{Result, anyhow};
@@ -31,6 +32,7 @@ use crate::message::sequence_reset::SequenceReset;
 use crate::message::test_request::TestRequest;
 use crate::message_utils::is_admin;
 use crate::session::event::AwaitingActiveSessionResponse;
+use crate::session::info::SessionInfo;
 use crate::session::state::{AwaitingResendState, TestRequestId};
 use crate::session_schedule::SessionSchedule;
 use event::SessionEvent;
@@ -104,6 +106,15 @@ impl<M: FixMessage> SessionRef<M> {
         receiver.await.expect("to receive a response");
         debug!("resuming connection as session is active");
     }
+
+    pub async fn get_session_info(&self) -> SessionInfo {
+        let (sender, receiver) = oneshot::channel::<SessionInfo>();
+        self.sender
+            .send(SessionEvent::SessionInfoRequested(sender))
+            .await
+            .unwrap();
+        receiver.await.expect("to receive a response")
+    }
 }
 
 struct Session<M, S> {
@@ -639,6 +650,11 @@ impl<M: FixMessage, S: MessageStore> Session<M, S> {
             SessionEvent::AwaitingActiveSession(responder) => {
                 self.state.register_session_awaiter(responder);
             }
+            SessionEvent::SessionInfoRequested(responder) => {
+                if responder.send(self.get_session_info()).is_err() {
+                    error!("failed to respond to session info request");
+                }
+            }
         }
     }
 
@@ -696,6 +712,14 @@ impl<M: FixMessage, S: MessageStore> Session<M, S> {
         let deadline = Instant::now() + Duration::from_secs(SCHEDULE_CHECK_INTERVAL);
         self.schedule_check_timer.as_mut().reset(deadline);
     }
+
+    fn get_session_info(&self) -> SessionInfo {
+        SessionInfo {
+            next_sender_seq_number: self.store.next_sender_seq_number(),
+            next_target_seq_number: self.store.next_target_seq_number(),
+            status: self.state.as_status(),
+        }
+    }
 }
 
 async fn run_session<M, S>(mut session: Session<M, S>)

crates/hotfix/src/session/event.rs

@@ -1,6 +1,7 @@
 use tokio::sync::oneshot;
 
 use crate::message::parser::RawFixMessage;
+use crate::session::info::SessionInfo;
 use crate::transport::writer::WriterRef;
 
 #[derive(Debug)]
@@ -17,6 +18,8 @@ pub enum SessionEvent<M> {
     ShouldReconnect(oneshot::Sender<bool>),
     /// Ask the session to notify us when the session is active.
     AwaitingActiveSession(oneshot::Sender<AwaitingActiveSessionResponse>),
+    /// Ask the session for a report on its state
+    SessionInfoRequested(oneshot::Sender<SessionInfo>),
 }
 
 /// The response sent by the session to AwaitingActiveSession messages.

crates/hotfix/src/session/info.rs

@@ -0,0 +1,24 @@
+/// Information about the session's current state.
+///
+/// This is intended for external code to peek inside
+/// the session's internals for debugging and monitoring.
+#[derive(Clone, Debug)]
+pub struct SessionInfo {
+    pub next_sender_seq_number: u64,
+    pub next_target_seq_number: u64,
+    pub status: Status,
+}
+
+/// The status of the session as reported to external consumers.
+///
+/// These roughly correspond to the `SessionState` variants but don't contain
+/// internal state.
+#[derive(Clone, Debug)]
+pub enum Status {
+    AwaitingLogon,
+    AwaitingResend,
+    AwaitingLogout,
+    Active,
+    LoggedOut,
+    Disconnected,
+}

crates/hotfix/src/session/state.rs

@@ -1,5 +1,6 @@
 use crate::message::parser::RawFixMessage;
 use crate::session::event::AwaitingActiveSessionResponse;
+use crate::session::info::Status as SessionInfoStatus;
 use crate::transport::writer::WriterRef;
 use hotfix_message::message::Message;
 use std::collections::VecDeque;
@@ -211,6 +212,17 @@ impl SessionState {
     pub fn is_expecting_test_response(&self) -> bool {
         self.expected_test_response_id().is_some()
     }
+
+    pub fn as_status(&self) -> SessionInfoStatus {
+        match self {
+            SessionState::AwaitingLogon { .. } => SessionInfoStatus::AwaitingLogon,
+            SessionState::AwaitingResend(_) => SessionInfoStatus::AwaitingResend,
+            SessionState::AwaitingLogout { .. } => SessionInfoStatus::AwaitingLogout,
+            SessionState::Active(_) => SessionInfoStatus::Active,
+            SessionState::LoggedOut { .. } => SessionInfoStatus::LoggedOut,
+            SessionState::Disconnected(_) => SessionInfoStatus::Disconnected,
+        }
+    }
 }
 
 #[inline]