Fix clippy warnings

backend/common/src/assign_id.rs

@@ -31,6 +31,17 @@ pub struct AssignId<Id, Details> {
     _id_type: std::marker::PhantomData<Id>,
 }
 
+impl<Id, Details> Default for AssignId<Id, Details>
+where
+    Details: Eq + Hash,
+    Id: From<usize> + Copy,
+    usize: From<Id>,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<Id, Details> AssignId<Id, Details>
 where
     Details: Eq + Hash,
@@ -68,7 +79,7 @@ where
 
     pub fn remove_by_details(&mut self, details: &Details) -> Option<Id> {
         self.mapping
-            .remove_by_right(&details)
+            .remove_by_right(details)
             .map(|(id, _)| id.into())
     }
 

backend/common/src/byte_size.rs

@@ -84,20 +84,20 @@ mod test {
             ("20 kB", 20 * 1000),
             ("20K", 20 * 1000),
             (" 20k", 20 * 1000),
-            ("1MB", 1 * 1000 * 1000),
-            ("1M", 1 * 1000 * 1000),
-            ("1m", 1 * 1000 * 1000),
-            ("1 m", 1 * 1000 * 1000),
-            ("1GB", 1 * 1000 * 1000 * 1000),
-            ("1G", 1 * 1000 * 1000 * 1000),
-            ("1g", 1 * 1000 * 1000 * 1000),
-            ("1KiB", 1 * 1024),
-            ("1Ki", 1 * 1024),
-            ("1MiB", 1 * 1024 * 1024),
-            ("1Mi", 1 * 1024 * 1024),
-            ("1GiB", 1 * 1024 * 1024 * 1024),
-            ("1Gi", 1 * 1024 * 1024 * 1024),
-            (" 1 Gi ", 1 * 1024 * 1024 * 1024),
+            ("1MB", 1000 * 1000),
+            ("1M", 1000 * 1000),
+            ("1m", 1000 * 1000),
+            ("1 m", 1000 * 1000),
+            ("1GB", 1000 * 1000 * 1000),
+            ("1G", 1000 * 1000 * 1000),
+            ("1g", 1000 * 1000 * 1000),
+            ("1KiB", 1024),
+            ("1Ki", 1024),
+            ("1MiB", 1024 * 1024),
+            ("1Mi", 1024 * 1024),
+            ("1GiB", 1024 * 1024 * 1024),
+            ("1Gi", 1024 * 1024 * 1024),
+            (" 1 Gi ", 1024 * 1024 * 1024),
         ];
 
         for (s, expected) in cases {

backend/common/src/dense_map.rs

@@ -23,6 +23,7 @@
 /// Items are keyed by an Id, which can be any type you wish, but
 /// must be convertible to/from a `usize`. This promotes using a
 /// custom Id type to talk about items in the map.
+#[derive(Default)]
 pub struct DenseMap<Id, T> {
     /// List of retired indexes that can be re-used
     retired: Vec<usize>,
@@ -108,6 +109,7 @@ where
             .filter_map(|(id, item)| Some((id.into(), item.as_mut()?)))
     }
 
+    #[allow(clippy::should_implement_trait)]
     pub fn into_iter(self) -> impl Iterator<Item = (Id, T)> {
         self.items
             .into_iter()

backend/common/src/http_utils.rs

@@ -134,7 +134,7 @@ fn generate_websocket_accept_key<'a>(key: &[u8], buf: &'a mut [u8; 32]) -> &'a [
     digest.update(KEY);
     let d = digest.finalize();
 
-    let n = base64::encode_config_slice(&d, base64::STANDARD, buf);
+    let n = base64::encode_config_slice(d, base64::STANDARD, buf);
     &buf[..n]
 }
 

backend/common/src/multi_map_unique.rs

@@ -19,6 +19,7 @@ use std::hash::Hash;
 /// A map where each key can contain multiple values. We enforce that a value
 /// only ever belongs to one key at a time (the latest key it was inserted
 /// against).
+#[derive(Default)]
 pub struct MultiMapUnique<K, V> {
     value_to_key: HashMap<V, K>,
     key_to_values: HashMap<K, HashSet<V>>,

backend/common/src/node_message.rs

@@ -134,7 +134,7 @@ mod tests {
     // know whether things can (de)serialize to bincode or not at runtime without failing unless
     // we test the different types we want to (de)serialize ourselves. We just need to test each
     // type, not each variant.
-    fn bincode_can_serialize_and_deserialize<'de, T>(item: T)
+    fn bincode_can_serialize_and_deserialize<T>(item: T)
     where
         T: Serialize + serde::de::DeserializeOwned,
     {

backend/common/src/node_types.rs

@@ -132,7 +132,7 @@ impl Serialize for NodeIO {
 }
 
 /// Concise block details
-#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq)]
+#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Block {
     pub hash: BlockHash,
     pub height: BlockNumber,
@@ -208,7 +208,7 @@ impl<'de> Deserialize<'de> for NodeLocation {
 }
 
 /// Verbose block details
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct BlockDetails {
     pub block: Block,
     pub block_time: u64,

backend/common/src/rolling_total.rs

@@ -27,11 +27,17 @@ pub struct RollingTotalBuilder<Time: TimeSource = SystemTimeSource> {
     time_source: Time,
 }
 
+impl Default for RollingTotalBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl RollingTotalBuilder {
     /// Build a [`RollingTotal`] struct. By default,
     /// the window_size is 10s, the granularity is 1s,
     /// and system time is used.
-    pub fn new() -> RollingTotalBuilder<SystemTimeSource> {
+    pub fn new() -> Self {
         Self {
             window_size_multiple: 10,
             granularity: Duration::from_secs(1),
@@ -253,11 +259,7 @@ mod test {
         // Regardless of the exact time that's elapsed, we'll end up with buckets that
         // are exactly granularity spacing (or multiples of) apart.
         assert_eq!(
-            rolling_total
-                .averages()
-                .into_iter()
-                .copied()
-                .collect::<Vec<_>>(),
+            rolling_total.averages().iter().copied().collect::<Vec<_>>(),
             vec![
                 (start_time, 1),
                 (start_time + granularity, 2),

backend/common/src/ws_client/connect.rs

@@ -115,7 +115,7 @@ impl Connection {
                 let msg = match message_data {
                     soketto::Data::Binary(_) => Ok(RecvMessage::Binary(data)),
                     soketto::Data::Text(_) => String::from_utf8(data)
-                        .map(|s| RecvMessage::Text(s))
+                        .map(RecvMessage::Text)
                         .map_err(|e| e.into()),
                 };
 
@@ -249,7 +249,7 @@ pub async fn connect(uri: &http::Uri) -> Result<Connection, ConnectError> {
     let socket = may_connect_tls(socket, host, scheme == "https" || scheme == "wss").await?;
 
     // Establish a WS connection:
-    let mut client = Client::new(socket.compat(), host, &path);
+    let mut client = Client::new(socket.compat(), host, path);
     let (ws_to_connection, ws_from_connection) = match client.handshake().await? {
         ServerResponse::Accepted { .. } => client.into_builder().finish(),
         ServerResponse::Redirect { status_code, .. } => {

backend/common/src/ws_client/receiver.rs

@@ -48,7 +48,7 @@ impl Stream for Receiver {
         mut self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Option<Self::Item>> {
-        self.inner.poll_next_unpin(cx).map_err(|e| e.into())
+        self.inner.poll_next_unpin(cx)
     }
 }
 
@@ -68,4 +68,8 @@ impl RecvMessage {
             RecvMessage::Text(s) => s.len(),
         }
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
 }

backend/telemetry_core/benches/subscribe.rs

@@ -103,7 +103,7 @@ pub fn benchmark_subscribe_speed(c: &mut Criterion) {
                 let start = Instant::now();
                 loop {
                     let msgs = feeds[0].1.recv_feed_messages_once().await.unwrap();
-                    if msgs.iter().find(|&m| m == &finished).is_some() {
+                    if msgs.iter().any(|m| m == &finished) {
                         break;
                     }
                 }

backend/telemetry_core/src/aggregator/inner_loop.rs

@@ -55,13 +55,13 @@ pub enum FromShardWebsocket {
     Add {
         local_id: ShardNodeId,
         ip: std::net::IpAddr,
-        node: common::node_types::NodeDetails,
+        node: Box<common::node_types::NodeDetails>,
         genesis_hash: common::node_types::BlockHash,
     },
     /// Update/pass through details about a node.
     Update {
         local_id: ShardNodeId,
-        payload: node_message::Payload,
+        payload: Box<node_message::Payload>,
     },
     /// Tell the aggregator that a node has been removed when it disconnects.
     Remove { local_id: ShardNodeId },
@@ -139,7 +139,7 @@ impl FromStr for FromFeedWebsocket {
             "subscribe" => Ok(FromFeedWebsocket::Subscribe {
                 chain: value.parse()?,
             }),
-            _ => return Err(anyhow::anyhow!("Command {} not recognised", cmd)),
+            _ => Err(anyhow::anyhow!("Command {} not recognised", cmd)),
         }
     }
 }
@@ -235,16 +235,16 @@ impl InnerLoop {
             // ignore node updates if we have too many messages to handle, in an attempt
             // to reduce the queue length back to something reasonable, lest it get out of
             // control and start consuming a load of memory.
-            if metered_tx.len() > max_queue_len {
-                if matches!(
+            if metered_tx.len() > max_queue_len
+                && matches!(
                     msg,
                     ToAggregator::FromShardWebsocket(.., FromShardWebsocket::Update { .. })
-                ) {
-                    // Note: this wraps on overflow (which is probably the best
-                    // behaviour for graphing it anyway)
-                    dropped_messages.fetch_add(1, Ordering::Relaxed);
-                    continue;
-                }
+                )
+            {
+                // Note: this wraps on overflow (which is probably the best
+                // behaviour for graphing it anyway)
+                dropped_messages.fetch_add(1, Ordering::Relaxed);
+                continue;
             }
 
             if let Err(e) = metered_tx.send(msg) {
@@ -327,7 +327,7 @@ impl InnerLoop {
             } => {
                 // Conditionally modify the node's details to include the IP address.
                 node.ip = self.expose_node_ips.then_some(ip.to_string().into());
-                match self.node_state.add_node(genesis_hash, node) {
+                match self.node_state.add_node(genesis_hash, *node) {
                     state::AddNodeResult::ChainOnDenyList => {
                         if let Some(shard_conn) = self.shard_channels.get_mut(&shard_conn_id) {
                             let _ = shard_conn.send(ToShardWebsocket::Mute {
@@ -359,7 +359,7 @@ impl InnerLoop {
                         let mut feed_messages_for_chain = FeedMessageSerializer::new();
                         feed_messages_for_chain.push(feed_message::AddedNode(
                             node_id.get_chain_node_id().into(),
-                            &details.node,
+                            details.node,
                         ));
                         self.finalize_and_broadcast_to_chain_feeds(
                             &genesis_hash,
@@ -411,7 +411,7 @@ impl InnerLoop {
 
                 let mut feed_message_serializer = FeedMessageSerializer::new();
                 self.node_state
-                    .update_node(node_id, payload, &mut feed_message_serializer);
+                    .update_node(node_id, *payload, &mut feed_message_serializer);
 
                 if let Some(chain) = self.node_state.get_chain_by_node_id(node_id) {
                     let genesis_hash = chain.genesis_hash();

backend/telemetry_core/src/aggregator/mod.rs

@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
+#[allow(clippy::module_inception)]
 mod aggregator;
 mod aggregator_set;
 mod inner_loop;

backend/telemetry_core/src/find_location.rs

@@ -43,7 +43,7 @@ where
     cache.insert(
         Ipv4Addr::new(127, 0, 0, 1).into(),
         Arc::new(NodeLocation {
-            latitude: 52.516_6667,
+            latitude: 52.516_666,
             longitude: 13.4,
             city: "Berlin".into(),
         }),
@@ -103,7 +103,7 @@ impl Locator {
             return cached_loc;
         }
 
-        let City { city, location, .. } = self.city.lookup(ip.into()).ok()?;
+        let City { city, location, .. } = self.city.lookup(ip).ok()?;
         let city = city
             .as_ref()?
             .names

backend/telemetry_core/src/main.rs

@@ -279,12 +279,15 @@ where
                     genesis_hash,
                 } => FromShardWebsocket::Add {
                     ip,
-                    node,
+                    node: Box::new(node),
                     genesis_hash,
                     local_id,
                 },
                 internal_messages::FromShardAggregator::UpdateNode { payload, local_id } => {
-                    FromShardWebsocket::Update { local_id, payload }
+                    FromShardWebsocket::Update {
+                        local_id,
+                        payload: Box::new(payload),
+                    }
                 }
                 internal_messages::FromShardAggregator::RemoveNode { local_id } => {
                     FromShardWebsocket::Remove { local_id }
@@ -525,34 +528,34 @@ async fn return_prometheus_metrics(aggregator: AggregatorSet) -> Response<hyper:
     use std::fmt::Write;
     let mut s = String::new();
     for (idx, m) in metrics.iter().enumerate() {
-        let _ = write!(
+        let _ = writeln!(
             &mut s,
-            "telemetry_core_connected_feeds{{aggregator=\"{}\"}} {} {}\n",
+            "telemetry_core_connected_feeds{{aggregator=\"{}\"}} {} {}",
             idx, m.connected_feeds, m.timestamp_unix_ms
         );
-        let _ = write!(
+        let _ = writeln!(
             &mut s,
-            "telemetry_core_connected_nodes{{aggregator=\"{}\"}} {} {}\n",
+            "telemetry_core_connected_nodes{{aggregator=\"{}\"}} {} {}",
             idx, m.connected_nodes, m.timestamp_unix_ms
         );
-        let _ = write!(
+        let _ = writeln!(
             &mut s,
-            "telemetry_core_connected_shards{{aggregator=\"{}\"}} {} {}\n",
+            "telemetry_core_connected_shards{{aggregator=\"{}\"}} {} {}",
             idx, m.connected_shards, m.timestamp_unix_ms
         );
-        let _ = write!(
+        let _ = writeln!(
             &mut s,
-            "telemetry_core_chains_subscribed_to{{aggregator=\"{}\"}} {} {}\n",
+            "telemetry_core_chains_subscribed_to{{aggregator=\"{}\"}} {} {}",
             idx, m.chains_subscribed_to, m.timestamp_unix_ms
         );
-        let _ = write!(
+        let _ = writeln!(
             &mut s,
-            "telemetry_core_subscribed_feeds{{aggregator=\"{}\"}} {} {}\n",
+            "telemetry_core_subscribed_feeds{{aggregator=\"{}\"}} {} {}",
             idx, m.subscribed_feeds, m.timestamp_unix_ms
         );
-        let _ = write!(
+        let _ = writeln!(
             &mut s,
-            "telemetry_core_total_messages_to_feeds{{aggregator=\"{}\"}} {} {}\n",
+            "telemetry_core_total_messages_to_feeds{{aggregator=\"{}\"}} {} {}",
             idx, m.total_messages_to_feeds, m.timestamp_unix_ms
         );
         let _ = write!(