Move handle_sending_time_accuracy_problem to inbound module

Author: davidsteiner

crates/hotfix/src/session.rs

@@ -607,24 +607,31 @@ where
                     .await;
             }
             MessageVerificationError::SendingTimeAccuracyIssue { msg_seq_num } => {
-                self.handle_sending_time_accuracy_problem(msg_seq_num, "unexpected sending time")
-                    .await;
+                if let Some(writer) = self.state.get_writer() {
+                    inbound::handle_sending_time_accuracy_problem(
+                        &mut self.ctx, writer, msg_seq_num, "unexpected sending time",
+                    ).await;
+                }
             }
             MessageVerificationError::SendingTimeMissing { msg_seq_num } => {
-                self.handle_sending_time_accuracy_problem(msg_seq_num, "sending time missing")
-                    .await;
+                if let Some(writer) = self.state.get_writer() {
+                    inbound::handle_sending_time_accuracy_problem(
+                        &mut self.ctx, writer, msg_seq_num, "sending time missing",
+                    ).await;
+                }
             }
             MessageVerificationError::OriginalSendingTimeMissing { msg_seq_num } => {
                 self.handle_original_sending_time_missing(msg_seq_num).await;
             }
             MessageVerificationError::OriginalSendingTimeAfterSendingTime {
                 msg_seq_num, ..
             } => {
-                self.handle_sending_time_accuracy_problem(
-                    msg_seq_num,
-                    "original sending time is after sending time",
-                )
-                .await;
+                if let Some(writer) = self.state.get_writer() {
+                    inbound::handle_sending_time_accuracy_problem(
+                        &mut self.ctx, writer, msg_seq_num,
+                        "original sending time is after sending time",
+                    ).await;
+                }
             }
         }
 
@@ -745,17 +752,6 @@ where
         }
     }
 
-    async fn handle_sending_time_accuracy_problem(&mut self, msg_seq_num: u64, text: &str) {
-        let reject = Reject::new(msg_seq_num)
-            .session_reject_reason(SessionRejectReason::SendingtimeAccuracyProblem)
-            .text(text);
-        if let Err(err) = self.send_message(reject).await {
-            error!("failed to send reject for time accuracy problem: {err}");
-        };
-        if let Err(err) = self.ctx.store.increment_target_seq_number().await {
-            error!("failed to increment target seq number: {:?}", err);
-        };
-    }
 
     async fn handle_original_sending_time_missing(&mut self, msg_seq_num: u64) {
         let reject = Reject::new(msg_seq_num)

crates/hotfix/src/session/inbound.rs

@@ -1,18 +1,20 @@
+use crate::message::reject::Reject;
 use crate::message::verification::verify_message;
 use crate::message::verification_error::MessageVerificationError;
 use crate::session::ctx::SessionCtx;
+use crate::session::outbound;
+use crate::transport::writer::WriterRef;
 use hotfix_message::message::Message;
+use hotfix_message::session_fields::SessionRejectReason;
 use hotfix_store::MessageStore;
+use tracing::error;
 
-pub(crate) fn verify_message_with_ctx<A, S>(
+pub(crate) fn verify_message_with_ctx<A, S: MessageStore>(
     ctx: &SessionCtx<A, S>,
     message: &Message,
     check_too_high: bool,
     check_too_low: bool,
-) -> Result<(), MessageVerificationError>
-where
-    S: MessageStore,
-{
+) -> Result<(), MessageVerificationError> {
     let expected_seq_number = if check_too_high || check_too_low {
         Some(ctx.store.next_target_seq_number())
     } else {
@@ -26,3 +28,20 @@ where
         check_too_low,
     )
 }
+
+pub(crate) async fn handle_sending_time_accuracy_problem<A, S: MessageStore>(
+    ctx: &mut SessionCtx<A, S>,
+    writer: &WriterRef,
+    msg_seq_num: u64,
+    text: &str,
+) {
+    let reject = Reject::new(msg_seq_num)
+        .session_reject_reason(SessionRejectReason::SendingtimeAccuracyProblem)
+        .text(text);
+    if let Err(err) = outbound::send_message(ctx, writer, reject).await {
+        error!("failed to send reject for time accuracy problem: {err}");
+    }
+    if let Err(err) = ctx.store.increment_target_seq_number().await {
+        error!("failed to increment target seq number: {:?}", err);
+    }
+}

crates/hotfix/src/session/outbound.rs

@@ -5,13 +5,23 @@ use tracing::{debug, enabled, error, info};
 use crate::message::generate_message;
 use crate::message::parser::RawFixMessage;
 use crate::message::sequence_reset::SequenceReset;
-use crate::message::{is_admin, prepare_message_for_resend};
+use crate::message::{OutboundMessage, is_admin, prepare_message_for_resend};
 use crate::session::ctx::SessionCtx;
-use crate::session::error::SessionOperationError;
+use crate::session::error::{InternalSendError, SessionOperationError};
 use crate::session::get_msg_seq_num;
 use crate::transport::writer::WriterRef;
 use hotfix_message::session_fields::MSG_TYPE;
 
+pub async fn send_message<A, S: MessageStore>(
+    ctx: &mut SessionCtx<A, S>,
+    writer: &WriterRef,
+    message: impl OutboundMessage,
+) -> Result<u64, InternalSendError> {
+    let prepared = ctx.prepare_message(message).await?;
+    writer.send_raw_message(prepared.raw).await;
+    Ok(prepared.seq_num)
+}
+
 pub async fn send_sequence_reset<A, S: MessageStore>(
     ctx: &mut SessionCtx<A, S>,
     writer: &WriterRef,