chore: clean relative to references and borrows

- lint message: the borrowed expression implements the required traits
help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.92.0/index.html#needless_borrows_for_generic_args
- lint message: this expression creates a reference which is immediately dereferenced by the compiler
help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.92.0/index.html#needless_borrow
- lint message: you don't need to add `&` to all patterns
help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.92.0/index.html#match_ref_pat
- remove useless taken reference
lint message: needlessly taken reference of left operand
help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.92.0/index.html#op_ref
- use &Path instead of &PathBuf as fn parameters
lint message: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.92.0/index.html#ptr_arg

src/api/admin/admin_token.rs

@@ -143,7 +143,7 @@ impl RequestHandler for UpdateAdminTokenRequest {
 		garage: &Arc<Garage>,
 		_admin: &Admin,
 	) -> Result<UpdateAdminTokenResponse, Error> {
-		let mut token = get_existing_admin_token(&garage, &self.id).await?;
+		let mut token = get_existing_admin_token(garage, &self.id).await?;
 
 		apply_token_updates(&mut token, self.body)?;
 
@@ -164,7 +164,7 @@ impl RequestHandler for DeleteAdminTokenRequest {
 		garage: &Arc<Garage>,
 		_admin: &Admin,
 	) -> Result<DeleteAdminTokenResponse, Error> {
-		let token = get_existing_admin_token(&garage, &self.id).await?;
+		let token = get_existing_admin_token(garage, &self.id).await?;
 
 		garage
 			.admin_token_table
@@ -224,7 +224,7 @@ impl RequestHandler for GetCurrentAdminTokenInfoRequest {
 		}
 
 		let (prefix, _) = self.admin_token.split_once('.').unwrap();
-		let token = get_existing_admin_token(&garage, &prefix.to_string()).await?;
+		let token = get_existing_admin_token(garage, &prefix.to_string()).await?;
 
 		Ok(GetCurrentAdminTokenInfoResponse(admin_token_info_results(
 			&token, now,

src/api/admin/api_server.rs

@@ -64,7 +64,7 @@ impl EndpointHandler<AdminRpc> for AdminApiServer {
 		match message {
 			AdminRpc::Proxy(req) => {
 				info!("Proxied admin API request: {}", req.name());
-				let res = req.clone().handle(&self.garage, &self).await;
+				let res = req.clone().handle(&self.garage, self).await;
 				match res {
 					Ok(res) => Ok(AdminRpcResponse::ProxyApiOkResponse(res.tagged())),
 					Err(e) => Ok(AdminRpcResponse::ApiErrorResponse {
@@ -76,7 +76,7 @@ impl EndpointHandler<AdminRpc> for AdminApiServer {
 			}
 			AdminRpc::Internal(req) => {
 				info!("Internal admin API request: {}", req.name());
-				let res = req.clone().handle(&self.garage, &self).await;
+				let res = req.clone().handle(&self.garage, self).await;
 				match res {
 					Ok(res) => Ok(AdminRpcResponse::InternalApiOkResponse(res)),
 					Err(e) => Ok(AdminRpcResponse::ApiErrorResponse {
@@ -173,12 +173,12 @@ impl AdminApiServer {
 		}
 
 		match request {
-			AdminApiRequest::Options(req) => req.handle(&self.garage, &self).await,
-			AdminApiRequest::CheckDomain(req) => req.handle(&self.garage, &self).await,
-			AdminApiRequest::Health(req) => req.handle(&self.garage, &self).await,
-			AdminApiRequest::Metrics(req) => req.handle(&self.garage, &self).await,
+			AdminApiRequest::Options(req) => req.handle(&self.garage, self).await,
+			AdminApiRequest::CheckDomain(req) => req.handle(&self.garage, self).await,
+			AdminApiRequest::Health(req) => req.handle(&self.garage, self).await,
+			AdminApiRequest::Metrics(req) => req.handle(&self.garage, self).await,
 			req => {
-				let res = req.handle(&self.garage, &self).await?;
+				let res = req.handle(&self.garage, self).await?;
 				let mut res = json_ok_response(&res)?;
 				res.headers_mut()
 					.insert(ACCESS_CONTROL_ALLOW_ORIGIN, HeaderValue::from_static("*"));

src/api/admin/block.rs

@@ -29,7 +29,7 @@ impl RequestHandler for LocalListBlockErrorsRequest {
 		let errors = errors
 			.into_iter()
 			.map(|e| BlockError {
-				block_hash: hex::encode(&e.hash),
+				block_hash: hex::encode(e.hash),
 				refcount: e.refcount,
 				error_count: e.error_count,
 				last_try_secs_ago: now.saturating_sub(e.last_try) / 1000,
@@ -61,15 +61,15 @@ impl RequestHandler for LocalGetBlockInfoRequest {
 					VersionBacklink::MultipartUpload { upload_id } => {
 						if let Some(u) = garage.mpu_table.get(upload_id, &EmptyKey).await? {
 							BlockVersionBacklink::Upload {
-								upload_id: hex::encode(&upload_id),
+								upload_id: hex::encode(upload_id),
 								upload_deleted: u.deleted.get(),
 								upload_garbage_collected: false,
-								bucket_id: Some(hex::encode(&u.bucket_id)),
+								bucket_id: Some(hex::encode(u.bucket_id)),
 								key: Some(u.key.to_string()),
 							}
 						} else {
 							BlockVersionBacklink::Upload {
-								upload_id: hex::encode(&upload_id),
+								upload_id: hex::encode(upload_id),
 								upload_deleted: true,
 								upload_garbage_collected: true,
 								bucket_id: None,
@@ -78,12 +78,12 @@ impl RequestHandler for LocalGetBlockInfoRequest {
 						}
 					}
 					VersionBacklink::Object { bucket_id, key } => BlockVersionBacklink::Object {
-						bucket_id: hex::encode(&bucket_id),
+						bucket_id: hex::encode(bucket_id),
 						key: key.to_string(),
 					},
 				};
 				versions.push(BlockVersion {
-					version_id: hex::encode(&br.version),
+					version_id: hex::encode(br.version),
 					ref_deleted: br.deleted.get(),
 					version_deleted: v.deleted.get(),
 					garbage_collected: false,
@@ -91,7 +91,7 @@ impl RequestHandler for LocalGetBlockInfoRequest {
 				});
 			} else {
 				versions.push(BlockVersion {
-					version_id: hex::encode(&br.version),
+					version_id: hex::encode(br.version),
 					ref_deleted: br.deleted.get(),
 					version_deleted: true,
 					garbage_collected: true,
@@ -100,7 +100,7 @@ impl RequestHandler for LocalGetBlockInfoRequest {
 			}
 		}
 		Ok(LocalGetBlockInfoResponse {
-			block_hash: hex::encode(&hash),
+			block_hash: hex::encode(hash),
 			refcount,
 			versions,
 		})
@@ -215,7 +215,7 @@ fn find_block_hash_by_prefix(garage: &Arc<Garage>, prefix: &str) -> Result<Hash,
 	for item in iter {
 		let (k, _v) = item.map_err(GarageError::from)?;
 		let hash = Hash::try_from(&k[..32]).unwrap();
-		if &hash.as_slice()[..prefix_bin.len()] != prefix_bin {
+		if hash.as_slice()[..prefix_bin.len()] != prefix_bin {
 			break;
 		}
 		if hex::encode(hash.as_slice()).starts_with(prefix) {

src/api/admin/bucket.rs

@@ -380,13 +380,13 @@ impl RequestHandler for InspectObjectRequest {
 						.map(|(vk, vb)| InspectObjectBlock {
 							part_number: vk.part_number,
 							offset: vk.offset,
-							hash: hex::encode(&vb.hash),
+							hash: hex::encode(vb.hash),
 							size: vb.size,
 						})
 						.collect::<Vec<_>>()
 				})
 				.unwrap_or_default();
-			let uuid = hex::encode(&obj_ver.uuid);
+			let uuid = hex::encode(obj_ver.uuid);
 			let timestamp = DateTime::from_timestamp_millis(obj_ver.timestamp as i64)
 				.expect("invalid timestamp in db");
 			match &obj_ver.state {
@@ -467,7 +467,7 @@ impl RequestHandler for InspectObjectRequest {
 		}
 
 		Ok(InspectObjectResponse {
-			bucket_id: hex::encode(&object.bucket_id),
+			bucket_id: hex::encode(object.bucket_id),
 			key: object.key,
 			versions,
 		})

src/api/admin/layout.rs

@@ -143,7 +143,7 @@ impl RequestHandler for GetClusterLayoutHistoryRequest {
 					.iter()
 					.map(|node| {
 						(
-							hex::encode(&node),
+							hex::encode(node),
 							NodeUpdateTrackers {
 								ack: layout.update_trackers.ack_map.get(node, min_stored),
 								sync: layout.update_trackers.sync_map.get(node, min_stored),

src/api/common/signature/checksum.rs

@@ -187,7 +187,7 @@ impl Checksums {
 	pub fn verify(&self, expected: &ExpectedChecksums) -> Result<(), Error> {
 		if let Some(expected_md5) = &expected.md5 {
 			match self.md5 {
-				Some(md5) if BASE64_STANDARD.encode(&md5) == expected_md5.trim_matches('"') => (),
+				Some(md5) if BASE64_STANDARD.encode(md5) == expected_md5.trim_matches('"') => (),
 				_ => {
 					return Err(Error::InvalidDigest(
 						"MD5 checksum verification failed (from content-md5)".into(),
@@ -312,7 +312,7 @@ pub fn extract_checksum_value(
 		ChecksumAlgorithm::Crc32 => {
 			let crc32 = headers
 				.get(X_AMZ_CHECKSUM_CRC32)
-				.and_then(|x| BASE64_STANDARD.decode(&x).ok())
+				.and_then(|x| BASE64_STANDARD.decode(x).ok())
 				.and_then(|x| x.try_into().ok())
 				.ok_or_bad_request("invalid x-amz-checksum-crc32 header")?;
 			Ok(ChecksumValue::Crc32(crc32))
@@ -320,7 +320,7 @@ pub fn extract_checksum_value(
 		ChecksumAlgorithm::Crc32c => {
 			let crc32c = headers
 				.get(X_AMZ_CHECKSUM_CRC32C)
-				.and_then(|x| BASE64_STANDARD.decode(&x).ok())
+				.and_then(|x| BASE64_STANDARD.decode(x).ok())
 				.and_then(|x| x.try_into().ok())
 				.ok_or_bad_request("invalid x-amz-checksum-crc32c header")?;
 			Ok(ChecksumValue::Crc32c(crc32c))
@@ -328,7 +328,7 @@ pub fn extract_checksum_value(
 		ChecksumAlgorithm::Crc64Nvme => {
 			let crc64nvme = headers
 				.get(X_AMZ_CHECKSUM_CRC64NVME)
-				.and_then(|x| BASE64_STANDARD.decode(&x).ok())
+				.and_then(|x| BASE64_STANDARD.decode(x).ok())
 				.and_then(|x| x.try_into().ok())
 				.ok_or_bad_request("invalid x-amz-checksum-crc64nvme header")?;
 			Ok(ChecksumValue::Crc64Nvme(crc64nvme))
@@ -336,7 +336,7 @@ pub fn extract_checksum_value(
 		ChecksumAlgorithm::Sha1 => {
 			let sha1 = headers
 				.get(X_AMZ_CHECKSUM_SHA1)
-				.and_then(|x| BASE64_STANDARD.decode(&x).ok())
+				.and_then(|x| BASE64_STANDARD.decode(x).ok())
 				.and_then(|x| x.try_into().ok())
 				.ok_or_bad_request("invalid x-amz-checksum-sha1 header")?;
 			Ok(ChecksumValue::Sha1(sha1))
@@ -344,7 +344,7 @@ pub fn extract_checksum_value(
 		ChecksumAlgorithm::Sha256 => {
 			let sha256 = headers
 				.get(X_AMZ_CHECKSUM_SHA256)
-				.and_then(|x| BASE64_STANDARD.decode(&x).ok())
+				.and_then(|x| BASE64_STANDARD.decode(x).ok())
 				.and_then(|x| x.try_into().ok())
 				.ok_or_bad_request("invalid x-amz-checksum-sha256 header")?;
 			Ok(ChecksumValue::Sha256(sha256))
@@ -358,19 +358,19 @@ pub fn add_checksum_response_headers(
 ) -> http::response::Builder {
 	match checksum {
 		Some(ChecksumValue::Crc32(crc32)) => {
-			resp = resp.header(X_AMZ_CHECKSUM_CRC32, BASE64_STANDARD.encode(&crc32));
+			resp = resp.header(X_AMZ_CHECKSUM_CRC32, BASE64_STANDARD.encode(crc32));
 		}
 		Some(ChecksumValue::Crc32c(crc32c)) => {
-			resp = resp.header(X_AMZ_CHECKSUM_CRC32C, BASE64_STANDARD.encode(&crc32c));
+			resp = resp.header(X_AMZ_CHECKSUM_CRC32C, BASE64_STANDARD.encode(crc32c));
 		}
 		Some(ChecksumValue::Crc64Nvme(crc64nvme)) => {
-			resp = resp.header(X_AMZ_CHECKSUM_CRC64NVME, BASE64_STANDARD.encode(&crc64nvme));
+			resp = resp.header(X_AMZ_CHECKSUM_CRC64NVME, BASE64_STANDARD.encode(crc64nvme));
 		}
 		Some(ChecksumValue::Sha1(sha1)) => {
-			resp = resp.header(X_AMZ_CHECKSUM_SHA1, BASE64_STANDARD.encode(&sha1));
+			resp = resp.header(X_AMZ_CHECKSUM_SHA1, BASE64_STANDARD.encode(sha1));
 		}
 		Some(ChecksumValue::Sha256(sha256)) => {
-			resp = resp.header(X_AMZ_CHECKSUM_SHA256, BASE64_STANDARD.encode(&sha256));
+			resp = resp.header(X_AMZ_CHECKSUM_SHA256, BASE64_STANDARD.encode(sha256));
 		}
 		None => (),
 	}

src/api/common/signature/mod.rs

@@ -69,7 +69,7 @@ pub fn verify_request(
 	mut req: Request<IncomingBody>,
 	service: &'static str,
 ) -> Result<VerifiedRequest, Error> {
-	let checked_signature = payload::check_payload_signature(&garage, &mut req, service)?;
+	let checked_signature = payload::check_payload_signature(garage, &mut req, service)?;
 
 	let request = streaming::parse_streaming_body(
 		req,

src/api/common/signature/payload.rs

@@ -187,7 +187,7 @@ fn check_presigned_signature(
 	let headers_mut = request.headers_mut();
 	for (name, value) in query.iter() {
 		if let Some(existing) = headers_mut.get(name) {
-			if signed_headers.contains(&name) && existing.as_bytes() != value.value.as_bytes() {
+			if signed_headers.contains(name) && existing.as_bytes() != value.value.as_bytes() {
 				return Err(Error::bad_request(format!(
 					"Conflicting values for `{}` in query parameters and request headers",
 					name
@@ -343,7 +343,7 @@ pub fn canonical_request(
 	let canonical_query_string = {
 		let mut items = Vec::with_capacity(query.len());
 		for (_, QueryValue { key, value }) in query.iter() {
-			items.push(uri_encode(&key, true) + "=" + &uri_encode(&value, true));
+			items.push(uri_encode(key, true) + "=" + &uri_encode(value, true));
 		}
 		items.sort();
 		items.join("&")

src/api/k2v/index.rs

@@ -33,7 +33,7 @@ pub async fn handle_read_index(
 
 	let (partition_keys, more, next_start) = read_range(
 		&garage.k2v.counter_table.table,
-		&bucket_id,
+		bucket_id,
 		&prefix,
 		&start,
 		&end,

src/api/s3/bucket.rs

@@ -57,23 +57,23 @@ pub fn handle_get_bucket_acl(ctx: ReqCtx) -> Result<Response<ResBody>, Error> {
 
 	if kp.allow_owner {
 		grants.push(s3_xml::Grant {
-			grantee: create_grantee(&key_p, &api_key),
+			grantee: create_grantee(key_p, &api_key),
 			permission: s3_xml::Value("FULL_CONTROL".to_string()),
 		});
 	} else {
 		if kp.allow_read {
 			grants.push(s3_xml::Grant {
-				grantee: create_grantee(&key_p, &api_key),
+				grantee: create_grantee(key_p, &api_key),
 				permission: s3_xml::Value("READ".to_string()),
 			});
 			grants.push(s3_xml::Grant {
-				grantee: create_grantee(&key_p, &api_key),
+				grantee: create_grantee(key_p, &api_key),
 				permission: s3_xml::Value("READ_ACP".to_string()),
 			});
 		}
 		if kp.allow_write {
 			grants.push(s3_xml::Grant {
-				grantee: create_grantee(&key_p, &api_key),
+				grantee: create_grantee(key_p, &api_key),
 				permission: s3_xml::Value("WRITE".to_string()),
 			});
 		}

src/api/s3/encryption.rs

@@ -124,7 +124,7 @@ impl EncryptionParams {
 
 	pub fn add_response_headers(&self, resp: &mut http::response::Builder) {
 		if let Self::SseC { client_key_md5, .. } = self {
-			let md5 = BASE64_STANDARD.encode(&client_key_md5);
+			let md5 = BASE64_STANDARD.encode(client_key_md5);
 
 			resp.headers_mut().unwrap().insert(
 				X_AMZ_SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM,
@@ -196,7 +196,7 @@ impl EncryptionParams {
 						None
 					},
 				};
-				let plaintext = enc.decrypt_blob(&inner)?;
+				let plaintext = enc.decrypt_blob(inner)?;
 				let inner = ObjectVersionMetaInner::decode(&plaintext)
 					.ok_or_internal_error("Could not decode encrypted metadata")?;
 				Ok((enc, Cow::Owned(inner)))
@@ -248,7 +248,7 @@ impl EncryptionParams {
 				// So we just put some random bytes.
 				let mut random = [0u8; 16];
 				OsRng.fill_bytes(&mut random);
-				hex::encode(&random)
+				hex::encode(random)
 			}
 		}
 	}
@@ -263,12 +263,12 @@ impl EncryptionParams {
 			Self::SseC {
 				object_key: Some(oek),
 				..
-			} => Some(Aes256Gcm::new(&oek)),
+			} => Some(Aes256Gcm::new(oek)),
 			Self::SseC {
 				client_key,
 				object_key: None,
 				..
-			} => Some(Aes256Gcm::new(&client_key)),
+			} => Some(Aes256Gcm::new(client_key)),
 			Self::Plaintext => None,
 		}
 	}
@@ -433,7 +433,7 @@ fn parse_request_headers(
 			let key_b64 =
 				key.ok_or_bad_request("Missing server-side-encryption-customer-key header")?;
 			let key_bytes: [u8; 32] = BASE64_STANDARD
-				.decode(&key_b64)
+				.decode(key_b64)
 				.ok_or_bad_request(
 					"Invalid server-side-encryption-customer-key header: invalid base64",
 				)?
@@ -445,7 +445,7 @@ fn parse_request_headers(
 
 			let md5_b64 =
 				md5.ok_or_bad_request("Missing server-side-encryption-customer-key-md5 header")?;
-			let md5_bytes = BASE64_STANDARD.decode(&md5_b64).ok_or_bad_request(
+			let md5_bytes = BASE64_STANDARD.decode(md5_b64).ok_or_bad_request(
 				"Invalid server-side-encryption-customer-key-md5 header: invalid bass64",
 			)?;
 
@@ -547,7 +547,7 @@ impl Stream for DecryptStream {
 			let nonce_size = StreamNonceSize::to_usize();
 			if let Some(nonce) = this.buf.take_exact(nonce_size) {
 				let nonce = Nonce::from_slice(nonce.as_ref());
-				*this.state = DecryptStreamState::Running(DecryptorLE31::new(&this.key, nonce));
+				*this.state = DecryptStreamState::Running(DecryptorLE31::new(this.key, nonce));
 				break;
 			}
 

src/api/s3/get.rs

@@ -124,7 +124,7 @@ fn handle_http_precondition(
 ) -> Result<Option<Response<ResBody>>, Error> {
 	let precondition_headers = PreconditionHeaders::parse(req)?;
 
-	if let Some(status_code) = precondition_headers.check(&version, &version_meta.etag)? {
+	if let Some(status_code) = precondition_headers.check(version, &version_meta.etag)? {
 		Ok(Some(
 			Response::builder()
 				.status(status_code)
@@ -189,7 +189,7 @@ pub async fn handle_head_without_ctx(
 		OekDerivationInfo::for_object(&object, object_version),
 	)?;
 
-	let checksum_mode = checksum_mode(&req);
+	let checksum_mode = checksum_mode(req);
 
 	if let Some(part_number) = part_number {
 		match version_data {
@@ -316,7 +316,7 @@ pub async fn handle_get_without_ctx(
 		OekDerivationInfo::for_object(&object, last_v),
 	)?;
 
-	let checksum_mode = checksum_mode(&req);
+	let checksum_mode = checksum_mode(req);
 
 	match (part_number, parse_range_header(req, last_v_meta.size)?) {
 		(Some(_), Some(_)) => Err(Error::bad_request(
@@ -403,7 +403,7 @@ async fn handle_get_full(
 	let mut resp_builder = object_headers(
 		version,
 		version_meta,
-		&meta_inner,
+		meta_inner,
 		encryption,
 		checksum_mode,
 	)
@@ -515,7 +515,7 @@ async fn handle_get_range(
 	match &version_data {
 		ObjectVersionData::DeleteMarker => unreachable!(),
 		ObjectVersionData::Inline(_meta, bytes) => {
-			let bytes = encryption.decrypt_blob(&bytes)?;
+			let bytes = encryption.decrypt_blob(bytes)?;
 			if end as usize <= bytes.len() {
 				let body = bytes_body(bytes[begin as usize..end as usize].to_vec().into());
 				Ok(resp_builder.body(body)?)
@@ -564,7 +564,7 @@ async fn handle_get_part(
 			if part_number != 1 {
 				return Err(Error::InvalidPart);
 			}
-			let bytes = encryption.decrypt_blob(&bytes)?;
+			let bytes = encryption.decrypt_blob(bytes)?;
 			assert_eq!(bytes.len() as u64, version_meta.size);
 			Ok(resp_builder
 				.header(CONTENT_LENGTH, format!("{}", bytes.len()))

src/api/s3/list.rs

@@ -324,31 +324,31 @@ pub async fn handle_list_parts(
 					size: s3_xml::IntValue(part.size as i64),
 					checksum_crc32: match &checksum {
 						Some(ChecksumValue::Crc32(x)) => {
-							Some(s3_xml::Value(BASE64_STANDARD.encode(&x)))
+							Some(s3_xml::Value(BASE64_STANDARD.encode(x)))
 						}
 						_ => None,
 					},
 					checksum_crc32c: match &checksum {
 						Some(ChecksumValue::Crc32c(x)) => {
-							Some(s3_xml::Value(BASE64_STANDARD.encode(&x)))
+							Some(s3_xml::Value(BASE64_STANDARD.encode(x)))
 						}
 						_ => None,
 					},
 					checksum_crc64nvme: match &checksum {
 						Some(ChecksumValue::Crc64Nvme(x)) => {
-							Some(s3_xml::Value(BASE64_STANDARD.encode(&x)))
+							Some(s3_xml::Value(BASE64_STANDARD.encode(x)))
 						}
 						_ => None,
 					},
 					checksum_sha1: match &checksum {
 						Some(ChecksumValue::Sha1(x)) => {
-							Some(s3_xml::Value(BASE64_STANDARD.encode(&x)))
+							Some(s3_xml::Value(BASE64_STANDARD.encode(x)))
 						}
 						_ => None,
 					},
 					checksum_sha256: match &checksum {
 						Some(ChecksumValue::Sha256(x)) => {
-							Some(s3_xml::Value(BASE64_STANDARD.encode(&x)))
+							Some(s3_xml::Value(BASE64_STANDARD.encode(x)))
 						}
 						_ => None,
 					},

src/api/s3/multipart.rs

@@ -43,7 +43,7 @@ pub async fn handle_create_multipart_upload(
 		bucket_name,
 		..
 	} = &ctx;
-	let existing_object = garage.object_table.get(&bucket_id, &key).await?;
+	let existing_object = garage.object_table.get(bucket_id, key).await?;
 
 	let upload_id = gen_uuid();
 	let timestamp = next_timestamp(existing_object.as_ref());
@@ -57,12 +57,12 @@ pub async fn handle_create_multipart_upload(
 
 	// Determine whether object should be encrypted, and if so the key
 	let encryption = EncryptionParams::new_from_headers(
-		&garage,
+		garage,
 		req.headers(),
 		OekDerivationInfo {
 			bucket_id: *bucket_id,
 			version_id: upload_id,
-			object_key: &key,
+			object_key: key,
 		},
 	)?;
 	let object_encryption = encryption.encrypt_meta(meta)?;
@@ -157,12 +157,8 @@ pub async fn handle_put_part(
 		} => (encryption, checksum_algorithm),
 		_ => unreachable!(),
 	};
-	let (encryption, _) = EncryptionParams::check_decrypt(
-		&garage,
-		&req_head.headers,
-		&object_encryption,
-		oek_params,
-	)?;
+	let (encryption, _) =
+		EncryptionParams::check_decrypt(garage, &req_head.headers, &object_encryption, oek_params)?;
 
 	// Check object is valid and part can be accepted
 	let first_block = first_block.ok_or_bad_request("Empty body")?;
@@ -459,7 +455,7 @@ pub async fn handle_complete_multipart_upload(
 		None => object_encryption,
 		Some(_) => {
 			let (encryption, meta) = EncryptionParams::check_decrypt(
-				&garage,
+				garage,
 				&req_head.headers,
 				&object_encryption,
 				oek_params,
@@ -503,23 +499,23 @@ pub async fn handle_complete_multipart_upload(
 		key: s3_xml::Value(key),
 		etag: s3_xml::Value(format!("\"{}\"", etag)),
 		checksum_crc32: match &checksum_extra {
-			Some(ChecksumValue::Crc32(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(&x))),
+			Some(ChecksumValue::Crc32(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(x))),
 			_ => None,
 		},
 		checksum_crc32c: match &checksum_extra {
-			Some(ChecksumValue::Crc32c(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(&x))),
+			Some(ChecksumValue::Crc32c(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(x))),
 			_ => None,
 		},
 		checksum_crc64nvme: match &checksum_extra {
-			Some(ChecksumValue::Crc64Nvme(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(&x))),
+			Some(ChecksumValue::Crc64Nvme(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(x))),
 			_ => None,
 		},
 		checksum_sha1: match &checksum_extra {
-			Some(ChecksumValue::Sha1(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(&x))),
+			Some(ChecksumValue::Sha1(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(x))),
 			_ => None,
 		},
 		checksum_sha256: match &checksum_extra {
-			Some(ChecksumValue::Sha256(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(&x))),
+			Some(ChecksumValue::Sha256(x)) => Some(s3_xml::Value(BASE64_STANDARD.encode(x))),
 			_ => None,
 		},
 		checksum_type: match checksum_algorithm {
@@ -735,7 +731,7 @@ impl MultipartChecksummer {
 		part_len: u64,
 	) -> Result<(), Error> {
 		self.md5
-			.update(&hex::decode(&etag).ok_or_message("invalid etag hex")?);
+			.update(&hex::decode(etag).ok_or_message("invalid etag hex")?);
 		if let Some(extra) = &mut self.extra {
 			extra.update(checksum, part_len)?;
 		}
@@ -815,10 +811,10 @@ impl MultipartExtraChecksummer {
 				}
 			},
 			(Self::CompositeSha1(sha1), Some(ChecksumValue::Sha1(x))) => {
-				sha1.update(&x);
+				sha1.update(x);
 			}
 			(Self::CompositeSha256(sha256), Some(ChecksumValue::Sha256(x))) => {
-				sha256.update(&x);
+				sha256.update(x);
 			}
 			_ => {
 				return Err(Error::internal_error(format!(

src/api/s3/put.rs

@@ -91,7 +91,7 @@ pub async fn handle_put(
 		OekDerivationInfo {
 			bucket_id: ctx.bucket_id,
 			version_id: version_uuid,
-			object_key: &key,
+			object_key: key,
 		},
 	)?;