gsadmin/rustfs
1
0
Fork 0
mirror of https://github.com/rustfs/rustfs.git synced 2026-08-30 08:49:26 +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 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()) { 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()) { } 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(); let mut md5_base64: String = "".to_string();
if opts.send_content_md5 { 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]); let hash = md5_hasher.hash_encode(&buf[..length]);
md5_base64 = base64_encode(hash.as_ref()); 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; /// use rustfs_ecstore::api::erasure::Erasure;
/// let erasure = Erasure::new(4, 2, 8); /// let erasure = Erasure::new(4, 2, 8);
/// let data = b"hello world"; /// 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... /// // Simulate loss and recovery...
/// ``` /// ```
pub struct Erasure { pub struct Erasure {
@@ -474,13 +474,13 @@ impl Erasure {
/// for decode/reconstruct (for reading and healing old-version files). /// 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 { 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 { 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 { } else {
None None
}; };
let legacy_encoder = if uses_legacy && parity_shards > 0 { 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 { } else {
None 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 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 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); assert_eq!(encoded_shards.len(), data_shards + parity_shards);
// Create decode input with some shards missing, convert to the format expected by decode_data // 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()); 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 // Recover original data
let mut recovered = Vec::new(); let mut recovered = Vec::new();
for shard in decode_input.iter().take(data_shards) { 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()); recovered.truncate(data.len());
assert_eq!(&recovered, data); assert_eq!(&recovered, data);
@@ -1238,7 +1238,7 @@ mod tests {
// Generate 1MB test data // Generate 1MB test data
let data: Vec<u8> = (0..1048576).map(|i| (i % 256) as u8).collect(); 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); assert_eq!(encoded_shards.len(), data_shards + parity_shards);
// Create decode input with some shards missing, convert to the format expected by decode_data // 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()); 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 // Recover original data
let mut recovered = Vec::new(); let mut recovered = Vec::new();
for shard in decode_input.iter().take(data_shards) { 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()); recovered.truncate(data.len());
assert_eq!(recovered, data); assert_eq!(recovered, data);
@@ -1265,7 +1265,7 @@ mod tests {
let block_size = 6; let block_size = 6;
let erasure = Erasure::new(data_shards, parity_shards, block_size); let erasure = Erasure::new(data_shards, parity_shards, block_size);
let data = vec![0u8; 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); assert_eq!(shards.len(), data_shards + parity_shards);
let total_len: usize = shards.iter().map(|b| b.len()).sum(); let total_len: usize = shards.iter().map(|b| b.len()).sum();
assert_eq!(total_len, erasure.shard_size() * (data_shards + parity_shards)); 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 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 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); assert_eq!(encoded_shards.len(), data_shards + parity_shards);
let mut decode_input: Vec<Option<Vec<u8>>> = vec![None; 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()); 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(); let mut recovered = Vec::new();
for shard in decode_input.iter().take(data_shards) { 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()); recovered.truncate(data.len());
assert_eq!(&recovered, &data); assert_eq!(&recovered, &data);
@@ -1322,17 +1322,17 @@ mod tests {
let erasure = Erasure::new_with_options(data_shards, parity_shards, block_size, true); 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 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(); let mut shards_opt: Vec<Option<Vec<u8>>> = encoded_shards.iter().map(|s| Some(s.to_vec())).collect();
shards_opt[1] = None; shards_opt[1] = None;
shards_opt[5] = 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(); let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) { 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()); recovered.truncate(data.len());
assert_eq!(&recovered, &data); assert_eq!(&recovered, &data);
@@ -1373,17 +1373,17 @@ mod tests {
.encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| { .encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| {
let tx = tx.clone(); let tx = tx.clone();
async move { async move {
let shards = res.unwrap(); let shards = res.expect("operation should succeed");
tx.send(shards).await.unwrap(); tx.send(shards).await.expect("operation should succeed");
Ok(()) Ok(())
} }
}) })
.await .await
.unwrap(); .expect("operation should succeed");
}); });
let result = handle.await; let result = handle.await;
assert!(result.is_ok()); 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); assert_eq!(collected_shards.len(), data_shards + parity_shards);
} }
@@ -1412,17 +1412,17 @@ mod tests {
.encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| { .encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| {
let tx = tx.clone(); let tx = tx.clone();
async move { async move {
let shards = res.unwrap(); let shards = res.expect("operation should succeed");
tx.send(shards).await.unwrap(); tx.send(shards).await.expect("operation should succeed");
Ok(()) Ok(())
} }
}) })
.await .await
.unwrap(); .expect("operation should succeed");
}); });
let result = handle.await; let result = handle.await;
assert!(result.is_ok()); 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); assert_eq!(shards.len(), data_shards + parity_shards);
// Test decode using the old API that operates in-place // Test decode using the old API that operates in-place
@@ -1430,12 +1430,12 @@ mod tests {
for i in 0..data_shards { for i in 0..data_shards {
decode_input[i] = Some(shards[i].to_vec()); 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 // Recover original data
let mut recovered = Vec::new(); let mut recovered = Vec::new();
for shard in decode_input.iter().take(data_shards) { 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()); recovered.truncate(data_clone.len());
assert_eq!(&recovered, &data_clone); assert_eq!(&recovered, &data_clone);
@@ -1456,7 +1456,7 @@ mod tests {
let observed = observed_clone.clone(); let observed = observed_clone.clone();
async move { async move {
let err = res.expect_err("zero block size should report an error"); 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(()) Ok(())
} }
}) })
@@ -1464,7 +1464,7 @@ mod tests {
.expect("callback should handle the zero block size error"); .expect("callback should handle the zero block size error");
assert_eq!(total, 0); 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"); let (kind, message) = observed.as_ref().expect("callback should be invoked once");
assert_eq!(*kind, io::ErrorKind::InvalidInput); assert_eq!(*kind, io::ErrorKind::InvalidInput);
assert!(message.contains("block_size")); 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 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 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); assert_eq!(encoded_shards.len(), data_shards + parity_shards);
// Create decode input with some shards missing // Create decode input with some shards missing
@@ -1495,12 +1495,12 @@ mod tests {
shards_opt[1] = None; // Lose second data shard shards_opt[1] = None; // Lose second data shard
shards_opt[5] = None; // Lose second parity 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 // Verify recovered data
let mut recovered = Vec::new(); let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) { 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()); recovered.truncate(data.len());
assert_eq!(&recovered, &data); assert_eq!(&recovered, &data);
@@ -1516,7 +1516,7 @@ mod tests {
// Create all-zero data that ensures adequate shard size for SIMD optimization // 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 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); assert_eq!(encoded_shards.len(), data_shards + parity_shards);
// Verify that all data shards are zeros // Verify that all data shards are zeros
@@ -1531,12 +1531,12 @@ mod tests {
shards_opt[0] = None; // Lose first data shard shards_opt[0] = None; // Lose first data shard
shards_opt[4] = None; // Lose first parity 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 // Verify recovered data is still all zeros
let mut recovered = Vec::new(); let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) { 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()); recovered.truncate(data.len());
assert!(recovered.iter().all(|&x| x == 0), "Recovered data should be all zeros"); 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); 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); assert_eq!(shards.len(), data_shards + parity_shards);
// Simulate the loss of multiple shards // Simulate the loss of multiple shards
@@ -1566,12 +1566,12 @@ mod tests {
shards_opt[11] = None; // Parity shard shards_opt[11] = None; // Parity shard
// Decode // Decode
erasure.decode_data(&mut shards_opt).unwrap(); erasure.decode_data(&mut shards_opt).expect("operation should succeed");
// Recover original data // Recover original data
let mut recovered = Vec::new(); let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) { 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()); recovered.truncate(data.len());
assert_eq!(&recovered, &data); assert_eq!(&recovered, &data);
@@ -1603,7 +1603,7 @@ mod tests {
Ok(_) => { Ok(_) => {
let mut recovered = Vec::new(); let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) { 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()); recovered.truncate(data.len());
assert_eq!(&recovered, &data); assert_eq!(&recovered, &data);
@@ -1630,7 +1630,7 @@ mod tests {
let data = let data =
b"Testing maximum erasure capacity with SIMD Reed-Solomon implementation for robustness verification!".repeat(3); 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) // 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(); 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 shards_opt[6] = None; // Parity shard
// Should succeed with maximum erasures // 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(); let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) { 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()); recovered.truncate(data.len());
assert_eq!(&recovered, &data); assert_eq!(&recovered, &data);
@@ -1662,7 +1662,7 @@ mod tests {
fn test_reed_solomon_compat() { fn test_reed_solomon_compat() {
let data = generate_compat_test_data(7557); let data = generate_compat_test_data(7557);
let erasure = Erasure::new(4, 2, 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)"); assert_eq!(shards.len(), 6, "expected 6 shards (4 data + 2 parity)");
// Per-shard HighwayHash // Per-shard HighwayHash
@@ -1732,7 +1732,7 @@ mod tests {
// Verify recovered data // Verify recovered data
let mut recovered = Vec::new(); let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) { 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()); recovered.truncate(small_data.len());
println!("recovered: {recovered:?}"); println!("recovered: {recovered:?}");
@@ -1776,7 +1776,7 @@ mod tests {
// Encode the data // Encode the data
let start = std::time::Instant::now(); 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(); let encode_duration = start.elapsed();
println!("⏱️ Encoding completed in: {encode_duration:?}"); println!("⏱️ Encoding completed in: {encode_duration:?}");
@@ -1800,7 +1800,7 @@ mod tests {
// Decode and recover data // Decode and recover data
let start = std::time::Instant::now(); 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(); let decode_duration = start.elapsed();
println!("⏱️ Decoding completed in: {decode_duration:?}"); println!("⏱️ Decoding completed in: {decode_duration:?}");
@@ -1808,7 +1808,7 @@ mod tests {
// Verify recovered data integrity // Verify recovered data integrity
let mut recovered = Vec::new(); let mut recovered = Vec::new();
for shard in shards_opt.iter().take(data_shards) { 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()); recovered.truncate(data.len());
@@ -1853,20 +1853,20 @@ mod tests {
.encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| { .encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| {
let tx = tx.clone(); let tx = tx.clone();
async move { async move {
let shards = res.unwrap(); let shards = res.expect("operation should succeed");
tx.send(shards).await.unwrap(); tx.send(shards).await.expect("operation should succeed");
Ok(()) Ok(())
} }
}) })
.await .await
.unwrap(); .expect("operation should succeed");
}); });
let mut all_blocks = Vec::new(); let mut all_blocks = Vec::new();
while let Some(block) = rx.recv().await { while let Some(block) = rx.recv().await {
all_blocks.push(block); all_blocks.push(block);
} }
handle.await.unwrap(); handle.await.expect("operation should succeed");
// Verify we got multiple blocks // Verify we got multiple blocks
assert!(all_blocks.len() > 1, "Should have multiple blocks for stream test"); assert!(all_blocks.len() > 1, "Should have multiple blocks for stream test");
@@ -1879,10 +1879,10 @@ mod tests {
shards_opt[1] = None; shards_opt[1] = None;
shards_opt[5] = 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) { 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 /// * None
/// ///
pub fn set_global_deployment_id(id: Uuid) { pub fn set_global_deployment_id(id: Uuid) {
globalDeploymentIDPtr.set(id).unwrap(); globalDeploymentIDPtr.set(id).expect("operation should succeed");
} }
/// Get the global deployment id /// Get the global deployment id
@@ -274,7 +274,7 @@ pub(crate) type TypeLocalDiskSetDrives = Vec<Vec<Vec<Option<DiskStore>>>>;
/// # Returns /// # Returns
/// * None /// * None
pub fn set_global_region(region: s3s::region::Region) { 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 /// Get the global region
crates/ecstore/src/store/rebalance.rs
+6 -6
View File
@@ -36,7 +36,7 @@ impl ECStore {
// if disk.is_none() { // if disk.is_none() {
// continue; // continue;
// } // }
// // let disk = disk.as_ref().unwrap().clone(); // // let disk = disk.as_ref().expect("operation should succeed").clone();
// // futures.push(disk.delete( // // futures.push(disk.delete(
// // bucket, // // bucket,
// // prefix, // // prefix,
@@ -315,7 +315,7 @@ impl ECStore {
return Ok((pinfo.clone(), self.pools_with_object(&ress, opts).await)); 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 { if err == &Error::ErasureReadQuorum && !opts.metadata_chg {
return Ok((pinfo.clone(), self.pools_with_object(&ress, opts).await)); 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; let mut pool_meta = self.pool_meta.write().await;
*pool_meta = meta; *pool_meta = meta;
// *self.pool_meta.write().unwrap() = meta; // *self.pool_meta.write().expect("operation should succeed") = meta;
Ok(()) Ok(())
} }
@@ -638,7 +638,7 @@ mod tests {
fn object_info_with_mod_time(unix_ts: i64, delete_marker: bool) -> ObjectInfo { fn object_info_with_mod_time(unix_ts: i64, delete_marker: bool) -> ObjectInfo {
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, delete_marker,
..Default::default() ..Default::default()
} }
@@ -660,7 +660,7 @@ mod tests {
]; ];
let (info, idx) = 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_eq!(idx, 1);
assert!(info.delete_marker); 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); 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 // Use the pool's shared metrics for recording
let _metrics_lock = self.metrics.lock().unwrap_or_else(|e| e.into_inner()); 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 // Record acquisition
pool_metrics.total_acquires.fetch_add(1, Ordering::Relaxed); pool_metrics.total_acquires.fetch_add(1, Ordering::Relaxed);
@@ -406,7 +406,7 @@ impl PoolTier {
// Use the pool's shared metrics for recording // Use the pool's shared metrics for recording
let _metrics_lock = self.metrics.lock().unwrap_or_else(|e| e.into_inner()); 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 // Record acquisition
pool_metrics.total_acquires.fetch_add(1, Ordering::Relaxed); 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>>, metrics: &Arc<RwLock<ExpirationMetrics>>,
) -> SwiftResult<()> { ) -> SwiftResult<()> {
let start_time = SystemTime::now(); 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!( debug!(
event = EVENT_SWIFT_EXPIRATION_ITERATION_SUMMARY, event = EVENT_SWIFT_EXPIRATION_ITERATION_SUMMARY,
@@ -375,7 +375,7 @@ impl ExpirationWorker {
} }
// Remove from queue and add to batch // 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 drop(queue); // Release lock
batch.push(entry); batch.push(entry);
@@ -452,7 +452,7 @@ impl ExpirationWorker {
} }
// Update metrics // 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; let mut m = metrics.write().await;
m.objects_scanned += scanned_count; m.objects_scanned += scanned_count;
m.objects_deleted += deleted_count; m.objects_deleted += deleted_count;
@@ -589,9 +589,9 @@ mod tests {
})); }));
// Should pop in order: 1000, 2000, 3000 // Should pop in order: 1000, 2000, 3000
assert_eq!(heap.pop().unwrap().0.expires_at, 1000); assert_eq!(heap.pop().expect("operation should succeed").0.expires_at, 1000);
assert_eq!(heap.pop().unwrap().0.expires_at, 2000); assert_eq!(heap.pop().expect("operation should succeed").0.expires_at, 2000);
assert_eq!(heap.pop().unwrap().0.expires_at, 3000); assert_eq!(heap.pop().expect("operation should succeed").0.expires_at, 3000);
} }
#[test] #[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 reader = BufReader::new(Cursor::new(data.to_vec()));
let mut encrypt_reader = EncryptReader::new(reader, key, nonce); let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new(); 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 encrypted
} }
@@ -674,14 +674,14 @@ mod tests {
// Encrypt // Encrypt
let mut encrypt_reader = encrypt_reader; let mut encrypt_reader = encrypt_reader;
let mut encrypted = Vec::new(); 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 // Decrypt using DecryptReader
let reader = Cursor::new(encrypted.clone()); let reader = Cursor::new(encrypted.clone());
let decrypt_reader = DecryptReader::new(reader, key, nonce); let decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypt_reader = decrypt_reader; let mut decrypt_reader = decrypt_reader;
let mut decrypted = Vec::new(); 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); assert_eq!(&decrypted, data);
} }
@@ -700,7 +700,7 @@ mod tests {
let encrypt_reader = EncryptReader::new(reader, key, nonce); let encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypt_reader = encrypt_reader; let mut encrypt_reader = encrypt_reader;
let mut encrypted = Vec::new(); 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 // Now test DecryptReader
@@ -708,7 +708,7 @@ mod tests {
let decrypt_reader = DecryptReader::new(reader, key, nonce); let decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypt_reader = decrypt_reader; let mut decrypt_reader = decrypt_reader;
let mut decrypted = Vec::new(); 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); assert_eq!(&decrypted, data);
} }
@@ -728,13 +728,13 @@ mod tests {
let encrypt_reader = EncryptReader::new(reader, key, nonce); let encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypt_reader = encrypt_reader; let mut encrypt_reader = encrypt_reader;
let mut encrypted = Vec::new(); 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 reader = std::io::Cursor::new(encrypted.clone());
let decrypt_reader = DecryptReader::new(reader, key, nonce); let decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypt_reader = decrypt_reader; let mut decrypt_reader = decrypt_reader;
let mut decrypted = Vec::new(); 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); assert_eq!(&decrypted, &data);
} }
@@ -752,12 +752,12 @@ mod tests {
let reader = Cursor::new(data.clone()); let reader = Cursor::new(data.clone());
let mut encrypt_reader = EncryptReader::new(reader, key, nonce); let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new(); 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 reader = ChunkedCursor::new(encrypted, 3);
let mut decrypt_reader = DecryptReader::new(reader, key, nonce); let mut decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypted = Vec::new(); 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); assert_eq!(decrypted, data);
} }
@@ -775,12 +775,12 @@ mod tests {
let reader = Cursor::new(data.clone()); let reader = Cursor::new(data.clone());
let mut encrypt_reader = EncryptReader::new(reader, key, nonce); let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new(); 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 reader = PendingChunkedCursor::new(encrypted, 3);
let mut decrypt_reader = DecryptReader::new(reader, key, nonce); let mut decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypted = Vec::new(); 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); assert_eq!(decrypted, data);
} }
@@ -798,7 +798,7 @@ mod tests {
let reader = Cursor::new(data.clone()); let reader = Cursor::new(data.clone());
let mut encrypt_reader = EncryptReader::new(reader, key, nonce); let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new(); 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 reader = ChunkedCursor::new(encrypted, 8192);
let decrypt_reader = DecryptReader::new(reader, key, nonce); let decrypt_reader = DecryptReader::new(reader, key, nonce);
@@ -806,7 +806,7 @@ mod tests {
let mut decrypted = Vec::new(); let mut decrypted = Vec::new();
while let Some(chunk) = stream.next().await { while let Some(chunk) = stream.next().await {
let bytes = chunk.unwrap(); let bytes = chunk.expect("operation should succeed");
decrypted.extend_from_slice(&bytes); decrypted.extend_from_slice(&bytes);
} }
@@ -826,7 +826,7 @@ mod tests {
let reader = Cursor::new(data.clone()); let reader = Cursor::new(data.clone());
let mut encrypt_reader = EncryptReader::new(reader, key, nonce); let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new(); 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 reader = ChunkedCursor::new(encrypted, 8192);
let decrypt_reader = DecryptReader::new(reader, key, nonce); let decrypt_reader = DecryptReader::new(reader, key, nonce);
@@ -835,7 +835,7 @@ mod tests {
let mut decrypted = Vec::new(); let mut decrypted = Vec::new();
while let Some(chunk) = stream.next().await { while let Some(chunk) = stream.next().await {
let bytes = chunk.unwrap(); let bytes = chunk.expect("operation should succeed");
decrypted.extend_from_slice(&bytes); decrypted.extend_from_slice(&bytes);
} }
@@ -857,7 +857,7 @@ mod tests {
let reader = BufReader::new(Cursor::new(data.to_vec())); let reader = BufReader::new(Cursor::new(data.to_vec()));
let mut encrypt_reader = EncryptReader::new(reader, key, nonce); let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new(); 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 encrypted
} }
@@ -871,7 +871,7 @@ mod tests {
let reader = BufReader::new(Cursor::new(combined)); let reader = BufReader::new(Cursor::new(combined));
let mut decrypt_reader = DecryptReader::new_multipart(reader, key, base_nonce, vec![1, 2]); let mut decrypt_reader = DecryptReader::new_multipart(reader, key, base_nonce, vec![1, 2]);
let mut decrypted = Vec::new(); 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()); let mut expected = Vec::with_capacity(part_one.len() + part_two.len());
expected.extend_from_slice(&part_one); expected.extend_from_slice(&part_one);
@@ -891,7 +891,7 @@ mod tests {
let reader = Cursor::new(data); let reader = Cursor::new(data);
let mut encrypt_reader = EncryptReader::new(reader, key, nonce); let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
let mut encrypted = Vec::new(); 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); let payloads = extract_encrypted_payloads(&encrypted);
assert!(payloads.len() >= 2); assert!(payloads.len() >= 2);
@@ -920,7 +920,7 @@ mod tests {
let reader = Cursor::new(encrypted); let reader = Cursor::new(encrypted);
let mut decrypt_reader = DecryptReader::new(reader, key, nonce); let mut decrypt_reader = DecryptReader::new(reader, key, nonce);
let mut decrypted = Vec::new(); 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); assert_eq!(decrypted, data);
} }
@@ -945,7 +945,7 @@ mod tests {
let reader = BufReader::new(Cursor::new(combined)); let reader = BufReader::new(Cursor::new(combined));
let mut decrypt_reader = DecryptReader::new_multipart(reader, key, base_nonce, vec![1, 2]); let mut decrypt_reader = DecryptReader::new_multipart(reader, key, base_nonce, vec![1, 2]);
let mut decrypted = Vec::new(); 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()); let mut expected = Vec::with_capacity(part_one.len() + part_two.len());
expected.extend_from_slice(&part_one); 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 thiserror::Error;
use url::Url; 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. /// NetError represents errors that can occur in network operations.
#[derive(Error, Debug)] #[derive(Error, Debug)]
@@ -332,7 +332,7 @@ impl<'de> serde::Deserialize<'de> for ParsedURL {
{ {
let s: String = serde::Deserialize::deserialize(deserializer)?; let s: String = serde::Deserialize::deserialize(deserializer)?;
if s.is_empty() { if s.is_empty() {
Ok(ParsedURL(Url::parse("about:blank").unwrap())) Ok(ParsedURL(Url::parse("about:blank").expect("operation should succeed")))
} else { } else {
parse_url(&s).map_err(serde::de::Error::custom) 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() { 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)?; parse_host(&host_port)?;
} }
} }
@@ -485,7 +485,7 @@ mod tests {
fn parse_host_with_valid_ipv4() { fn parse_host_with_valid_ipv4() {
let result = parse_host("192.168.1.1:8080"); let result = parse_host("192.168.1.1:8080");
assert!(result.is_ok()); 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.name, "192.168.1.1");
assert_eq!(host.port, Some(8080)); assert_eq!(host.port, Some(8080));
} }
@@ -494,7 +494,7 @@ mod tests {
fn parse_host_with_valid_hostname() { fn parse_host_with_valid_hostname() {
let result = parse_host("example.com:443"); let result = parse_host("example.com:443");
assert!(result.is_ok()); assert!(result.is_ok());
let host = result.unwrap(); let host = result.expect("operation should succeed");
assert_eq!(host.name, "example.com"); assert_eq!(host.name, "example.com");
assert_eq!(host.port, Some(443)); assert_eq!(host.port, Some(443));
} }
@@ -503,7 +503,7 @@ mod tests {
fn parse_host_with_ipv6_brackets() { fn parse_host_with_ipv6_brackets() {
let result = parse_host("[::1]:8080"); let result = parse_host("[::1]:8080");
assert!(result.is_ok()); assert!(result.is_ok());
let host = result.unwrap(); let host = result.expect("operation should succeed");
assert_eq!(host.name, "::1"); assert_eq!(host.name, "::1");
assert_eq!(host.port, Some(8080)); assert_eq!(host.port, Some(8080));
} }
@@ -512,7 +512,7 @@ mod tests {
fn parse_host_with_bare_ipv6_without_port() { fn parse_host_with_bare_ipv6_without_port() {
let result = parse_host("::1"); let result = parse_host("::1");
assert!(result.is_ok()); assert!(result.is_ok());
let host = result.unwrap(); let host = result.expect("operation should succeed");
assert_eq!(host.name, "::1"); assert_eq!(host.name, "::1");
assert_eq!(host.port, None); assert_eq!(host.port, None);
} }
@@ -521,7 +521,7 @@ mod tests {
fn parse_host_with_ipv6_zone_without_port() { fn parse_host_with_ipv6_zone_without_port() {
let result = parse_host("fe80::1%eth0"); let result = parse_host("fe80::1%eth0");
assert!(result.is_ok()); 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.name, "fe80::1%eth0");
assert_eq!(host.port, None); assert_eq!(host.port, None);
} }
@@ -530,7 +530,7 @@ mod tests {
fn parse_host_with_bracketed_ipv6_zone_and_port() { fn parse_host_with_bracketed_ipv6_zone_and_port() {
let result = parse_host("[fe80::1%eth0]:9000"); let result = parse_host("[fe80::1%eth0]:9000");
assert!(result.is_ok()); 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.name, "fe80::1%eth0");
assert_eq!(host.port, Some(9000)); assert_eq!(host.port, Some(9000));
} }
@@ -539,7 +539,7 @@ mod tests {
fn parse_host_with_bracketed_ipv6_without_port() { fn parse_host_with_bracketed_ipv6_without_port() {
let result = parse_host("[::1]"); let result = parse_host("[::1]");
assert!(result.is_ok()); assert!(result.is_ok());
let host = result.unwrap(); let host = result.expect("operation should succeed");
assert_eq!(host.name, "::1"); assert_eq!(host.name, "::1");
assert_eq!(host.port, None); assert_eq!(host.port, None);
} }
@@ -560,7 +560,7 @@ mod tests {
fn parse_host_without_port() { fn parse_host_without_port() {
let result = parse_host("example.com"); let result = parse_host("example.com");
assert!(result.is_ok()); assert!(result.is_ok());
let host = result.unwrap(); let host = result.expect("operation should succeed");
assert_eq!(host.name, "example.com"); assert_eq!(host.name, "example.com");
assert_eq!(host.port, None); assert_eq!(host.port, None);
} }
@@ -605,7 +605,7 @@ mod tests {
fn parse_url_with_valid_http_url() { fn parse_url_with_valid_http_url() {
let result = parse_url("http://example.com/path"); let result = parse_url("http://example.com/path");
assert!(result.is_ok()); assert!(result.is_ok());
let parsed = result.unwrap(); let parsed = result.expect("operation should succeed");
assert_eq!(parsed.hostname(), "example.com"); assert_eq!(parsed.hostname(), "example.com");
assert_eq!(parsed.port(), "80"); assert_eq!(parsed.port(), "80");
assert_eq!(parsed.scheme(), "http"); assert_eq!(parsed.scheme(), "http");
@@ -616,7 +616,7 @@ mod tests {
fn parse_url_with_explicit_default_https_port() { fn parse_url_with_explicit_default_https_port() {
let result = parse_url("https://example.com:443/path"); let result = parse_url("https://example.com:443/path");
assert!(result.is_ok()); assert!(result.is_ok());
let parsed = result.unwrap(); let parsed = result.expect("operation should succeed");
assert_eq!(parsed.to_string(), "https://example.com/path"); assert_eq!(parsed.to_string(), "https://example.com/path");
} }
@@ -636,7 +636,7 @@ mod tests {
fn parse_url_normalizes_path() { fn parse_url_normalizes_path() {
let result = parse_url("http://example.com//path/../path/"); let result = parse_url("http://example.com//path/../path/");
assert!(result.is_ok()); assert!(result.is_ok());
let parsed = result.unwrap(); let parsed = result.expect("operation should succeed");
assert_eq!(parsed.to_string(), "http://example.com/path/"); 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 data = serde_json::to_vec(&response).map_err(|e| s3_error!(InternalError, "failed to serialize response: {}", e))?;
let mut headers = HeaderMap::new(); 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)) 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 data = serde_json::to_vec(&response).map_err(|e| s3_error!(InternalError, "failed to serialize response: {}", e))?;
let mut headers = HeaderMap::new(); 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)) 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))?; serde_json::to_vec(&response).map_err(|e| s3_error!(InternalError, "failed to serialize response: {}", e))?;
let mut headers = HeaderMap::new(); 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)) Ok(S3Response::with_headers((StatusCode::OK, Body::from(data)), headers))
} }