gsadmin/rustfs
1
0
Fork 0
mirror of https://github.com/rustfs/rustfs.git synced 2026-07-26 08:18:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: replace unwrap() with expect() in remaining files (#729 batch 12) (#3992)

Browse Source
This commit is contained in:
Zhengchao An
2026-06-28 11:45:03 +08:00
committed by GitHub
parent 1f8a5bc095
commit f0ab812213
9 changed files with 108 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/ecstore/src/client/api_put_object.rs
+3 -3
View File
@@ -237,10 +237,10 @@ impl PutObjectOptions {
if is_amz_header(k) || is_standard_header(k) || is_storageclass_header(k) || is_rustfs_header(k) || is_minio_header(k)
{
if let Ok(header_name) = HeaderName::from_bytes(k.as_bytes()) {
header.insert(header_name, HeaderValue::from_str(&v).unwrap());
header.insert(header_name, HeaderValue::from_str(&v).expect("operation should succeed"));
}
} else if let Ok(header_name) = HeaderName::from_bytes(format!("x-amz-meta-{}", k).as_bytes()) {
header.insert(header_name, HeaderValue::from_str(&v).unwrap());
header.insert(header_name, HeaderValue::from_str(&v).expect("operation should succeed"));
}
}
@@ -376,7 +376,7 @@ impl TransitionClient {
let mut md5_base64: String = "".to_string();
if opts.send_content_md5 {
if let Some(mut md5_hasher) = self.md5_hasher.lock().unwrap().as_mut() {
if let Some(mut md5_hasher) = self.md5_hasher.lock().expect("operation should succeed").as_mut() {
let hash = md5_hasher.hash_encode(&buf[..length]);
md5_base64 = base64_encode(hash.as_ref());
}
crates/ecstore/src/erasure/coding/erasure.rs
+52 -52
View File
@@ -412,7 +412,7 @@ fn recover_empty_payload_data_shards(
/// use rustfs_ecstore::api::erasure::Erasure;
/// let erasure = Erasure::new(4, 2, 8);
/// let data = b"hello world";
/// let shards = erasure.encode_data(data).unwrap();
/// let shards = erasure.encode_data(data).expect("operation should succeed");
/// // Simulate loss and recovery...
/// ```
pub struct Erasure {
@@ -474,13 +474,13 @@ impl Erasure {
/// for decode/reconstruct (for reading and healing old-version files).
pub fn new_with_options(data_shards: usize, parity_shards: usize, block_size: usize, uses_legacy: bool) -> Self {
let encoder = if !uses_legacy && parity_shards > 0 {
Some(ReedSolomonEncoder::new(data_shards, parity_shards).unwrap())
Some(ReedSolomonEncoder::new(data_shards, parity_shards).expect("operation should succeed"))
} else {
None
};
let legacy_encoder = if uses_legacy && parity_shards > 0 {
Some(LegacyReedSolomonEncoder::new(data_shards, parity_shards).unwrap())
Some(LegacyReedSolomonEncoder::new(data_shards, parity_shards).expect("operation should succeed"))
} else {
None
};
@@ -1208,7 +1208,7 @@ mod tests {
let test_data = b"SIMD mode test data for encoding and decoding roundtrip verification with sufficient length to ensure shard size requirements are met for proper SIMD optimization.".repeat(20); // ~3KB for SIMD
let data = &test_data;
let encoded_shards = erasure.encode_data(data).unwrap();
let encoded_shards = erasure.encode_data(data).expect("operation should succeed");
assert_eq!(encoded_shards.len(), data_shards + parity_shards);
// Create decode input with some shards missing, convert to the format expected by decode_data
@@ -1217,12 +1217,12 @@ mod tests {
decode_input[i] = Some(encoded_shards[i].to_vec());
}
erasure.decode_data(&mut decode_input).unwrap();
erasure.decode_data(&mut decode_input).expect("operation should succeed");
// Recover original data
let mut recovered = Vec::new();
for shard in decode_input.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
assert_eq!(&recovered, data);
@@ -1238,7 +1238,7 @@ mod tests {
// Generate 1MB test data
let data: Vec<u8> = (0..1048576).map(|i| (i % 256) as u8).collect();
let encoded_shards = erasure.encode_data(&data).unwrap();
let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
assert_eq!(encoded_shards.len(), data_shards + parity_shards);
// Create decode input with some shards missing, convert to the format expected by decode_data
@@ -1247,12 +1247,12 @@ mod tests {
decode_input[i] = Some(encoded_shards[i].to_vec());
}
erasure.decode_data(&mut decode_input).unwrap();
erasure.decode_data(&mut decode_input).expect("operation should succeed");
// Recover original data
let mut recovered = Vec::new();
for shard in decode_input.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
assert_eq!(recovered, data);
@@ -1265,7 +1265,7 @@ mod tests {
let block_size = 6;
let erasure = Erasure::new(data_shards, parity_shards, block_size);
let data = vec![0u8; block_size];
let shards = erasure.encode_data(&data).unwrap();
let shards = erasure.encode_data(&data).expect("operation should succeed");
assert_eq!(shards.len(), data_shards + parity_shards);
let total_len: usize = shards.iter().map(|b| b.len()).sum();
assert_eq!(total_len, erasure.shard_size() * (data_shards + parity_shards));
@@ -1296,7 +1296,7 @@ mod tests {
let erasure = Erasure::new_with_options(data_shards, parity_shards, block_size, true);
let data = b"Legacy encode/decode roundtrip test data with sufficient length.".repeat(20);
let encoded_shards = erasure.encode_data(&data).unwrap();
let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
assert_eq!(encoded_shards.len(), data_shards + parity_shards);
let mut decode_input: Vec<Option<Vec<u8>>> = vec![None; data_shards + parity_shards];
@@ -1304,11 +1304,11 @@ mod tests {
decode_input[i] = Some(encoded_shards[i].to_vec());
}
erasure.decode_data(&mut decode_input).unwrap();
erasure.decode_data(&mut decode_input).expect("operation should succeed");
let mut recovered = Vec::new();
for shard in decode_input.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
assert_eq!(&recovered, &data);
@@ -1322,17 +1322,17 @@ mod tests {
let erasure = Erasure::new_with_options(data_shards, parity_shards, block_size, true);
let data = b"Legacy decode with missing shards test.".repeat(10);
let encoded_shards = erasure.encode_data(&data).unwrap();
let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
let mut shards_opt: Vec<Option<Vec<u8>>> = encoded_shards.iter().map(|s| Some(s.to_vec())).collect();
shards_opt[1] = None;
shards_opt[5] = None;
erasure.decode_data(&mut shards_opt).unwrap();
erasure.decode_data(&mut shards_opt).expect("operation should succeed");
let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
assert_eq!(&recovered, &data);
@@ -1373,17 +1373,17 @@ mod tests {
.encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| {
let tx = tx.clone();
async move {
let shards = res.unwrap();
tx.send(shards).await.unwrap();
let shards = res.expect("operation should succeed");
tx.send(shards).await.expect("operation should succeed");
Ok(())
}
})
.await
.unwrap();
.expect("operation should succeed");
});
let result = handle.await;
assert!(result.is_ok());
let collected_shards = rx.recv().await.unwrap();
let collected_shards = rx.recv().await.expect("operation should succeed");
assert_eq!(collected_shards.len(), data_shards + parity_shards);
}
@@ -1412,17 +1412,17 @@ mod tests {
.encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| {
let tx = tx.clone();
async move {
let shards = res.unwrap();
tx.send(shards).await.unwrap();
let shards = res.expect("operation should succeed");
tx.send(shards).await.expect("operation should succeed");
Ok(())
}
})
.await
.unwrap();
.expect("operation should succeed");
});
let result = handle.await;
assert!(result.is_ok());
let shards = rx.recv().await.unwrap();
let shards = rx.recv().await.expect("operation should succeed");
assert_eq!(shards.len(), data_shards + parity_shards);
// Test decode using the old API that operates in-place
@@ -1430,12 +1430,12 @@ mod tests {
for i in 0..data_shards {
decode_input[i] = Some(shards[i].to_vec());
}
erasure.decode_data(&mut decode_input).unwrap();
erasure.decode_data(&mut decode_input).expect("operation should succeed");
// Recover original data
let mut recovered = Vec::new();
for shard in decode_input.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data_clone.len());
assert_eq!(&recovered, &data_clone);
@@ -1456,7 +1456,7 @@ mod tests {
let observed = observed_clone.clone();
async move {
let err = res.expect_err("zero block size should report an error");
*observed.lock().unwrap() = Some((err.kind(), err.to_string()));
*observed.lock().expect("operation should succeed") = Some((err.kind(), err.to_string()));
Ok(())
}
})
@@ -1464,7 +1464,7 @@ mod tests {
.expect("callback should handle the zero block size error");
assert_eq!(total, 0);
let observed = observed.lock().unwrap();
let observed = observed.lock().expect("operation should succeed");
let (kind, message) = observed.as_ref().expect("callback should be invoked once");
assert_eq!(*kind, io::ErrorKind::InvalidInput);
assert!(message.contains("block_size"));
@@ -1485,7 +1485,7 @@ mod tests {
let test_data = b"SIMD mode test data for encoding and decoding roundtrip verification with sufficient length to ensure shard size requirements are met for proper SIMD optimization and validation.";
let data = test_data.repeat(25); // Create much larger data: ~5KB total, ~1.25KB per shard
let encoded_shards = erasure.encode_data(&data).unwrap();
let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
assert_eq!(encoded_shards.len(), data_shards + parity_shards);
// Create decode input with some shards missing
@@ -1495,12 +1495,12 @@ mod tests {
shards_opt[1] = None; // Lose second data shard
shards_opt[5] = None; // Lose second parity shard
erasure.decode_data(&mut shards_opt).unwrap();
erasure.decode_data(&mut shards_opt).expect("operation should succeed");
// Verify recovered data
let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
assert_eq!(&recovered, &data);
@@ -1516,7 +1516,7 @@ mod tests {
// Create all-zero data that ensures adequate shard size for SIMD optimization
let data = vec![0u8; 1024]; // 1KB of zeros, each shard will be 256 bytes
let encoded_shards = erasure.encode_data(&data).unwrap();
let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
assert_eq!(encoded_shards.len(), data_shards + parity_shards);
// Verify that all data shards are zeros
@@ -1531,12 +1531,12 @@ mod tests {
shards_opt[0] = None; // Lose first data shard
shards_opt[4] = None; // Lose first parity shard
erasure.decode_data(&mut shards_opt).unwrap();
erasure.decode_data(&mut shards_opt).expect("operation should succeed");
// Verify recovered data is still all zeros
let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
assert!(recovered.iter().all(|&x| x == 0), "Recovered data should be all zeros");
@@ -1555,7 +1555,7 @@ mod tests {
data.push((i % 256) as u8);
}
let shards = erasure.encode_data(&data).unwrap();
let shards = erasure.encode_data(&data).expect("operation should succeed");
assert_eq!(shards.len(), data_shards + parity_shards);
// Simulate the loss of multiple shards
@@ -1566,12 +1566,12 @@ mod tests {
shards_opt[11] = None; // Parity shard
// Decode
erasure.decode_data(&mut shards_opt).unwrap();
erasure.decode_data(&mut shards_opt).expect("operation should succeed");
// Recover original data
let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
assert_eq!(&recovered, &data);
@@ -1603,7 +1603,7 @@ mod tests {
Ok(_) => {
let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
assert_eq!(&recovered, &data);
@@ -1630,7 +1630,7 @@ mod tests {
let data =
b"Testing maximum erasure capacity with SIMD Reed-Solomon implementation for robustness verification!".repeat(3);
let shards = erasure.encode_data(&data).unwrap();
let shards = erasure.encode_data(&data).expect("operation should succeed");
// Lose exactly the maximum number of shards (equal to parity_shards)
let mut shards_opt: Vec<Option<Vec<u8>>> = shards.iter().map(|b| Some(b.to_vec())).collect();
@@ -1639,11 +1639,11 @@ mod tests {
shards_opt[6] = None; // Parity shard
// Should succeed with maximum erasures
erasure.decode_data(&mut shards_opt).unwrap();
erasure.decode_data(&mut shards_opt).expect("operation should succeed");
let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
assert_eq!(&recovered, &data);
@@ -1662,7 +1662,7 @@ mod tests {
fn test_reed_solomon_compat() {
let data = generate_compat_test_data(7557);
let erasure = Erasure::new(4, 2, 7557);
let shards = erasure.encode_data(&data).unwrap();
let shards = erasure.encode_data(&data).expect("operation should succeed");
assert_eq!(shards.len(), 6, "expected 6 shards (4 data + 2 parity)");
// Per-shard HighwayHash
@@ -1732,7 +1732,7 @@ mod tests {
// Verify recovered data
let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(small_data.len());
println!("recovered: {recovered:?}");
@@ -1776,7 +1776,7 @@ mod tests {
// Encode the data
let start = std::time::Instant::now();
let shards = erasure.encode_data(&data).unwrap();
let shards = erasure.encode_data(&data).expect("operation should succeed");
let encode_duration = start.elapsed();
println!("⏱️ Encoding completed in: {encode_duration:?}");
@@ -1800,7 +1800,7 @@ mod tests {
// Decode and recover data
let start = std::time::Instant::now();
erasure.decode_data(&mut shards_opt).unwrap();
erasure.decode_data(&mut shards_opt).expect("operation should succeed");
let decode_duration = start.elapsed();
println!("⏱️ Decoding completed in: {decode_duration:?}");
@@ -1808,7 +1808,7 @@ mod tests {
// Verify recovered data integrity
let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
recovered.truncate(data.len());
@@ -1853,20 +1853,20 @@ mod tests {
.encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| {
let tx = tx.clone();
async move {
let shards = res.unwrap();
tx.send(shards).await.unwrap();
let shards = res.expect("operation should succeed");
tx.send(shards).await.expect("operation should succeed");
Ok(())
}
})
.await
.unwrap();
.expect("operation should succeed");
});
let mut all_blocks = Vec::new();
while let Some(block) = rx.recv().await {
all_blocks.push(block);
}
handle.await.unwrap();
handle.await.expect("operation should succeed");
// Verify we got multiple blocks
assert!(all_blocks.len() > 1, "Should have multiple blocks for stream test");
@@ -1879,10 +1879,10 @@ mod tests {
shards_opt[1] = None;
shards_opt[5] = None;
erasure.decode_data(&mut shards_opt).unwrap();
erasure.decode_data(&mut shards_opt).expect("operation should succeed");
for shard in shards_opt.iter().take(data_shards) {
recovered.extend_from_slice(shard.as_ref().unwrap());
recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
}
}
crates/ecstore/src/runtime/global.rs
+2 -2
View File
@@ -112,7 +112,7 @@ pub fn set_global_rustfs_port(value: u16) {
/// * None
///
pub fn set_global_deployment_id(id: Uuid) {
globalDeploymentIDPtr.set(id).unwrap();
globalDeploymentIDPtr.set(id).expect("operation should succeed");
}
/// Get the global deployment id
@@ -274,7 +274,7 @@ pub(crate) type TypeLocalDiskSetDrives = Vec<Vec<Vec<Option<DiskStore>>>>;
/// # Returns
/// * None
pub fn set_global_region(region: s3s::region::Region) {
GLOBAL_REGION.set(region).unwrap();
GLOBAL_REGION.set(region).expect("operation should succeed");
}
/// Get the global region
crates/ecstore/src/store/rebalance.rs
+6 -6
View File
@@ -36,7 +36,7 @@ impl ECStore {
// if disk.is_none() {
// continue;
// }
// // let disk = disk.as_ref().unwrap().clone();
// // let disk = disk.as_ref().expect("operation should succeed").clone();
// // futures.push(disk.delete(
// // bucket,
// // prefix,
@@ -315,7 +315,7 @@ impl ECStore {
return Ok((pinfo.clone(), self.pools_with_object(&ress, opts).await));
}
let err = pinfo.err.as_ref().unwrap();
let err = pinfo.err.as_ref().expect("operation should succeed");
if err == &Error::ErasureReadQuorum && !opts.metadata_chg {
return Ok((pinfo.clone(), self.pools_with_object(&ress, opts).await));
@@ -460,7 +460,7 @@ impl ECStore {
let mut pool_meta = self.pool_meta.write().await;
*pool_meta = meta;
// *self.pool_meta.write().unwrap() = meta;
// *self.pool_meta.write().expect("operation should succeed") = meta;
Ok(())
}
@@ -638,7 +638,7 @@ mod tests {
fn object_info_with_mod_time(unix_ts: i64, delete_marker: bool) -> ObjectInfo {
ObjectInfo {
mod_time: Some(OffsetDateTime::from_unix_timestamp(unix_ts).unwrap()),
mod_time: Some(OffsetDateTime::from_unix_timestamp(unix_ts).expect("operation should succeed")),
delete_marker,
..Default::default()
}
@@ -660,7 +660,7 @@ mod tests {
];
let (info, idx) =
resolve_latest_object_info_candidates(candidates, "bucket", "object", &ObjectOptions::default()).unwrap();
resolve_latest_object_info_candidates(candidates, "bucket", "object", &ObjectOptions::default()).expect("operation should succeed");
assert_eq!(idx, 1);
assert!(info.delete_marker);
@@ -681,7 +681,7 @@ mod tests {
},
];
let (_, idx) = resolve_latest_object_info_candidates(candidates, "bucket", "object", &ObjectOptions::default()).unwrap();
let (_, idx) = resolve_latest_object_info_candidates(candidates, "bucket", "object", &ObjectOptions::default()).expect("operation should succeed");
assert_eq!(idx, 1);
}
crates/io-core/src/pool.rs
+2 -2
View File
@@ -383,7 +383,7 @@ impl PoolTier {
// Use the pool's shared metrics for recording
let _metrics_lock = self.metrics.lock().unwrap_or_else(|e| e.into_inner());
let _metrics = _metrics_lock.as_ref().unwrap();
let _metrics = _metrics_lock.as_ref().expect("operation should succeed");
// Record acquisition
pool_metrics.total_acquires.fetch_add(1, Ordering::Relaxed);
@@ -406,7 +406,7 @@ impl PoolTier {
// Use the pool's shared metrics for recording
let _metrics_lock = self.metrics.lock().unwrap_or_else(|e| e.into_inner());
let _metrics = _metrics_lock.as_ref().unwrap();
let _metrics = _metrics_lock.as_ref().expect("operation should succeed");
// Record acquisition
pool_metrics.total_acquires.fetch_add(1, Ordering::Relaxed);
crates/protocols/src/swift/expiration_worker.rs
+6 -6
View File
@@ -342,7 +342,7 @@ impl ExpirationWorker {
metrics: &Arc<RwLock<ExpirationMetrics>>,
) -> SwiftResult<()> {
let start_time = SystemTime::now();
let now = start_time.duration_since(UNIX_EPOCH).unwrap().as_secs();
let now = start_time.duration_since(UNIX_EPOCH).expect("operation should succeed").as_secs();
debug!(
event = EVENT_SWIFT_EXPIRATION_ITERATION_SUMMARY,
@@ -375,7 +375,7 @@ impl ExpirationWorker {
}
// Remove from queue and add to batch
let entry = queue.pop().unwrap().0;
let entry = queue.pop().expect("operation should succeed").0;
drop(queue); // Release lock
batch.push(entry);
@@ -452,7 +452,7 @@ impl ExpirationWorker {
}
// Update metrics
let duration = SystemTime::now().duration_since(start_time).unwrap();
let duration = SystemTime::now().duration_since(start_time).expect("operation should succeed");
let mut m = metrics.write().await;
m.objects_scanned += scanned_count;
m.objects_deleted += deleted_count;
@@ -589,9 +589,9 @@ mod tests {
}));
// Should pop in order: 1000, 2000, 3000
assert_eq!(heap.pop().unwrap().0.expires_at, 1000);
assert_eq!(heap.pop().unwrap().0.expires_at, 2000);
assert_eq!(heap.pop().unwrap().0.expires_at, 3000);
assert_eq!(heap.pop().expect("operation should succeed").0.expires_at, 1000);
assert_eq!(heap.pop().expect("operation should succeed").0.expires_at, 2000);
assert_eq!(heap.pop().expect("operation should succeed").0.expires_at, 3000);
}
#[test]
crates/rio/src/encrypt_reader.rs
+20 -20
View File
@@ -636,7 +636,7 @@ mod tests {
let reader = BufReader::new(Cursor::new(data.to_vec()));
let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
encrypted
}
@@ -674,14 +674,14 @@ mod tests {
// Encrypt
let mut encrypt_reader = encrypt_reader;
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
// Decrypt using DecryptReader
let reader = Cursor::new(encrypted.clone());
let decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypt_reader = decrypt_reader;
let mut decrypted = Vec::new();
decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
assert_eq!(&decrypted, data);
}
@@ -700,7 +700,7 @@ mod tests {
let encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypt_reader = encrypt_reader;
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
// Now test DecryptReader
@@ -708,7 +708,7 @@ mod tests {
let decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypt_reader = decrypt_reader;
let mut decrypted = Vec::new();
decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
assert_eq!(&decrypted, data);
}
@@ -728,13 +728,13 @@ mod tests {
let encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypt_reader = encrypt_reader;
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
let reader = std::io::Cursor::new(encrypted.clone());
let decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypt_reader = decrypt_reader;
let mut decrypted = Vec::new();
decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
assert_eq!(&decrypted, &data);
}
@@ -752,12 +752,12 @@ mod tests {
let reader = Cursor::new(data.clone());
let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
let reader = ChunkedCursor::new(encrypted, 3);
let mut decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypted = Vec::new();
decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
assert_eq!(decrypted, data);
}
@@ -775,12 +775,12 @@ mod tests {
let reader = Cursor::new(data.clone());
let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
let reader = PendingChunkedCursor::new(encrypted, 3);
let mut decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypted = Vec::new();
decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
assert_eq!(decrypted, data);
}
@@ -798,7 +798,7 @@ mod tests {
let reader = Cursor::new(data.clone());
let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
let reader = ChunkedCursor::new(encrypted, 8192);
let decrypt_reader = DecryptReader::new(reader, key, nonce);
@@ -806,7 +806,7 @@ mod tests {
let mut decrypted = Vec::new();
while let Some(chunk) = stream.next().await {
let bytes = chunk.unwrap();
let bytes = chunk.expect("operation should succeed");
decrypted.extend_from_slice(&bytes);
}
@@ -826,7 +826,7 @@ mod tests {
let reader = Cursor::new(data.clone());
let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
let reader = ChunkedCursor::new(encrypted, 8192);
let decrypt_reader = DecryptReader::new(reader, key, nonce);
@@ -835,7 +835,7 @@ mod tests {
let mut decrypted = Vec::new();
while let Some(chunk) = stream.next().await {
let bytes = chunk.unwrap();
let bytes = chunk.expect("operation should succeed");
decrypted.extend_from_slice(&bytes);
}
@@ -857,7 +857,7 @@ mod tests {
let reader = BufReader::new(Cursor::new(data.to_vec()));
let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
encrypted
}
@@ -871,7 +871,7 @@ mod tests {
let reader = BufReader::new(Cursor::new(combined));
let mut decrypt_reader = DecryptReader::new_multipart(reader, key, base_nonce, vec![1, 2]);
let mut decrypted = Vec::new();
decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
let mut expected = Vec::with_capacity(part_one.len() + part_two.len());
expected.extend_from_slice(&part_one);
@@ -891,7 +891,7 @@ mod tests {
let reader = Cursor::new(data);
let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new();
encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
let payloads = extract_encrypted_payloads(&encrypted);
assert!(payloads.len() >= 2);
@@ -920,7 +920,7 @@ mod tests {
let reader = Cursor::new(encrypted);
let mut decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypted = Vec::new();
decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
assert_eq!(decrypted, data);
}
@@ -945,7 +945,7 @@ mod tests {
let reader = BufReader::new(Cursor::new(combined));
let mut decrypt_reader = DecryptReader::new_multipart(reader, key, base_nonce, vec![1, 2]);
let mut decrypted = Vec::new();
decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
let mut expected = Vec::with_capacity(part_one.len() + part_two.len());
expected.extend_from_slice(&part_one);
crates/targets/src/net.rs
+14 -14
View File
@@ -23,7 +23,7 @@ use std::sync::LazyLock;
use thiserror::Error;
use url::Url;
static HOST_LABEL_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$").unwrap());
static HOST_LABEL_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$").expect("operation should succeed"));
/// NetError represents errors that can occur in network operations.
#[derive(Error, Debug)]
@@ -332,7 +332,7 @@ impl<'de> serde::Deserialize<'de> for ParsedURL {
{
let s: String = serde::Deserialize::deserialize(deserializer)?;
if s.is_empty() {
Ok(ParsedURL(Url::parse("about:blank").unwrap()))
Ok(ParsedURL(Url::parse("about:blank").expect("operation should succeed")))
} else {
parse_url(&s).map_err(serde::de::Error::custom)
}
@@ -363,7 +363,7 @@ pub fn parse_url(s: &str) -> Result<ParsedURL, NetError> {
});
if !port_str.is_empty() {
let host_port = format!("{}:{}", uu.host_str().unwrap(), port_str);
let host_port = format!("{}:{}", uu.host_str().expect("operation should succeed"), port_str);
parse_host(&host_port)?;
}
}
@@ -485,7 +485,7 @@ mod tests {
fn parse_host_with_valid_ipv4() {
let result = parse_host("192.168.1.1:8080");
assert!(result.is_ok());
let host = result.unwrap();
let host = result.expect("operation should succeed");
assert_eq!(host.name, "192.168.1.1");
assert_eq!(host.port, Some(8080));
}
@@ -494,7 +494,7 @@ mod tests {
fn parse_host_with_valid_hostname() {
let result = parse_host("example.com:443");
assert!(result.is_ok());
let host = result.unwrap();
let host = result.expect("operation should succeed");
assert_eq!(host.name, "example.com");
assert_eq!(host.port, Some(443));
}
@@ -503,7 +503,7 @@ mod tests {
fn parse_host_with_ipv6_brackets() {
let result = parse_host("[::1]:8080");
assert!(result.is_ok());
let host = result.unwrap();
let host = result.expect("operation should succeed");
assert_eq!(host.name, "::1");
assert_eq!(host.port, Some(8080));
}
@@ -512,7 +512,7 @@ mod tests {
fn parse_host_with_bare_ipv6_without_port() {
let result = parse_host("::1");
assert!(result.is_ok());
let host = result.unwrap();
let host = result.expect("operation should succeed");
assert_eq!(host.name, "::1");
assert_eq!(host.port, None);
}
@@ -521,7 +521,7 @@ mod tests {
fn parse_host_with_ipv6_zone_without_port() {
let result = parse_host("fe80::1%eth0");
assert!(result.is_ok());
let host = result.unwrap();
let host = result.expect("operation should succeed");
assert_eq!(host.name, "fe80::1%eth0");
assert_eq!(host.port, None);
}
@@ -530,7 +530,7 @@ mod tests {
fn parse_host_with_bracketed_ipv6_zone_and_port() {
let result = parse_host("[fe80::1%eth0]:9000");
assert!(result.is_ok());
let host = result.unwrap();
let host = result.expect("operation should succeed");
assert_eq!(host.name, "fe80::1%eth0");
assert_eq!(host.port, Some(9000));
}
@@ -539,7 +539,7 @@ mod tests {
fn parse_host_with_bracketed_ipv6_without_port() {
let result = parse_host("[::1]");
assert!(result.is_ok());
let host = result.unwrap();
let host = result.expect("operation should succeed");
assert_eq!(host.name, "::1");
assert_eq!(host.port, None);
}
@@ -560,7 +560,7 @@ mod tests {
fn parse_host_without_port() {
let result = parse_host("example.com");
assert!(result.is_ok());
let host = result.unwrap();
let host = result.expect("operation should succeed");
assert_eq!(host.name, "example.com");
assert_eq!(host.port, None);
}
@@ -605,7 +605,7 @@ mod tests {
fn parse_url_with_valid_http_url() {
let result = parse_url("http://example.com/path");
assert!(result.is_ok());
let parsed = result.unwrap();
let parsed = result.expect("operation should succeed");
assert_eq!(parsed.hostname(), "example.com");
assert_eq!(parsed.port(), "80");
assert_eq!(parsed.scheme(), "http");
@@ -616,7 +616,7 @@ mod tests {
fn parse_url_with_explicit_default_https_port() {
let result = parse_url("https://example.com:443/path");
assert!(result.is_ok());
let parsed = result.unwrap();
let parsed = result.expect("operation should succeed");
assert_eq!(parsed.to_string(), "https://example.com/path");
}
@@ -636,7 +636,7 @@ mod tests {
fn parse_url_normalizes_path() {
let result = parse_url("http://example.com//path/../path/");
assert!(result.is_ok());
let parsed = result.unwrap();
let parsed = result.expect("operation should succeed");
assert_eq!(parsed.to_string(), "http://example.com/path/");
}
}
rustfs/src/admin/handlers/kms_management.rs
+3 -3
View File
@@ -208,7 +208,7 @@ impl Operation for KmsStatusHandler {
let data = serde_json::to_vec(&response).map_err(|e| s3_error!(InternalError, "failed to serialize response: {}", e))?;
let mut headers = HeaderMap::new();
headers.insert(CONTENT_TYPE, "application/json".parse().unwrap());
headers.insert(CONTENT_TYPE, "application/json".parse().expect("operation should succeed"));
Ok(S3Response::with_headers((StatusCode::OK, Body::from(data)), headers))
}
@@ -257,7 +257,7 @@ impl Operation for KmsConfigHandler {
let data = serde_json::to_vec(&response).map_err(|e| s3_error!(InternalError, "failed to serialize response: {}", e))?;
let mut headers = HeaderMap::new();
headers.insert(CONTENT_TYPE, "application/json".parse().unwrap());
headers.insert(CONTENT_TYPE, "application/json".parse().expect("operation should succeed"));
Ok(S3Response::with_headers((StatusCode::OK, Body::from(data)), headers))
}
@@ -302,7 +302,7 @@ impl Operation for KmsClearCacheHandler {
serde_json::to_vec(&response).map_err(|e| s3_error!(InternalError, "failed to serialize response: {}", e))?;
let mut headers = HeaderMap::new();
headers.insert(CONTENT_TYPE, "application/json".parse().unwrap());
headers.insert(CONTENT_TYPE, "application/json".parse().expect("operation should succeed"));
Ok(S3Response::with_headers((StatusCode::OK, Body::from(data)), headers))
}