cargo fmt

backend/telemetry_core/src/aggregator/aggregator.rs

@@ -113,8 +113,10 @@ impl Aggregator {
     /// Return a sink that a feed can send messages into to be handled by the aggregator.
     pub fn subscribe_feed(
         &self,
-    ) -> (u64, impl Sink<inner_loop::FromFeedWebsocket, Error = anyhow::Error> + Send + Sync + Unpin + 'static)
-    {
+    ) -> (
+        u64,
+        impl Sink<inner_loop::FromFeedWebsocket, Error = anyhow::Error> + Send + Sync + Unpin + 'static,
+    ) {
         // Assign a unique aggregator-local ID to each connection that subscribes, and pass
         // that along with every message to the aggregator loop:
         let feed_conn_id = self
@@ -125,11 +127,14 @@ impl Aggregator {
 
         // Calling `send` on this Sink requires Unpin. There may be a nicer way than this,
         // but pinning by boxing is the easy solution for now:
-        (feed_conn_id, Box::pin(tx_to_aggregator.with(move |msg| async move {
-            Ok(inner_loop::ToAggregator::FromFeedWebsocket(
-                feed_conn_id.into(),
-                msg,
-            ))
-        })))
+        (
+            feed_conn_id,
+            Box::pin(tx_to_aggregator.with(move |msg| async move {
+                Ok(inner_loop::ToAggregator::FromFeedWebsocket(
+                    feed_conn_id.into(),
+                    msg,
+                ))
+            })),
+        )
     }
 }

backend/telemetry_core/src/aggregator/inner_loop.rs

@@ -447,7 +447,10 @@ impl InnerLoop {
                     .chunks(64)
                     .filter_map(|nodes| {
                         let mut feed_serializer = FeedMessageSerializer::new();
-                        for (node_id, node) in nodes.iter().filter_map(|&(idx, n)| n.as_ref().map(|n| (idx, n))) {
+                        for (node_id, node) in nodes
+                            .iter()
+                            .filter_map(|&(idx, n)| n.as_ref().map(|n| (idx, n)))
+                        {
                             feed_serializer.push(feed_message::AddedNode(node_id, node));
                             feed_serializer.push(feed_message::FinalizedBlock(
                                 node_id,

backend/telemetry_core/src/feed_message.rs

@@ -18,7 +18,6 @@
 //! send to subscribed feeds (browsers).
 
 use serde::Serialize;
-use std::mem;
 
 use crate::state::Node;
 use common::node_types::{
@@ -82,20 +81,6 @@ impl FeedMessageSerializer {
         let _ = to_writer(&mut self.buffer, value);
     }
 
-    /// Return the bytes we've serialized so far and prepare a new buffer. If you're
-    /// finished serializing data, prefer [`FeedMessageSerializer::into_finalized`]
-    pub fn finalize(&mut self) -> Option<bytes::Bytes> {
-        if self.buffer.is_empty() {
-            return None;
-        }
-
-        self.buffer.push(b']');
-
-        let bytes = mem::replace(&mut self.buffer, Vec::with_capacity(BUFCAP));
-
-        Some(bytes.into())
-    }
-
     /// Return the bytes that we've serialized so far, consuming the serializer.
     pub fn into_finalized(mut self) -> Option<bytes::Bytes> {
         if self.buffer.is_empty() {

backend/telemetry_core/src/main.rs

@@ -77,7 +77,7 @@ fn main() {
 
     let worker_threads = match opts.worker_threads {
         0 => num_cpus::get(),
-        n => n
+        n => n,
     };
 
     tokio::runtime::Builder::new_multi_thread()
@@ -308,7 +308,7 @@ async fn handle_feed_websocket_connection<S>(
     mut ws_recv: http_utils::WsReceiver,
     mut tx_to_aggregator: S,
     feed_timeout: u64,
-    _feed_id: u64 // <- can be useful for debugging purposes.
+    _feed_id: u64, // <- can be useful for debugging purposes.
 ) -> (S, http_utils::WsSender)
 where
     S: futures::Sink<FromFeedWebsocket, Error = anyhow::Error> + Unpin + Send + 'static,