🔧 Rust fmt (#1166)

Author: maxgttph

.github/workflows/clippy.yml

@@ -28,3 +28,7 @@ jobs:
           deny: warnings
           token: ${{ secrets.GITHUB_TOKEN }}
           options: "--all-targets --all-features"
+      - name: Run rustfmt
+        run: cargo fmt --all -- --check
+      - name: Run cargo check
+        run: cargo check --workspace

crates/hyle-net/src/metrics.rs

@@ -35,7 +35,7 @@ impl P2PMetrics {
             message_closed: build!(my_meter, counter, "message_closed"),
             handshake_connection: build!(my_meter, counter, "handshake_connection"),
             handshake_hello: build!(my_meter, counter, "handshake_hello"),
-            handshake_verack: build!(my_meter, counter, "handshake_verack")
+            handshake_verack: build!(my_meter, counter, "handshake_verack"),
         }
     }
 
@@ -44,42 +44,102 @@ impl P2PMetrics {
     }
 
     pub fn message_received(&self, from: String, canal: Canal) {
-        self.message.add(1, &[KeyValue::new("from", from), KeyValue::new("canal", canal.to_string())]);
+        self.message.add(
+            1,
+            &[
+                KeyValue::new("from", from),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        );
     }
 
     pub fn message_error(&self, from: String, canal: Canal) {
-        self.message_error.add(1, &[KeyValue::new("from", from), KeyValue::new("canal", canal.to_string())]);
+        self.message_error.add(
+            1,
+            &[
+                KeyValue::new("from", from),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        );
     }
-    
+
     pub fn message_closed(&self, from: String, canal: Canal) {
-        self.message_closed.add(1, &[KeyValue::new("from", from), KeyValue::new("canal", canal.to_string())]);
+        self.message_closed.add(
+            1,
+            &[
+                KeyValue::new("from", from),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        );
     }
 
     pub fn ping(&self, peer: String, canal: Canal) {
-        self.ping.add(1, &[KeyValue::new("peer", peer), KeyValue::new("canal", canal.to_string())]);
+        self.ping.add(
+            1,
+            &[
+                KeyValue::new("peer", peer),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        );
     }
 
     pub fn message_emitted(&self, to: String, canal: Canal) {
-        self.message.add(1, &[KeyValue::new("to", to), KeyValue::new("canal", canal.to_string())]);
+        self.message.add(
+            1,
+            &[
+                KeyValue::new("to", to),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        );
     }
 
     pub fn handshake_connection_emitted(&self, to: String, canal: Canal) {
-        self.handshake_connection.add(1, &[KeyValue::new("to", to), KeyValue::new("canal", canal.to_string())])
+        self.handshake_connection.add(
+            1,
+            &[
+                KeyValue::new("to", to),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        )
     }
-    
+
     pub fn handshake_hello_emitted(&self, to: String, canal: Canal) {
-        self.handshake_hello.add(1, &[KeyValue::new("to", to), KeyValue::new("canal", canal.to_string())])
+        self.handshake_hello.add(
+            1,
+            &[
+                KeyValue::new("to", to),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        )
     }
-   
+
     pub fn handshake_hello_received(&self, from: String, canal: Canal) {
-        self.handshake_hello.add(1, &[KeyValue::new("from", from), KeyValue::new("canal", canal.to_string())])
+        self.handshake_hello.add(
+            1,
+            &[
+                KeyValue::new("from", from),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        )
     }
 
     pub fn handshake_verack_emitted(&self, to: String, canal: Canal) {
-        self.handshake_verack.add(1, &[KeyValue::new("to", to), KeyValue::new("canal", canal.to_string())])
+        self.handshake_verack.add(
+            1,
+            &[
+                KeyValue::new("to", to),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        )
     }
 
     pub fn handshake_verack_received(&self, from: String, canal: Canal) {
-        self.handshake_verack.add(1, &[KeyValue::new("from", from), KeyValue::new("canal", canal.to_string())])
+        self.handshake_verack.add(
+            1,
+            &[
+                KeyValue::new("from", from),
+                KeyValue::new("canal", canal.to_string()),
+            ],
+        )
     }
 }

src/mempool/block_construction.rs

@@ -52,13 +52,11 @@ impl super::Mempool {
                 .and_then(|f| f.iter().find(|el| &el.0 == lane_id))
                 .map(|el| &el.1);
 
-            let mut entries = Box::pin(self
-                .lanes
-                .get_entries_between_hashes(
-                    lane_id, // get start hash for validator
-                    from_hash.cloned(),
-                    Some(to_hash.clone()),
-                ));
+            let mut entries = Box::pin(self.lanes.get_entries_between_hashes(
+                lane_id, // get start hash for validator
+                from_hash.cloned(),
+                Some(to_hash.clone()),
+            ));
 
             let mut dps = vec![];
 
@@ -68,7 +66,7 @@ impl super::Mempool {
                     buc.from, buc.ccp.consensus_proposal.cut
                 ))?;
 
-                dps.push(dp);                    
+                dps.push(dp);
             }
 
             result.push((lane_id.clone(), dps));
@@ -226,7 +224,9 @@ pub mod test {
         let key = ctx.validator_pubkey().clone();
         ctx.add_trusted_validator(&key);
 
-        let cut = ctx.process_cut_with_dp(&key, &dp_hash, cumul_size, 1).await?;
+        let cut = ctx
+            .process_cut_with_dp(&key, &dp_hash, cumul_size, 1)
+            .await?;
 
         assert_chanmsg_matches!(
             ctx.mempool_event_receiver,
@@ -267,22 +267,27 @@ pub mod test {
                 .expect_err("Should not build signed block");
         };
 
-        ctx.process_cut_with_dp(&ctx_key, &dp2_hash, dp2_size, 2).await?;
+        ctx.process_cut_with_dp(&ctx_key, &dp2_hash, dp2_size, 2)
+            .await?;
         expect_nothing(&mut ctx);
 
-        ctx.process_cut_with_dp(&ctx_key, &dp5_hash, dp5_size, 5).await?;
+        ctx.process_cut_with_dp(&ctx_key, &dp5_hash, dp5_size, 5)
+            .await?;
         expect_nothing(&mut ctx);
 
         // Process it twice to check idempotency
-        ctx.process_cut_with_dp(&ctx_key, &dp5_hash, dp5_size, 5).await?;
+        ctx.process_cut_with_dp(&ctx_key, &dp5_hash, dp5_size, 5)
+            .await?;
         expect_nothing(&mut ctx);
 
         // Process the old one again as well
-        ctx.process_cut_with_dp(&ctx_key, &dp2_hash, dp2_size, 2).await?;
+        ctx.process_cut_with_dp(&ctx_key, &dp2_hash, dp2_size, 2)
+            .await?;
         expect_nothing(&mut ctx);
 
         // Finally process two consecutive ones
-        ctx.process_cut_with_dp(&ctx_key, &dp6_hash, dp6_size, 6).await?;
+        ctx.process_cut_with_dp(&ctx_key, &dp6_hash, dp6_size, 6)
+            .await?;
 
         assert_chanmsg_matches!(
             ctx.mempool_event_receiver,
@@ -338,7 +343,8 @@ pub mod test {
                     },
                     certificate: AggregateSignature::default(),
                 },
-            )).await?;
+            ))
+            .await?;
 
         // We've received consecutive blocks so start building
         assert_chanmsg_matches!(
@@ -381,7 +387,8 @@ pub mod test {
                     },
                     certificate: AggregateSignature::default(),
                 },
-            )).await?;
+            ))
+            .await?;
 
         // We don't have the data so we still don't send anything.
         ctx.mempool_event_receiver
@@ -436,38 +443,44 @@ pub mod test {
 
         // Receive the two DPs.
 
-        ctx.mempool.on_sync_reply(
-            &ctx.validator_pubkey().clone(),
-            vec![(
-                LaneEntryMetadata {
-                    parent_data_proposal_hash: dp1.parent_data_proposal_hash.clone(),
-                    cumul_size: dp1_size,
-                    signatures: vec![ctx
-                        .mempool
-                        .crypto
-                        .sign((dp1_hash, dp1_size))
-                        .expect("should sign")],
-                },
-                dp1.clone(),
-            )],
-        ).await?;
+        ctx.mempool
+            .on_sync_reply(
+                &ctx.validator_pubkey().clone(),
+                vec![(
+                    LaneEntryMetadata {
+                        parent_data_proposal_hash: dp1.parent_data_proposal_hash.clone(),
+                        cumul_size: dp1_size,
+                        signatures: vec![ctx
+                            .mempool
+                            .crypto
+                            .sign((dp1_hash, dp1_size))
+                            .expect("should sign")],
+                    },
+                    dp1.clone(),
+                )],
+            )
+            .await?;
 
         // We don't have the data so we still don't send anything.
         ctx.mempool_event_receiver
             .try_recv()
             .expect_err("Should not build signed block");
 
-        ctx.mempool.on_sync_reply(
-            &crypto2.validator_pubkey().clone(),
-            vec![(
-                LaneEntryMetadata {
-                    parent_data_proposal_hash: dp1b.parent_data_proposal_hash.clone(),
-                    cumul_size: dp1b_size,
-                    signatures: vec![crypto2.sign((dp1b_hash, dp1b_size)).expect("should sign")],
-                },
-                dp1b.clone(),
-            )],
-        ).await?;
+        ctx.mempool
+            .on_sync_reply(
+                &crypto2.validator_pubkey().clone(),
+                vec![(
+                    LaneEntryMetadata {
+                        parent_data_proposal_hash: dp1b.parent_data_proposal_hash.clone(),
+                        cumul_size: dp1b_size,
+                        signatures: vec![crypto2
+                            .sign((dp1b_hash, dp1b_size))
+                            .expect("should sign")],
+                    },
+                    dp1b.clone(),
+                )],
+            )
+            .await?;
 
         assert_chanmsg_matches!(
             ctx.mempool_event_receiver,

src/mempool/own_lane.rs

@@ -94,7 +94,8 @@ impl super::Mempool {
 
         // TODO: when we have a smarter system, we should probably not trigger this here
         // to make the event loop more efficient.
-        self.disseminate_data_proposals(Some(data_proposal_hash)).await
+        self.disseminate_data_proposals(Some(data_proposal_hash))
+            .await
     }
 
     /// If only_dp_with_hash is Some, only disseminate the DP with the specified hash. If None, disseminate any pending DPs.
@@ -113,11 +114,10 @@ impl super::Mempool {
         // Check for each pending DataProposal if it has enough signatures
         let cloned_lanes = self.lanes.clone();
         let own_lane_id = self.own_lane_id();
-        let mut entries_stream = Box::pin(cloned_lanes
-            .get_pending_entries_in_lane(&own_lane_id, last_cut));
+        let mut entries_stream =
+            Box::pin(cloned_lanes.get_pending_entries_in_lane(&own_lane_id, last_cut));
 
         while let Some(stream_entry) = entries_stream.next().await {
-
             let (entry_metadata, dp_hash) = stream_entry?;
             // If only_dp_with_hash is Some, we only disseminate that one, skip all others.
             if let Some(ref only_dp_with_hash) = only_dp_with_hash {
@@ -543,9 +543,11 @@ pub mod test {
         let signed_msg2 = create_data_vote(&crypto2, data_proposal.hashed(), size)?;
         let signed_msg3 = create_data_vote(&crypto3, data_proposal.hashed(), size)?;
         ctx.mempool
-            .handle_net_message(crypto2.sign_msg_with_header(signed_msg2)?).await?;
+            .handle_net_message(crypto2.sign_msg_with_header(signed_msg2)?)
+            .await?;
         ctx.mempool
-            .handle_net_message(crypto3.sign_msg_with_header(signed_msg3)?).await?;
+            .handle_net_message(crypto3.sign_msg_with_header(signed_msg3)?)
+            .await?;
 
         // Assert that PoDAUpdate message is broadcasted
         match ctx.assert_broadcast("PoDAUpdate").await.msg {