fix: update version to 0.2.46 and modify transaction state handling

Author: shenjinti

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsipstack"
-version = "0.2.45"
+version = "0.2.46"
 edition = "2021"
 description = "SIP Stack Rust library for building SIP applications"
 license = "MIT"

src/transaction/endpoint.rs

@@ -430,15 +430,15 @@ impl EndpointInner {
     }
 
     pub fn attach_transaction(&self, key: &TransactionKey, tu_sender: TransactionEventSender) {
-        trace!("attach_transaction {}", key);
+        trace!(%key, "attach transaction");
         self.transactions
             .lock()
             .unwrap()
             .insert(key.clone(), tu_sender);
     }
 
     pub fn detach_transaction(&self, key: &TransactionKey, last_message: Option<SipMessage>) {
-        trace!("detach_transaction {}", key);
+        trace!(%key, "detach transaction");
         self.transactions.lock().unwrap().remove(key);
 
         if let Some(msg) = last_message {

src/transaction/mod.rs

@@ -35,7 +35,8 @@ pub type TransactionSender = UnboundedSender<Transaction>;
 ///
 /// # States
 ///
-/// * `Calling` - Initial state for client transactions when request is sent
+/// * `Nothing` - Initial state for client transactions created
+/// * `Calling` - Initial state for client transactions when request is sent or received
 /// * `Trying` - Request has been sent/received, waiting for response/processing
 /// * `Proceeding` - Provisional response received/sent (1xx except 100 Trying)
 /// * `Completed` - Final response received/sent, waiting for ACK (INVITE) or cleanup
@@ -46,21 +47,21 @@ pub type TransactionSender = UnboundedSender<Transaction>;
 ///
 /// ## Client Non-INVITE Transaction
 /// ```text
-/// Calling → Trying → Proceeding → Completed → Terminated
+/// Nothing → Calling → Trying → Proceeding → Completed → Terminated
 /// ```
 ///
 /// ## Client INVITE Transaction  
 /// ```text
-/// Calling → Trying → Proceeding → Completed → Terminated
+/// Nothing → Calling → Trying → Proceeding → Completed → Terminated
 ///                                      ↓
-///                                 Confirmed → Terminated
+///                                   Confirmed → Terminated
 /// ```
 ///
 /// ## Server Transactions
 /// ```text
-/// Trying → Proceeding → Completed → Terminated
+/// Calling → Trying → Proceeding → Completed → Terminated
 ///                           ↓
-///                      Confirmed → Terminated (INVITE only)
+///                         Confirmed → Terminated (INVITE only)
 /// ```
 ///
 /// # Examples
@@ -70,7 +71,8 @@ pub type TransactionSender = UnboundedSender<Transaction>;
 ///
 /// let state = TransactionState::Proceeding;
 /// match state {
-///     TransactionState::Calling => println!("Transaction starting"),
+///     TransactionState::Nothing => println!("Transaction starting"),
+///     TransactionState::Calling => println!("Request sent"),
 ///     TransactionState::Trying => println!("Request sent/received"),
 ///     TransactionState::Proceeding => println!("Provisional response"),
 ///     TransactionState::Completed => println!("Final response"),
@@ -80,6 +82,7 @@ pub type TransactionSender = UnboundedSender<Transaction>;
 /// ```
 #[derive(Debug, Clone, PartialEq)]
 pub enum TransactionState {
+    Nothing,
     Calling,
     Trying,
     Proceeding,
@@ -91,6 +94,7 @@ pub enum TransactionState {
 impl std::fmt::Display for TransactionState {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            TransactionState::Nothing => write!(f, "Nothing"),
             TransactionState::Calling => write!(f, "Calling"),
             TransactionState::Trying => write!(f, "Trying"),
             TransactionState::Proceeding => write!(f, "Proceeding"),

src/transaction/tests/test_transaction_states.rs

@@ -50,7 +50,7 @@ async fn test_client_invite_transaction_creation() -> crate::Result<()> {
     );
 
     // Initial state should be Calling
-    assert_eq!(tx.state, TransactionState::Calling);
+    assert_eq!(tx.state, TransactionState::Nothing);
     assert_eq!(tx.transaction_type, TransactionType::ClientInvite);
 
     Ok(())
@@ -72,7 +72,7 @@ async fn test_client_non_invite_transaction_creation() -> crate::Result<()> {
     );
 
     // Initial state should be Calling
-    assert_eq!(tx.state, TransactionState::Calling);
+    assert_eq!(tx.state, TransactionState::Nothing);
     assert_eq!(tx.transaction_type, TransactionType::ClientNonInvite);
 
     Ok(())

src/transaction/transaction.rs

@@ -175,15 +175,23 @@ impl Transaction {
         endpoint_inner: EndpointInnerRef,
     ) -> Self {
         let (tu_sender, tu_receiver) = unbounded_channel();
-        info!(%key, "transaction created");
+        let state = if matches!(
+            transaction_type,
+            TransactionType::ServerInvite | TransactionType::ServerNonInvite
+        ) {
+            TransactionState::Calling
+        } else {
+            TransactionState::Nothing
+        };
+        info!(%key, %state, "transaction created");
         let tx = Self {
             transaction_type,
             endpoint_inner,
             connection,
             key,
             original,
             destination: None,
-            state: TransactionState::Calling,
+            state,
             last_response: None,
             last_ack: None,
             timer_a: None,
@@ -270,7 +278,7 @@ impl Transaction {
         };
 
         connection.send(message, self.destination.as_ref()).await?;
-        self.transition(TransactionState::Trying).map(|_| ())
+        self.transition(TransactionState::Calling).map(|_| ())
     }
 
     pub async fn reply_with(
@@ -348,7 +356,11 @@ impl Transaction {
 
     fn can_transition(&self, target: &TransactionState) -> Result<()> {
         match (&self.state, target) {
-            (&TransactionState::Calling, &TransactionState::Trying)
+            (&TransactionState::Nothing, &TransactionState::Calling)
+            | (&TransactionState::Nothing, &TransactionState::Trying)
+            | (&TransactionState::Nothing, &TransactionState::Proceeding)
+            | (&TransactionState::Nothing, &TransactionState::Terminated)
+            | (&TransactionState::Calling, &TransactionState::Trying)
             | (&TransactionState::Calling, &TransactionState::Proceeding)
             | (&TransactionState::Calling, &TransactionState::Completed)
             | (&TransactionState::Calling, &TransactionState::Terminated)
@@ -615,7 +627,7 @@ impl Transaction {
 
     async fn on_timer(&mut self, timer: TransactionTimer) -> Result<()> {
         match self.state {
-            TransactionState::Trying => {
+            TransactionState::Calling | TransactionState::Trying => {
                 if matches!(
                     self.transaction_type,
                     TransactionType::ClientInvite | TransactionType::ClientNonInvite
@@ -704,8 +716,28 @@ impl Transaction {
             return Ok(self.state.clone());
         }
         match state {
+            TransactionState::Nothing => {}
             TransactionState::Calling => {
-                // not state can transition to Calling
+                let connection = self.connection.as_ref().ok_or(Error::TransactionError(
+                    "no connection found".to_string(),
+                    self.key.clone(),
+                ))?;
+
+                if matches!(
+                    self.transaction_type,
+                    TransactionType::ClientInvite | TransactionType::ClientNonInvite
+                ) {
+                    if !connection.is_reliable() {
+                        let timer_a = self.endpoint_inner.timers.timeout(
+                            self.endpoint_inner.option.t1,
+                            TransactionTimer::TimerA(
+                                self.key.clone(),
+                                self.endpoint_inner.option.t1,
+                            ),
+                        );
+                        self.timer_a.replace(timer_a);
+                    }
+                }
             }
             TransactionState::Trying => {
                 let connection = self.connection.as_ref().ok_or(Error::TransactionError(