chore(rust-version): update Rust version and fix Clippy lints (#28)

Author: nabil-Tounarti

.github/workflows/ci.yaml

@@ -8,7 +8,7 @@ jobs:
   build-and-test:
     uses: iExecBlockchainComputing/github-actions-workflows/.github/workflows/[email protected]
     with:
-      rust-version: '1.85.0'
+      rust-version: '1.88.0'
       working-directory: "."
       enable-cache: true
       publish-crates-io: false

src/api/worker_api.rs

@@ -89,7 +89,7 @@ impl WorkerApiClient {
         )
         .unwrap_or_else(|_| DEFAULT_WORKER_HOST.to_string());
 
-        let base_url = format!("http://{}", &worker_host);
+        let base_url = format!("http://{worker_host}");
         Self::new(&base_url)
     }
 
@@ -129,7 +129,7 @@ impl WorkerApiClient {
     ///     &exit_message,
     /// ) {
     ///     Ok(()) => println!("Exit cause reported successfully"),
-    ///     Err(error) => eprintln!("Failed to report exit cause: {}", error),
+    ///     Err(error) => eprintln!("Failed to report exit cause: {error}"),
     /// }
     /// ```
     pub fn send_exit_cause_for_pre_compute_stage(
@@ -138,7 +138,7 @@ impl WorkerApiClient {
         chain_task_id: &str,
         exit_cause: &ExitMessage,
     ) -> Result<(), ReplicateStatusCause> {
-        let url = format!("{}/compute/pre/{}/exit", self.base_url, chain_task_id);
+        let url = format!("{}/compute/pre/{chain_task_id}/exit", self.base_url);
         match self
             .client
             .post(&url)
@@ -152,18 +152,12 @@ impl WorkerApiClient {
                     Ok(())
                 } else {
                     let body = resp.text().unwrap_or_default();
-                    error!(
-                        "Failed to send exit cause: [status:{}, body:{}]",
-                        status, body
-                    );
+                    error!("Failed to send exit cause: [status:{status}, body:{body}]");
                     Err(ReplicateStatusCause::PreComputeFailedUnknownIssue)
                 }
             }
             Err(err) => {
-                error!(
-                    "HTTP request failed when sending exit cause to {}: {:?}",
-                    url, err
-                );
+                error!("HTTP request failed when sending exit cause to {url}: {err:?}");
                 Err(ReplicateStatusCause::PreComputeFailedUnknownIssue)
             }
         }
@@ -224,7 +218,7 @@ mod tests {
     fn should_get_worker_api_client_without_env_var() {
         temp_env::with_vars_unset(vec![WorkerHostEnvVar.name()], || {
             let client = WorkerApiClient::from_env();
-            assert_eq!(client.base_url, format!("http://{}", DEFAULT_WORKER_HOST));
+            assert_eq!(client.base_url, format!("http://{DEFAULT_WORKER_HOST}"));
         });
     }
     // endregion
@@ -243,7 +237,7 @@ mod tests {
         });
 
         Mock::given(method("POST"))
-            .and(path(format!("/compute/pre/{}/exit", CHAIN_TASK_ID)))
+            .and(path(format!("/compute/pre/{CHAIN_TASK_ID}/exit")))
             .and(header("Authorization", CHALLENGE))
             .and(body_json(&expected_body))
             .respond_with(ResponseTemplate::new(200))
@@ -274,7 +268,7 @@ mod tests {
         let server_url = mock_server.uri();
 
         Mock::given(method("POST"))
-            .and(path(format!("/compute/pre/{}/exit", CHAIN_TASK_ID)))
+            .and(path(format!("/compute/pre/{CHAIN_TASK_ID}/exit")))
             .respond_with(ResponseTemplate::new(503).set_body_string("Service Unavailable"))
             .expect(1)
             .mount(&mock_server)

src/compute/app_runner.rs

@@ -48,10 +48,7 @@ pub fn start_with_app<A: PreComputeAppTrait>(pre_compute_app: &mut A) -> ExitMod
         match get_env_var_or_error(IexecTaskId, ReplicateStatusCause::PreComputeTaskIdMissing) {
             Ok(id) => id,
             Err(e) => {
-                error!(
-                    "TEE pre-compute cannot proceed without taskID context: {:?}",
-                    e
-                );
+                error!("TEE pre-compute cannot proceed without taskID context: {e:?}");
                 return ExitMode::InitializationFailure;
             }
         };
@@ -62,17 +59,14 @@ pub fn start_with_app<A: PreComputeAppTrait>(pre_compute_app: &mut A) -> ExitMod
             return ExitMode::Success;
         }
         Err(exit_cause) => {
-            error!(
-                "TEE pre-compute failed with known exit cause [{:?}]",
-                exit_cause
-            );
+            error!("TEE pre-compute failed with known exit cause [{exit_cause:?}]");
         }
     }
 
     let authorization = match get_challenge(&chain_task_id) {
         Ok(auth) => auth,
         Err(_) => {
-            error!("Failed to sign exitCause message [{:?}]", exit_cause);
+            error!("Failed to sign exitCause message [{exit_cause:?}]");
             return ExitMode::UnreportedFailure;
         }
     };
@@ -88,7 +82,7 @@ pub fn start_with_app<A: PreComputeAppTrait>(pre_compute_app: &mut A) -> ExitMod
     ) {
         Ok(_) => ExitMode::ReportedFailure,
         Err(_) => {
-            error!("Failed to report exitCause [{:?}]", exit_cause);
+            error!("Failed to report exitCause [{exit_cause:?}]");
             ExitMode::UnreportedFailure
         }
     }
@@ -197,7 +191,7 @@ mod pre_compute_start_with_app_tests {
         let mock_server = MockServer::start().await;
 
         Mock::given(method("POST"))
-            .and(path(format!("/compute/pre/{}/exit", CHAIN_TASK_ID)))
+            .and(path(format!("/compute/pre/{CHAIN_TASK_ID}/exit")))
             .respond_with(ResponseTemplate::new(500))
             .mount(&mock_server)
             .await;
@@ -243,7 +237,7 @@ mod pre_compute_start_with_app_tests {
 
         // Mock the worker API to return success
         Mock::given(method("POST"))
-            .and(path(format!("/compute/pre/{}/exit", CHAIN_TASK_ID)))
+            .and(path(format!("/compute/pre/{CHAIN_TASK_ID}/exit")))
             .and(body_json(expected_exit_message_payload))
             .respond_with(ResponseTemplate::new(200))
             .mount(&mock_server)

src/compute/pre_compute_app.rs

@@ -91,19 +91,13 @@ impl PreComputeAppTrait for PreComputeApp {
 
         let chain_task_id = self.chain_task_id.as_deref().unwrap_or("unknown");
 
-        info!(
-            "Checking output folder [chainTaskId:{}, path:{}]",
-            chain_task_id, output_dir
-        );
+        info!("Checking output folder [chainTaskId:{chain_task_id}, path:{output_dir}]");
 
         if Path::new(&output_dir).is_dir() {
             return Ok(());
         }
 
-        error!(
-            "Output folder not found [chainTaskId:{}, path:{}]",
-            chain_task_id, output_dir
-        );
+        error!("Output folder not found [chainTaskId:{chain_task_id}, path:{output_dir}]");
 
         Err(ReplicateStatusCause::PreComputeOutputFolderNotFound)
     }
@@ -140,10 +134,7 @@ impl PreComputeAppTrait for PreComputeApp {
         let chain_task_id = self.chain_task_id.as_ref().unwrap();
 
         for url in &args.input_files {
-            info!(
-                "Downloading input file [chainTaskId: {}, url: {}]",
-                chain_task_id, url
-            );
+            info!("Downloading input file [chainTaskId:{chain_task_id}, url:{url}]");
 
             let filename = sha256(url.to_string());
             if download_file(url, &args.output_dir, &filename).is_none() {
@@ -176,20 +167,19 @@ impl PreComputeAppTrait for PreComputeApp {
         let encrypted_dataset_url = args.encrypted_dataset_url.as_ref().unwrap();
 
         info!(
-            "Downloading encrypted dataset file [chainTaskId: {}, url: {}]",
-            chain_task_id, encrypted_dataset_url
+            "Downloading encrypted dataset file [chainTaskId:{chain_task_id}, url:{encrypted_dataset_url}]",
         );
 
         let encrypted_content = if is_multi_address(encrypted_dataset_url) {
             IPFS_GATEWAYS.iter().find_map(|gateway| {
-                let full_url = format!("{}{}", gateway, encrypted_dataset_url);
-                info!("Attempting to download dataset from {}", full_url);
+                let full_url = format!("{gateway}{encrypted_dataset_url}");
+                info!("Attempting to download dataset from {full_url}");
 
                 if let Some(content) = download_from_url(&full_url) {
-                    info!("Successfully downloaded from {}", full_url);
+                    info!("Successfully downloaded from {full_url}");
                     Some(content)
                 } else {
-                    info!("Failed to download from {}", full_url);
+                    info!("Failed to download from {full_url}");
                     None
                 }
             })
@@ -198,10 +188,7 @@ impl PreComputeAppTrait for PreComputeApp {
         }
         .ok_or(ReplicateStatusCause::PreComputeDatasetDownloadFailed)?;
 
-        info!(
-            "Checking encrypted dataset checksum [chainTaskId: {}]",
-            chain_task_id
-        );
+        info!("Checking encrypted dataset checksum [chainTaskId:{chain_task_id}]");
         let expected_checksum = args
             .encrypted_dataset_checksum
             .as_ref()
@@ -210,8 +197,7 @@ impl PreComputeAppTrait for PreComputeApp {
 
         if actual_checksum != *expected_checksum {
             error!(
-                "Invalid dataset checksum [chainTaskId: {}, expected: {}, actual: {}]",
-                chain_task_id, expected_checksum, actual_checksum
+                "Invalid dataset checksum [chainTaskId:{chain_task_id}, expected:{expected_checksum}, actual:{actual_checksum}]"
             );
             return Err(ReplicateStatusCause::PreComputeInvalidDatasetChecksum);
         }
@@ -303,15 +289,14 @@ impl PreComputeAppTrait for PreComputeApp {
         path.push(plain_dataset_filename);
 
         info!(
-            "Saving plain dataset file [chain_task_id:{}, path:{}]",
-            chain_task_id,
+            "Saving plain dataset file [chain_task_id:{chain_task_id}, path:{}]",
             path.display()
         );
 
         write_file(
             plain_dataset,
             &path,
-            &format!("chainTaskId:{}", chain_task_id),
+            &format!("chainTaskId:{chain_task_id}"),
         )
         .map_err(|_| ReplicateStatusCause::PreComputeSavingPlainDatasetFailed)
     }

src/compute/pre_compute_args.rs

@@ -154,7 +154,7 @@ mod tests {
         for i in 1..=count {
             vars.insert(
                 IexecInputFileUrlPrefix(i).name(),
-                format!("https://input-{}.txt", i),
+                format!("https://input-{i}.txt"),
             );
         }
         vars

src/compute/signer.rs

@@ -33,8 +33,8 @@ use alloy_signer_local::PrivateKeySigner;
 /// let private_key = "0xdd3b993ec21c71c1f6d63a5240850e0d4d8dd83ff70d29e49247958548c1d479";
 ///
 /// match sign_enclave_challenge(message_hash, private_key) {
-///     Ok(signature) => println!("Signature: {}", signature),
-///     Err(e) => eprintln!("Error: {:?}", e),
+///     Ok(signature) => println!("Signature: {signature}"),
+///     Err(e) => eprintln!("Error: {e:?}"),
 /// }
 /// ```
 pub fn sign_enclave_challenge(
@@ -89,8 +89,8 @@ pub fn sign_enclave_challenge(
 /// let chain_task_id = "0x123456789abcdef";
 ///
 /// match challenge(chain_task_id) {
-///     Ok(signature) => println!("Challenge signature: {}", signature),
-///     Err(e) => eprintln!("Error generating challenge: {:?}", e),
+///     Ok(signature) => println!("Challenge signature: {signature}"),
+///     Err(e) => eprintln!("Error generating challenge: {e:?}"),
 /// }
 /// ```
 pub fn get_challenge(chain_task_id: &str) -> Result<String, ReplicateStatusCause> {

src/compute/utils/env_utils.rs

@@ -28,7 +28,7 @@ impl TeeSessionEnvironmentVariable {
             TeeSessionEnvironmentVariable::IexecDatasetKey => "IEXEC_DATASET_KEY".to_string(),
             TeeSessionEnvironmentVariable::IexecDatasetUrl => "IEXEC_DATASET_URL".to_string(),
             TeeSessionEnvironmentVariable::IexecInputFileUrlPrefix(index) => {
-                format!("IEXEC_INPUT_FILE_URL_{}", index)
+                format!("IEXEC_INPUT_FILE_URL_{index}")
             }
             TeeSessionEnvironmentVariable::IexecInputFilesNumber => {
                 "IEXEC_INPUT_FILES_NUMBER".to_string()

src/compute/utils/file_utils.rs

@@ -32,16 +32,14 @@ pub fn write_file(content: &[u8], file_path: &Path, context: &str) -> Result<(),
     match fs::write(file_path, content) {
         Ok(_) => {
             info!(
-                "File written successfully [{}, path:{}]",
-                context,
+                "File written successfully [{context}, path:{}]",
                 file_path.display()
             );
             Ok(())
         }
         Err(_) => {
             error!(
-                "Failed to write file [{}, path:{}]",
-                context,
+                "Failed to write file [{context}, path:{}]",
                 file_path.display()
             );
             Err(())
@@ -82,28 +80,22 @@ pub fn write_file(content: &[u8], file_path: &Path, context: &str) -> Result<(),
 /// - The downloaded content is fully loaded into memory before being written to disk.
 pub fn download_file(url: &str, parent_dir: &str, filename: &str) -> Option<PathBuf> {
     if url.is_empty() {
-        error!("Invalid file url [url:{}]", url);
+        error!("Invalid file url [url:{url}]");
         return None;
     }
     if parent_dir.is_empty() {
-        error!(
-            "Invalid parent folder path [url:{}, parent_dir:{}]",
-            url, parent_dir
-        );
+        error!("Invalid parent folder path [url:{url}, parent_dir:{parent_dir}]");
         return None;
     }
     if filename.is_empty() {
-        error!(
-            "Invalid output filename [url:{}, parent_dir:{}, filename:{}]",
-            url, parent_dir, filename
-        );
+        error!("Invalid output filename [url:{url}, parent_dir:{parent_dir}, filename:{filename}]");
         return None;
     }
 
     let bytes = match download_from_url(url) {
         Some(b) => b,
         None => {
-            error!("Failed to download file [url:{}]", url);
+            error!("Failed to download file [url:{url}]");
             return None;
         }
     };
@@ -112,16 +104,13 @@ pub fn download_file(url: &str, parent_dir: &str, filename: &str) -> Option<Path
     let parent_existed = parent_path.exists();
 
     if !parent_existed && fs::create_dir_all(parent_path).is_err() {
-        error!(
-            "Failed to create parent folder [url:{}, parent_dir:{}]",
-            url, parent_dir
-        );
+        error!("Failed to create parent folder [url:{url}, parent_dir:{parent_dir}]");
         return None;
     }
 
     let file_path = parent_path.join(filename);
 
-    if write_file(&bytes, &file_path, &format!("url:{}", url)).is_ok() {
+    if write_file(&bytes, &file_path, &format!("url:{url}")).is_ok() {
         Some(file_path)
     } else {
         if !parent_existed {
@@ -175,18 +164,18 @@ pub fn download_from_url(url: &str) -> Option<Vec<u8>> {
         return None;
     }
 
-    info!("Attempting to download from {}", url);
+    info!("Attempting to download from {url}");
 
     match get(url)
         .and_then(|response| response.error_for_status())
         .and_then(|response| response.bytes())
     {
         Ok(bytes) => {
-            info!("Successfully downloaded {} bytes from {}", bytes.len(), url);
+            info!("Successfully downloaded {} bytes from {url}", bytes.len());
             Some(bytes.to_vec())
         }
         Err(e) => {
-            error!("Failed to download from {}: {}", url, e);
+            error!("Failed to download from {url}: {e}");
             None
         }
     }
@@ -331,7 +320,7 @@ mod tests {
         });
 
         let server_uri = mock_server.uri();
-        let result = download_from_url(&format!("{}/error", server_uri));
+        let result = download_from_url(&format!("{server_uri}/error"));
 
         assert!(result.is_none());
     }

src/compute/utils/hash_utils.rs

@@ -4,7 +4,7 @@ use sha256::digest;
 pub fn concatenate_and_hash(hexa_strings: &[&str]) -> String {
     let mut hasher = Keccak256::default();
     for hexa_string in hexa_strings {
-        println!("value {}", hexa_string);
+        println!("value {hexa_string}");
         hasher.update(hex_string_to_byte_array(hexa_string));
     }
     format!("0x{:x}", hasher.finalize())