Deprecate old code path for sending app messages

Author: davidsteiner

crates/hotfix/src/initiator.rs

@@ -68,14 +68,6 @@ impl<Outbound: OutboundMessage> Initiator<Outbound> {
         self.session_handle.send_forget(msg).await
     }
 
-    #[deprecated(since = "0.7.2", note = "use `send` or `send_forget` instead")]
-    #[allow(deprecated)]
-    pub async fn send_message(&self, msg: Outbound) -> Result<()> {
-        self.session_handle.send_message(msg).await?;
-
-        Ok(())
-    }
-
     pub fn is_interested(&self, sender_comp_id: &str, target_comp_id: &str) -> bool {
         self.config.sender_comp_id == sender_comp_id && self.config.target_comp_id == target_comp_id
     }

crates/hotfix/src/session.rs

@@ -802,36 +802,14 @@ where
             .reset_peer_timer(self.config.heartbeat_interval, test_request_id);
     }
 
-    async fn send_app_message(&mut self, message: Outbound) -> Result<()> {
-        match self.application.on_outbound_message(&message).await {
-            OutboundDecision::Send => {
-                self.send_message(message)
-                    .await
-                    .context("failed to send app message")?;
-            }
-            OutboundDecision::Drop => {
-                debug!("dropped outbound message as instructed by the application");
-            }
-            OutboundDecision::TerminateSession => {
-                warn!("the application indicated we should terminate the session");
-                self.state.disconnect_writer().await;
-            }
-        }
-
-        Ok(())
-    }
-
-    async fn send_app_message_with_confirmation(
-        &mut self,
-        message: Outbound,
-    ) -> Result<SendOutcome, SendError> {
+    async fn send_app_message(&mut self, message: Outbound) -> Result<SendOutcome, SendError> {
         if !self.state.is_connected() {
             return Err(SendError::Disconnected);
         }
 
         match self.application.on_outbound_message(&message).await {
             OutboundDecision::Send => {
-                let sequence_number = self.send_message_returning_seq(message).await?;
+                let sequence_number = self.send_message(message).await?;
                 Ok(SendOutcome::Sent { sequence_number })
             }
             OutboundDecision::Drop => {
@@ -846,10 +824,7 @@ where
         }
     }
 
-    async fn send_message_returning_seq(
-        &mut self,
-        message: impl OutboundMessage,
-    ) -> Result<u64, SendError> {
+    async fn send_message(&mut self, message: impl OutboundMessage) -> Result<u64, SendError> {
         let seq_num = self.store.next_sender_seq_number();
         let msg_type = message.message_type().as_bytes().to_vec();
         let msg = generate_message(
@@ -881,31 +856,6 @@ where
         Ok(seq_num)
     }
 
-    async fn send_message(&mut self, message: impl OutboundMessage) -> Result<()> {
-        let seq_num = self.store.next_sender_seq_number();
-        let msg_type = message.message_type().as_bytes().to_vec();
-        let msg = generate_message(
-            &self.config.begin_string,
-            &self.config.sender_comp_id,
-            &self.config.target_comp_id,
-            seq_num,
-            message,
-        )
-        .context("failed to generate message")?;
-        self.store
-            .increment_sender_seq_number()
-            .await
-            .context("failed to increment sender seq number")?;
-
-        self.store
-            .add(seq_num, &msg)
-            .await
-            .context("failed to add message to store")?;
-        self.send_raw(&msg_type, msg).await;
-
-        Ok(())
-    }
-
     async fn send_raw(&mut self, message_type: &[u8], data: Vec<u8>) {
         self.state
             .send_message(message_type, RawFixMessage::new(data))
@@ -935,7 +885,8 @@ where
 
     async fn send_resend_request(&mut self, begin: u64, end: u64) -> Result<()> {
         let request = ResendRequest::new(begin, end);
-        self.send_message(request).await
+        self.send_message(request).await.map(|_| ())?;
+        Ok(())
     }
 
     async fn send_logon(&mut self) -> Result<()> {
@@ -949,12 +900,14 @@ where
 
         let logon = Logon::new(self.config.heartbeat_interval, reset_config);
 
-        self.send_message(logon).await
+        self.send_message(logon).await.map(|_| ())?;
+        Ok(())
     }
 
     async fn send_logout(&mut self, reason: &str) -> Result<()> {
         let logout = Logout::with_reason(reason.to_string());
-        self.send_message(logout).await
+        self.send_message(logout).await.map(|_| ())?;
+        Ok(())
     }
 
     /// Sends a logout message and immediately disconnects the counterparty.
@@ -1021,14 +974,14 @@ where
 
     async fn handle_outbound_message(&mut self, request: OutboundRequest<Outbound>) {
         let OutboundRequest { message, confirm } = request;
+        let result = self.send_app_message(message).await;
         match confirm {
             Some(tx) => {
-                let result = self.send_app_message_with_confirmation(message).await;
                 // Ignore send errors - receiver may have been dropped
                 let _ = tx.send(result);
             }
             None => {
-                if let Err(err) = self.send_app_message(message).await {
+                if let Err(err) = result {
                     error!(err = ?err, "failed to send app message: {err}");
                 }
             }

crates/hotfix/src/session/session_handle.rs

@@ -2,7 +2,6 @@ use crate::session::admin_request::AdminRequest;
 use crate::session::error::{SendError, SendOutcome};
 use crate::session::session_ref::OutboundRequest;
 use crate::session::{InternalSessionRef, SessionInfo};
-use anyhow::anyhow;
 use tokio::sync::{mpsc, oneshot};
 
 /// A public handle to the session that can be used to interact with the session.
@@ -62,19 +61,6 @@ impl<Outbound> SessionHandle<Outbound> {
         Ok(())
     }
 
-    #[deprecated(since = "0.5.0", note = "use `send` or `send_forget` instead")]
-    pub async fn send_message(&self, msg: Outbound) -> anyhow::Result<()> {
-        self.outbound_message_sender
-            .send(OutboundRequest {
-                message: msg,
-                confirm: None,
-            })
-            .await
-            .map_err(|_| anyhow!("failed to send message"))?;
-
-        Ok(())
-    }
-
     pub async fn shutdown(&self, reconnect: bool) -> anyhow::Result<()> {
         self.admin_request_sender
             .send(AdminRequest::InitiateGracefulShutdown { reconnect })