Add prepare_message to SessionCtx

Author: davidsteiner

crates/hotfix/src/session.rs

@@ -899,37 +899,11 @@ where
         &mut self,
         message: impl OutboundMessage,
     ) -> Result<u64, InternalSendError> {
-        let seq_num = self.ctx.store.next_sender_seq_number();
         let msg_type = message.message_type().to_string();
-        let msg = generate_message(
-            &self.ctx.config.begin_string,
-            &self.ctx.config.sender_comp_id,
-            &self.ctx.config.target_comp_id,
-            seq_num,
-            message,
-        )
-        .map_err(|e| {
-            InternalSendError::Persist(crate::store::StoreError::PersistMessage {
-                sequence_number: seq_num,
-                source: e.into(),
-            })
-        })?;
-
-        self.ctx
-            .store
-            .increment_sender_seq_number()
-            .await
-            .map_err(InternalSendError::SequenceNumber)?;
-
-        self.ctx
-            .store
-            .add(seq_num, &msg)
-            .await
-            .map_err(InternalSendError::Persist)?;
-
-        self.send_raw(&msg_type, msg).await;
-
-        Ok(seq_num)
+        let prepared = self.ctx.prepare_message(message).await?;
+        self.state.send_message(&msg_type, prepared.raw).await;
+        self.reset_heartbeat_timer();
+        Ok(prepared.seq_num)
     }
 
     async fn send_raw(&mut self, message_type: &str, data: Vec<u8>) {

crates/hotfix/src/session/ctx.rs

@@ -1,7 +1,13 @@
 use hotfix_message::MessageBuilder;
 use hotfix_message::message::Config as MessageConfig;
+use hotfix_store::MessageStore;
 
 use crate::config::SessionConfig;
+use crate::message::OutboundMessage;
+use crate::message::generate_message;
+use crate::message::parser::RawFixMessage;
+use crate::session::error::InternalSendError;
+use crate::store::StoreError;
 
 pub(crate) struct SessionCtx<A, S> {
     pub config: SessionConfig,
@@ -10,3 +16,45 @@ pub(crate) struct SessionCtx<A, S> {
     pub message_builder: MessageBuilder,
     pub message_config: MessageConfig,
 }
+
+pub(crate) struct PreparedMessage {
+    pub seq_num: u64,
+    pub raw: RawFixMessage,
+}
+
+impl<A, S: MessageStore> SessionCtx<A, S> {
+    pub async fn prepare_message(
+        &mut self,
+        message: impl OutboundMessage,
+    ) -> Result<PreparedMessage, InternalSendError> {
+        let seq_num = self.store.next_sender_seq_number();
+        let msg = generate_message(
+            &self.config.begin_string,
+            &self.config.sender_comp_id,
+            &self.config.target_comp_id,
+            seq_num,
+            message,
+        )
+        .map_err(|e| {
+            InternalSendError::Persist(StoreError::PersistMessage {
+                sequence_number: seq_num,
+                source: e.into(),
+            })
+        })?;
+
+        self.store
+            .increment_sender_seq_number()
+            .await
+            .map_err(InternalSendError::SequenceNumber)?;
+
+        self.store
+            .add(seq_num, &msg)
+            .await
+            .map_err(InternalSendError::Persist)?;
+
+        Ok(PreparedMessage {
+            seq_num,
+            raw: RawFixMessage::new(msg),
+        })
+    }
+}