chore: clippy fixes

.github/workflows/rust-clippy.yml

@@ -1,7 +1,3 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
 # rust-clippy is a tool that runs a bunch of lints to catch common
 # mistakes in your Rust code and help improve your Rust code.
 # More details at https://github.com/rust-lang/rust-clippy
@@ -18,6 +14,13 @@ on:
   schedule:
     - cron: '29 19 * * 2'
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+
 jobs:
   rust-clippy-analyze:
     name: Run rust-clippy analyzing
@@ -30,23 +33,31 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Install Rust toolchain
-        uses: actions-rs/toolchain@16499b5e05bf2e26879000db0c1d13f7e13fa3af #@v1
+      - uses: actions/cache@v3
+        id: cache-cargo
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-cargo-
+
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
         with:
-          profile: minimal
-          toolchain: stable
-          components: clippy
-          override: true
+          version: "25.1"
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Run rust-clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
 
       - name: Install required cargo
         run: cargo install clippy-sarif sarif-fmt
 
-      - name: Run rust-clippy
-        run:
-          cargo clippy
-          --all-features
-          --message-format=json | clippy-sarif | tee rust-clippy-results.sarif | sarif-fmt
-        continue-on-error: true
+      - name: Run rust-sarif
+        run: cargo clippy --all-features --message-format=json | 
+          clippy-sarif | tee rust-clippy-results.sarif | sarif-fmt
 
       - name: Upload analysis results to GitHub
         uses: github/codeql-action/upload-sarif@v3

.github/workflows/rust-fmt.yml

@@ -0,0 +1,39 @@
+name: rust-fmt analyze
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "master" ]
+  schedule:
+    - cron: '29 19 * * 2'
+
+concurrency:
+  # One build per PR, branch or tag
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  rust-fmt-analyze:
+    name: Run rust-fmt analyzing
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: cargo fmt
+        run: cargo fmt --all -- --check

.github/workflows/rust.yml

@@ -2,30 +2,85 @@ name: Rust
 
 on:
   push:
-    branches: [ "master" ]
+    branches: ["master"]
+    paths-ignore:
+      - "docs/**"
+
   pull_request:
-    branches: [ "master" ]
+    branches: ["master"]
+    paths-ignore:
+      - "docs/**"
 
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  build:
-
+  code-coverage:
     runs-on: ubuntu-latest
     env:
       CARGO_TERM_COLOR: always
     steps:
       - uses: actions/checkout@v4
-      - name: Install Rust
-        run: rustup update stable
+      - name: Install deps
+        run: |
+          sudo apt-get update
+          sudo apt install -y libsoxr-dev libopus-dev libssl-dev libfdk-aac-dev
+
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          version: "25.1"
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
+      - name: Running cargo test
+        run: cargo test --all-features --workspace
       - name: Generate code coverage
         run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }} # not required for public repos
           files: lcov.info
-          fail_ci_if_error: false
+          fail_ci_if_error: false
+  cargo-deny:
+    name: cargo-deny
+
+    # TODO: remove this matrix when https://github.com/EmbarkStudios/cargo-deny/issues/324 is resolved
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - x86_64-unknown-linux-gnu
+          # - x86_64-unknown-linux-musl
+          - aarch64-unknown-linux-gnu
+          # - arm-unknown-linux-gnueabihf
+          # - armv7-unknown-linux-gnueabihf
+          # - mips-unknown-linux-gnu
+          # - mips64-unknown-linux-gnuabi64
+          # - mips64el-unknown-linux-gnuabi64
+          # - mipsel-unknown-linux-gnu
+          # - aarch64-unknown-linux-musl
+          - x86_64-apple-darwin
+          - aarch64-apple-darwin
+          # - x86_64-pc-windows-gnu
+          # - x86_64-pc-windows-msvc
+
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: EmbarkStudios/cargo-deny-action@v1
+        with:
+          command: check
+          log-level: error
+          arguments: --all-features --target ${{ matrix.platform }}

Cargo.toml

@@ -25,4 +25,4 @@ clap = { version = "4.4", features = ["derive", "env"] }
 mockall = "0.12.1"
 num_enum = "0.7.2"
 convert-enum = "0.1.0"
-sans-io-runtime = "0.1.0"
+sans-io-runtime = { version = "0.1.0", default-features = false }

packages/core/identity/src/conn_id.rs

@@ -121,11 +121,7 @@ impl Hash for ConnId {
 impl PartialOrd<Self> for ConnId {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         //compare both session and direction
-        if self.session == other.session {
-            self.direction.partial_cmp(&other.direction)
-        } else {
-            self.session.partial_cmp(&other.session)
-        }
+        Some(self.cmp(other))
     }
 }
 

packages/core/identity/src/node_id.rs

@@ -77,23 +77,23 @@ impl NodeIdType for NodeId {
     fn layer(&self, index: u8) -> u8 {
         assert!(index <= 3);
 
-        (*self >> 8 * index) as u8
+        (*self >> (8 * index)) as u8
     }
 
     fn build(geo1: u8, geo2: u8, group: u8, index: u8) -> Self {
-        ((geo1 as u32) << 8 * 3) | ((geo2 as u32) << 8 * 2) | ((group as u32) << 8) | (index as u32)
+        ((geo1 as u32) << (8 * 3)) | ((geo2 as u32) << (8 * 2)) | ((group as u32) << 8) | (index as u32)
     }
 
     fn build2(zone_id: u16, group: u8, index: u8) -> Self {
         ((zone_id as u32) << 16) | ((group as u32) << 8) | (index as u32)
     }
 
     fn geo1(&self) -> u8 {
-        (*self >> 8 * 3) as u8
+        (*self >> (8 * 3)) as u8
     }
 
     fn geo2(&self) -> u8 {
-        (*self >> 8 * 2) as u8
+        (*self >> (8 * 2)) as u8
     }
 
     fn group(&self) -> u8 {

packages/core/router/src/core/router.rs

@@ -455,8 +455,8 @@ mod tests {
 
             for i in 0..100 {
                 let key: u32 = rand::random();
-                let next_a = router_a.closest_node(key, &vec![]);
-                let next_b = router_b.closest_node(key, &vec![]);
+                let next_a = router_a.closest_node(key, &[]);
+                let next_b = router_b.closest_node(key, &[]);
                 match (next_a, next_b) {
                     (Some(a), Some(b)) => {
                         panic!("Step {}, Wrong with key {} => {:?} {:?}", i, key, a, b);

packages/core/router/src/core/table/metric.rs

@@ -47,9 +47,9 @@ impl Metric {
     pub fn score(&self) -> u32 {
         let based_score = self.latency as u32 + (self.hops.len() as u32 * HOP_PLUS_RTT as u32);
         if self.bandwidth >= BANDWIDTH_LIMIT {
-            return based_score;
+            based_score
         } else {
-            return based_score + BANDWIDTH_SCORE_PENALTY;
+            based_score + BANDWIDTH_SCORE_PENALTY
         }
     }
 

packages/core/router/src/core/table/path.rs

@@ -9,7 +9,7 @@ pub struct Path(pub ConnId, pub Metric);
 
 impl PartialOrd for Path {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.1.partial_cmp(&other.1)
+        Some(self.cmp(other))
     }
 }
 

packages/core/router/src/lib.rs

@@ -21,9 +21,9 @@ impl ServiceBroadcastLevel {
     }
 }
 
-impl Into<u8> for ServiceBroadcastLevel {
-    fn into(self) -> u8 {
-        match self {
+impl From<ServiceBroadcastLevel> for u8 {
+    fn from(val: ServiceBroadcastLevel) -> Self {
+        match val {
             ServiceBroadcastLevel::Global => 0,
             ServiceBroadcastLevel::Geo1 => 1,
             ServiceBroadcastLevel::Geo2 => 2,

packages/network/src/base/control.rs

@@ -38,6 +38,7 @@ pub struct NeighboursControl {
 }
 
 impl NeighboursControl {
+    #[allow(clippy::result_unit_err)]
     pub fn validate(&self, now: u64, auth: &dyn Authorization) -> Result<NeighboursControlCmds, ()> {
         auth.validate(self.from, &self.cmd, &self.signature).ok_or(())?;
         let (ts, cmd) = bincode::DefaultOptions::new().with_limit(1499).deserialize::<(u64, NeighboursControlCmds)>(&self.cmd).map_err(|_| ())?;

packages/network/src/base/feature.rs

@@ -6,9 +6,6 @@ use sans_io_runtime::TaskSwitcherChild;
 
 use super::{Buffer, ConnectionCtx, ConnectionEvent, ServiceId, TransportMsgHeader, Ttl};
 
-///
-///
-
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct NetIncomingMeta {
     pub source: Option<NodeId>,
@@ -126,7 +123,7 @@ pub enum FeatureOutput<UserData, Event, ToWorker> {
     NeighboursDisconnectFrom(NodeId),
 }
 
-impl<'a, UserData, Event, ToWorker> FeatureOutput<UserData, Event, ToWorker> {
+impl<UserData, Event, ToWorker> FeatureOutput<UserData, Event, ToWorker> {
     pub fn into2<UserData2, Event2, ToWorker2>(self) -> FeatureOutput<UserData2, Event2, ToWorker2>
     where
         UserData2: From<UserData>,
@@ -151,12 +148,9 @@ pub struct FeatureContext {
 
 pub trait Feature<UserData, Control, Event, ToController, ToWorker>: TaskSwitcherChild<FeatureOutput<UserData, Event, ToWorker>> {
     fn on_shared_input(&mut self, _ctx: &FeatureContext, _now: u64, _input: FeatureSharedInput);
-    fn on_input<'a>(&mut self, _ctx: &FeatureContext, now_ms: u64, input: FeatureInput<'a, UserData, Control, ToController>);
+    fn on_input(&mut self, _ctx: &FeatureContext, now_ms: u64, input: FeatureInput<'_, UserData, Control, ToController>);
 }
 
-///
-///
-
 pub enum FeatureWorkerInput<UserData, Control, ToWorker> {
     /// First bool is flag for broadcast or not
     FromController(bool, ToWorker),
@@ -184,7 +178,7 @@ pub enum FeatureWorkerOutput<UserData, Control, Event, ToController> {
     TunPkt(Buffer),
 }
 
-impl<'a, UserData, Control, Event, ToController> FeatureWorkerOutput<UserData, Control, Event, ToController> {
+impl<UserData, Control, Event, ToController> FeatureWorkerOutput<UserData, Control, Event, ToController> {
     pub fn into2<UserData2, Control2, Event2, ToController2>(self) -> FeatureWorkerOutput<UserData2, Control2, Event2, ToController2>
     where
         UserData2: From<UserData>,

packages/network/src/base/msg.rs

@@ -80,6 +80,12 @@ pub struct TransportMsgHeader {
     pub from_node: Option<NodeId>,
 }
 
+impl Default for TransportMsgHeader {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl TransportMsgHeader {
     pub fn is_secure(first_byte: u8) -> bool {
         first_byte & 0b0010_0000 != 0
@@ -536,7 +542,7 @@ mod tests {
         assert_eq!(header.feature, 2);
         assert_eq!(header.meta, 3);
         assert_eq!(header.route, RouteRule::Direct);
-        assert_eq!(header.encrypt, true);
+        assert!(header.encrypt);
         assert_eq!(header.from_node, None);
     }
 

packages/network/src/base/secure.rs

@@ -31,11 +31,13 @@ pub trait HandshakeBuilder: Send + Sync {
 #[mockall::automock]
 pub trait HandshakeRequester {
     fn create_public_request(&self) -> Result<Vec<u8>, HandshakeError>;
+    #[allow(clippy::type_complexity)]
     fn process_public_response(&mut self, response: &[u8]) -> Result<(Box<dyn Encryptor>, Box<dyn Decryptor>), HandshakeError>;
 }
 
 #[mockall::automock]
 pub trait HandshakeResponder {
+    #[allow(clippy::type_complexity)]
     fn process_public_request(&mut self, request: &[u8]) -> Result<(Box<dyn Encryptor>, Box<dyn Decryptor>, Vec<u8>), HandshakeError>;
 }
 
@@ -46,7 +48,7 @@ pub enum EncryptionError {
 
 #[mockall::automock]
 pub trait Encryptor: Debug + Send + Sync {
-    fn encrypt<'a>(&mut self, now_ms: u64, data: &mut Buffer) -> Result<(), EncryptionError>;
+    fn encrypt(&mut self, now_ms: u64, data: &mut Buffer) -> Result<(), EncryptionError>;
     fn clone_box(&self) -> Box<dyn Encryptor>;
 }
 
@@ -65,7 +67,7 @@ pub enum DecryptionError {
 
 #[mockall::automock]
 pub trait Decryptor: Debug + Send + Sync {
-    fn decrypt<'a>(&mut self, now_ms: u64, data: &mut Buffer) -> Result<(), DecryptionError>;
+    fn decrypt(&mut self, now_ms: u64, data: &mut Buffer) -> Result<(), DecryptionError>;
     fn clone_box(&self) -> Box<dyn Decryptor>;
 }