Merge branch 'develop' of https://github.com/stacks-network/stacks-core into feat/signer-state-conflict-resolution-strategies

Author: jferrant

stacks-common/src/util/macros.rs

@@ -40,16 +40,32 @@ macro_rules! iterable_enum {
 ///  and EnumType.get_name() for free.
 #[macro_export]
 macro_rules! define_named_enum {
-    ($Name:ident { $($Variant:ident($VarName:literal),)* }) =>
-    {
+    (
+        $(#[$enum_meta:meta])*
+        $Name:ident {
+            $(
+                $(#[$variant_meta:meta])*
+                $Variant:ident($VarName:literal),
+            )*
+        }
+    ) => {
+        $(#[$enum_meta])*
         #[derive(::serde::Serialize, ::serde::Deserialize, Debug, Hash, PartialEq, Eq, Copy, Clone)]
         pub enum $Name {
-            $($Variant),*,
+            $(
+                $(#[$variant_meta])*
+                $Variant,
+            )*
         }
+
         impl $Name {
+            /// All variants of the enum.
             pub const ALL: &[$Name] = &[$($Name::$Variant),*];
+
+            /// All names corresponding to the enum variants.
             pub const ALL_NAMES: &[&str] = &[$($VarName),*];
 
+            /// Looks up a variant by its name string.
             pub fn lookup_by_name(name: &str) -> Option<Self> {
                 match name {
                     $(
@@ -59,6 +75,7 @@ macro_rules! define_named_enum {
                 }
             }
 
+            /// Gets the name of the enum variant as a `String`.
             pub fn get_name(&self) -> String {
                 match self {
                     $(
@@ -67,6 +84,7 @@ macro_rules! define_named_enum {
                 }
             }
 
+            /// Gets the name of the enum variant as a static string slice.
             pub fn get_name_str(&self) -> &'static str {
                 match self {
                     $(
@@ -75,12 +93,13 @@ macro_rules! define_named_enum {
                 }
             }
         }
+
         impl ::std::fmt::Display for $Name {
             fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
                 write!(f, "{}", self.get_name_str())
             }
         }
-    }
+    };
 }
 
 /// Define a "named" enum, i.e., each variant corresponds
@@ -739,3 +758,46 @@ macro_rules! function_name {
         stdext::function_name!()
     };
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_macro_define_named_enum_without_docs() {
+        define_named_enum!(
+        MyEnum {
+            Variant1("variant1"),
+            Variant2("variant2"),
+        });
+
+        assert_eq!("variant1", MyEnum::Variant1.get_name());
+        assert_eq!("variant2", MyEnum::Variant2.get_name());
+
+        assert_eq!("variant1", MyEnum::Variant1.get_name_str());
+        assert_eq!("variant2", MyEnum::Variant2.get_name_str());
+
+        assert_eq!(Some(MyEnum::Variant1), MyEnum::lookup_by_name("variant1"));
+        assert_eq!(Some(MyEnum::Variant2), MyEnum::lookup_by_name("variant2"));
+        assert_eq!(None, MyEnum::lookup_by_name("inexistent"));
+    }
+    #[test]
+    fn test_macro_define_named_enum_with_docs() {
+        define_named_enum!(
+        /// MyEnum doc
+        MyEnum {
+            /// Variant1 doc
+            Variant1("variant1"),
+            /// Variant2 doc
+            Variant2("variant2"),
+        });
+
+        assert_eq!("variant1", MyEnum::Variant1.get_name());
+        assert_eq!("variant2", MyEnum::Variant2.get_name());
+
+        assert_eq!("variant1", MyEnum::Variant1.get_name_str());
+        assert_eq!("variant2", MyEnum::Variant2.get_name_str());
+
+        assert_eq!(Some(MyEnum::Variant1), MyEnum::lookup_by_name("variant1"));
+        assert_eq!(Some(MyEnum::Variant2), MyEnum::lookup_by_name("variant2"));
+        assert_eq!(None, MyEnum::lookup_by_name("inexistent"));
+    }
+}

stackslib/src/net/httpcore.rs

@@ -70,6 +70,9 @@ pub const STACKS_REQUEST_ID: &str = "X-Request-Id";
 /// from non-Stacks nodes (like Gaia hubs, CDNs, vanilla HTTP servers, and so on).
 pub const HTTP_REQUEST_ID_RESERVED: u32 = 0;
 
+/// The interval at which to send heartbeat logs
+const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(60);
+
 /// All representations of the `tip=` query parameter value
 #[derive(Debug, Clone, PartialEq)]
 pub enum TipRequest {
@@ -1823,8 +1826,8 @@ pub fn send_http_request(
     stream.set_nodelay(true)?;
 
     let start = Instant::now();
-
-    debug!("send_request: Sending request"; "request" => %request.request_path());
+    let request_path = request.request_path();
+    debug!("send_request: Sending request"; "request" => request_path);
 
     // Some explanation of what's going on here is in order.
     //
@@ -1882,6 +1885,7 @@ pub fn send_http_request(
         .map_err(|e| handle_net_error(e, "Failed to serialize request body"))?;
 
     debug!("send_request(sending data)");
+    let mut last_heartbeat_time = start; // Initialize heartbeat timer for sending loop
     loop {
         let flushed = request_handle
             .try_flush()
@@ -1900,18 +1904,26 @@ pub fn send_http_request(
             break;
         }
 
-        if Instant::now().saturating_duration_since(start) > timeout {
+        if start.elapsed() >= timeout {
             return Err(io::Error::new(
                 io::ErrorKind::WouldBlock,
-                "Timed out while receiving request",
+                "Timed out while sending request",
             ));
         }
+        if last_heartbeat_time.elapsed() >= HEARTBEAT_INTERVAL {
+            info!(
+                "send_request(sending data): heartbeat - still sending request to {} path='{}' (elapsed: {:?})",
+                addr, request_path, start.elapsed()
+            );
+            last_heartbeat_time = Instant::now();
+        }
     }
 
     // Step 4: pull bytes from the socket back into the handle, and see if the connection decoded
     // and dispatched any new messages to the request handle.  If so, then extract the message and
     // check that it's a well-formed HTTP response.
     debug!("send_request(receiving data)");
+    last_heartbeat_time = Instant::now();
     let response = loop {
         // get back the reply
         debug!("send_request(receiving data): try to receive data");
@@ -1944,12 +1956,19 @@ pub fn send_http_request(
         };
         request_handle = rh;
 
-        if Instant::now().saturating_duration_since(start) > timeout {
+        if start.elapsed() >= timeout {
             return Err(io::Error::new(
                 io::ErrorKind::WouldBlock,
-                "Timed out while receiving request",
+                "Timed out while receiving response",
             ));
         }
+        if last_heartbeat_time.elapsed() >= HEARTBEAT_INTERVAL {
+            info!(
+                "send_request(receiving data): heartbeat - still receiving response from {} path='{}' (elapsed: {:?})",
+                addr, request_path, start.elapsed()
+            );
+            last_heartbeat_time = Instant::now();
+        }
     };
 
     // Step 5: decode the HTTP message and return it if it's not an error.