1use crate::commands::profiles::ProfileState;
2use crate::error::Result;
3use crate::s3::S3State;
4use aws_sdk_s3::primitives::ByteStream;
5use aws_sdk_s3::types::{
6 CompletedMultipartUpload, CompletedPart, Delete, MetadataDirective, ObjectCannedAcl,
7 ObjectIdentifier, Permission, TaggingDirective,
8};
9use aws_sdk_s3::Client;
10use std::collections::HashSet;
11use std::path::Path;
12use tauri::State;
13
14pub(super) fn validate_operation_profile(expected: Option<&str>, actual: &str) -> Result<()> {
15 if expected != Some(actual) {
16 return Err(crate::error::AppError::ConfigError(
17 "The active profile changed. Copy or select the items again.".to_string(),
18 ));
19 }
20 Ok(())
21}
22
23async fn detect_and_cache_bucket_region(
24 active_profile: &crate::credentials::Profile,
25 bucket_name: &str,
26 s3_state: &S3State,
27) -> Result<Option<String>> {
28 let retry_client = {
29 let mut s3_manager = s3_state.write().await;
30 s3_manager.get_client(active_profile).await?.clone()
31 };
32
33 let detected_region = crate::s3::get_bucket_region(&retry_client, bucket_name)
34 .await
35 .ok();
36
37 if let Some(ref new_region) = detected_region {
38 let mut s3_manager = s3_state.write().await;
39 s3_manager.set_bucket_region(active_profile, bucket_name, new_region.clone());
40 }
41
42 Ok(detected_region)
43}
44
45fn validate_folder_target(
46 source_bucket: &str,
47 source_key: &str,
48 destination_bucket: &str,
49 destination_key: &str,
50) -> Result<()> {
51 if source_bucket != destination_bucket {
52 return Ok(());
53 }
54
55 if source_key.ends_with('/') {
56 let normalized_destination = if destination_key.ends_with('/') {
57 destination_key.to_string()
58 } else {
59 format!("{}/", destination_key)
60 };
61
62 if normalized_destination.starts_with(source_key) {
63 return Err(crate::error::AppError::ConfigError(format!(
64 "Cannot copy or move folder '{}' into its own subtree '{}'",
65 source_key, destination_key
66 )));
67 }
68 }
69
70 Ok(())
71}
72
73fn parse_object_canned_acl(value: &str) -> Result<ObjectCannedAcl> {
74 match value {
75 "private" => Ok(ObjectCannedAcl::Private),
76 "public-read" => Ok(ObjectCannedAcl::PublicRead),
77 "public-read-write" => Ok(ObjectCannedAcl::PublicReadWrite),
78 "authenticated-read" => Ok(ObjectCannedAcl::AuthenticatedRead),
79 "aws-exec-read" => Ok(ObjectCannedAcl::AwsExecRead),
80 "bucket-owner-read" => Ok(ObjectCannedAcl::BucketOwnerRead),
81 "bucket-owner-full-control" => Ok(ObjectCannedAcl::BucketOwnerFullControl),
82 _ => Err(crate::error::AppError::ConfigError(format!(
83 "Unsupported object ACL '{}'",
84 value
85 ))),
86 }
87}
88
89fn classify_acl_error(error: &str) -> Option<(&'static str, &'static str)> {
90 let normalized = error.to_ascii_lowercase();
91
92 if normalized.contains("accesscontrollistnotsupported")
93 || normalized.contains("acl is not supported")
94 || normalized.contains("acls are not supported")
95 || normalized.contains("bucket does not allow acls")
96 || normalized.contains("the bucket does not allow acls")
97 || normalized.contains("notimplemented")
98 || normalized.contains("not implemented")
99 || normalized.contains("methodnotallowed")
100 || normalized.contains("method not allowed")
101 || normalized.contains("xnotimplemented")
102 {
103 return Some((
104 "unsupported",
105 "ACL permissions are not supported for this bucket or provider. The bucket may use Object Ownership with ACLs disabled.",
106 ));
107 }
108
109 if normalized.contains("accessdenied")
110 || normalized.contains("access denied")
111 || normalized.contains("forbidden")
112 || normalized.contains("status code: 403")
113 || normalized.contains(" 403")
114 {
115 return Some((
116 "access_denied",
117 "Your credentials do not allow viewing or changing ACL permissions for this object.",
118 ));
119 }
120
121 None
122}
123
124fn s3_error_message<E: aws_sdk_s3::error::ProvideErrorMetadata>(
125 error: &aws_sdk_s3::error::SdkError<E>,
126) -> String {
127 match error.as_service_error() {
128 Some(service) => format!(
129 "{}: {}",
130 service.code().unwrap_or("S3Error"),
131 service.message().unwrap_or("Request failed"),
132 ),
133 None => error.to_string(),
134 }
135}
136
137fn map_acl_error<E: aws_sdk_s3::error::ProvideErrorMetadata>(
138 error: aws_sdk_s3::error::SdkError<E>,
139) -> crate::error::AppError {
140 let error_string = s3_error_message(&error);
141 if let Some((_, message)) = classify_acl_error(&error_string) {
142 crate::error::AppError::S3Error(message.to_string())
143 } else {
144 crate::error::AppError::S3Error(error_string)
145 }
146}
147
148#[derive(Debug, Default)]
149struct CopyAclHeaders {
150 full_control: Vec<String>,
151 read: Vec<String>,
152 read_acp: Vec<String>,
153 write_acp: Vec<String>,
154}
155
156impl CopyAclHeaders {
157 fn joined(values: &[String]) -> Option<String> {
158 (!values.is_empty()).then(|| values.join(", "))
159 }
160}
161
162fn quoted_acl_value(kind: &str, value: &str) -> Result<String> {
163 if value.chars().any(|character| character.is_control()) {
164 return Err(crate::error::AppError::InvalidContent(
165 "Object ACL contains an invalid control character".to_string(),
166 ));
167 }
168 let escaped = value.replace('\\', "\\\\").replace('"', "\\\"");
169 Ok(format!("{kind}=\"{escaped}\""))
170}
171
172fn acl_grantee_header(grantee: &aws_sdk_s3::types::Grantee) -> Result<String> {
173 match grantee.r#type() {
174 aws_sdk_s3::types::Type::CanonicalUser => grantee
175 .id()
176 .ok_or_else(|| {
177 crate::error::AppError::InvalidContent(
178 "Object ACL canonical user is missing its ID".to_string(),
179 )
180 })
181 .and_then(|value| quoted_acl_value("id", value)),
182 aws_sdk_s3::types::Type::AmazonCustomerByEmail => grantee
183 .email_address()
184 .ok_or_else(|| {
185 crate::error::AppError::InvalidContent(
186 "Object ACL email grantee is missing its address".to_string(),
187 )
188 })
189 .and_then(|value| quoted_acl_value("emailAddress", value)),
190 aws_sdk_s3::types::Type::Group => grantee
191 .uri()
192 .ok_or_else(|| {
193 crate::error::AppError::InvalidContent(
194 "Object ACL group grantee is missing its URI".to_string(),
195 )
196 })
197 .and_then(|value| quoted_acl_value("uri", value)),
198 other => Err(crate::error::AppError::InvalidContent(format!(
199 "Cannot safely preserve unsupported ACL grantee type '{}'",
200 other.as_str()
201 ))),
202 }
203}
204
205fn copy_acl_headers(
206 output: &aws_sdk_s3::operation::get_object_acl::GetObjectAclOutput,
207) -> Result<CopyAclHeaders> {
208 let mut headers = CopyAclHeaders::default();
209 for grant in output.grants() {
210 let Some(grantee) = grant.grantee() else {
211 continue;
212 };
213 let Some(permission) = grant.permission() else {
214 continue;
215 };
216 let header = acl_grantee_header(grantee)?;
217
218 match permission {
219 Permission::FullControl => headers.full_control.push(header),
220 Permission::Read => headers.read.push(header),
221 Permission::ReadAcp => headers.read_acp.push(header),
222 Permission::WriteAcp => headers.write_acp.push(header),
223 other => {
224 return Err(crate::error::AppError::InvalidContent(format!(
225 "Cannot safely preserve unsupported object ACL permission '{}'",
226 other.as_str()
227 )))
228 }
229 }
230 }
231 Ok(headers)
232}
233
234fn copy_source(bucket_name: &str, key: &str, version_id: Option<&str>) -> String {
235 let base = format!("{}/{}", bucket_name, urlencoding::encode(key));
236 match version_id {
237 Some(version_id) => format!("{base}?versionId={}", urlencoding::encode(version_id)),
238 None => base,
239 }
240}
241
242fn encode_object_tags(tags: &[aws_sdk_s3::types::Tag]) -> Option<String> {
243 (!tags.is_empty()).then(|| {
244 tags.iter()
245 .map(|tag| {
246 format!(
247 "{}={}",
248 urlencoding::encode(tag.key()),
249 urlencoding::encode(tag.value())
250 )
251 })
252 .collect::<Vec<_>>()
253 .join("&")
254 })
255}
256
257async fn multipart_copy_content_type(
258 client: &Client,
259 bucket_name: &str,
260 key: &str,
261 content_type: &str,
262 head: &aws_sdk_s3::operation::head_object::HeadObjectOutput,
263 acl_headers: Option<&CopyAclHeaders>,
264) -> Result<()> {
265 multipart_copy_object(
266 (client, bucket_name, key),
267 (client, bucket_name, key),
268 content_type,
269 head,
270 acl_headers,
271 )
272 .await
273}
274
275async fn multipart_copy_object(
276 source: (&Client, &str, &str),
277 destination: (&Client, &str, &str),
278 content_type: &str,
279 head: &aws_sdk_s3::operation::head_object::HeadObjectOutput,
280 acl_headers: Option<&CopyAclHeaders>,
281) -> Result<()> {
282 let (source_client, source_bucket, source_key) = source;
283 let (client, bucket_name, key) = destination;
284 if head.e_tag().is_none() {
285 return Err(crate::error::AppError::S3Error(
286 "Cannot safely copy an object without an ETag".into(),
287 ));
288 }
289 let object_size = head
290 .content_length()
291 .and_then(|value| u64::try_from(value).ok())
292 .ok_or_else(|| {
293 crate::error::AppError::S3Error(format!(
294 "S3 returned an invalid size for s3://{bucket_name}/{key}"
295 ))
296 })?;
297 let copy_source = copy_source(source_bucket, source_key, head.version_id());
298 let tag_output = match source_client
299 .get_object_tagging()
300 .bucket(source_bucket)
301 .key(source_key)
302 .set_version_id(head.version_id.clone())
303 .send()
304 .await
305 {
306 Ok(output) => Some(output),
307 Err(error) => {
308 let error_string = s3_error_message(&error);
309 if matches!(classify_acl_error(&error_string), Some(("unsupported", _))) {
310 None
311 } else {
312 return Err(crate::error::AppError::S3Error(format!(
313 "Cannot safely copy the object because the object's tags could not be read and preserved: {error_string}"
314 )));
315 }
316 }
317 };
318 let tagging = tag_output
319 .as_ref()
320 .and_then(|output| encode_object_tags(output.tag_set()));
321 let plan = crate::s3::plan_multipart_upload(object_size)?;
322
323 let build_create_request = |acl: Option<&CopyAclHeaders>| {
324 let mut request = client
325 .create_multipart_upload()
326 .bucket(bucket_name)
327 .key(key)
328 .content_type(content_type)
329 .set_cache_control(head.cache_control.clone())
330 .set_content_disposition(head.content_disposition.clone())
331 .set_content_encoding(head.content_encoding.clone())
332 .set_content_language(head.content_language.clone())
333 .set_metadata(head.metadata.clone())
334 .set_website_redirect_location(head.website_redirect_location.clone())
335 .set_storage_class(head.storage_class.clone())
336 .set_server_side_encryption(head.server_side_encryption.clone())
337 .set_ssekms_key_id(head.ssekms_key_id.clone())
338 .set_bucket_key_enabled(head.bucket_key_enabled)
339 .set_object_lock_mode(head.object_lock_mode.clone())
340 .set_object_lock_retain_until_date(head.object_lock_retain_until_date)
341 .set_object_lock_legal_hold_status(head.object_lock_legal_hold_status.clone())
342 .set_tagging(tagging.clone());
343
344 #[allow(deprecated)]
345 {
346 request = request.set_expires(head.expires);
347 }
348
349 if let Some(acl) = acl {
350 request = request
351 .set_grant_full_control(CopyAclHeaders::joined(&acl.full_control))
352 .set_grant_read(CopyAclHeaders::joined(&acl.read))
353 .set_grant_read_acp(CopyAclHeaders::joined(&acl.read_acp))
354 .set_grant_write_acp(CopyAclHeaders::joined(&acl.write_acp));
355 }
356
357 request
358 };
359
360 let created = match build_create_request(acl_headers).send().await {
361 Ok(output) => output,
362 Err(error) => {
363 let error_string = s3_error_message(&error);
364 if acl_headers.is_some()
365 && matches!(classify_acl_error(&error_string), Some(("unsupported", _)))
366 {
367 build_create_request(None).send().await.map_err(|retry_error| {
368 crate::error::AppError::S3Error(format!(
369 "Could not start multipart object copy after retrying without ACL headers: {retry_error}"
370 ))
371 })?
372 } else {
373 return Err(crate::error::AppError::S3Error(format!(
374 "Could not start multipart object copy: {error_string}"
375 )));
376 }
377 }
378 };
379 let upload_id = created.upload_id().ok_or_else(|| {
380 crate::error::AppError::S3Error(format!(
381 "S3 did not return an upload ID while copying the object for s3://{bucket_name}/{key}"
382 ))
383 })?;
384 let mut guard = crate::s3::MultipartUploadGuard::new(
385 client.clone(),
386 bucket_name,
387 key,
388 upload_id.to_string(),
389 );
390
391 let copy_result: Result<()> = async {
392 let mut completed_parts = Vec::with_capacity(plan.parts.len());
393 for part in &plan.parts {
394 let end = part.offset + part.length - 1;
395 let output = client
396 .upload_part_copy()
397 .bucket(bucket_name)
398 .key(key)
399 .upload_id(guard.upload_id())
400 .part_number(part.number)
401 .copy_source(©_source)
402 .copy_source_range(format!("bytes={}-{}", part.offset, end))
403 .set_copy_source_if_match(head.e_tag.clone())
404 .send()
405 .await
406 .map_err(|error| {
407 crate::error::AppError::S3Error(format!(
408 "Multipart object copy failed at part {} of {} for s3://{bucket_name}/{key}: {error}",
409 part.number,
410 plan.parts.len()
411 ))
412 })?;
413 let e_tag = output
414 .copy_part_result()
415 .and_then(|result| result.e_tag())
416 .ok_or_else(|| {
417 crate::error::AppError::S3Error(format!(
418 "S3 did not return an ETag for copied part {} of s3://{bucket_name}/{key}",
419 part.number
420 ))
421 })?;
422 completed_parts.push(
423 CompletedPart::builder()
424 .part_number(part.number)
425 .e_tag(e_tag)
426 .build(),
427 );
428 }
429
430 client
431 .complete_multipart_upload()
432 .set_if_none_match((source_bucket != bucket_name || source_key != key).then(|| "*".to_string()))
433 .bucket(bucket_name)
434 .key(key)
435 .upload_id(guard.upload_id())
436 .multipart_upload(
437 CompletedMultipartUpload::builder()
438 .set_parts(Some(completed_parts))
439 .build(),
440 )
441 .send()
442 .await
443 .map_err(|error| {
444 crate::error::AppError::S3Error(format!(
445 "Could not complete multipart object copy for s3://{bucket_name}/{key}: {error}"
446 ))
447 })?;
448
449 Ok(())
450 }
451 .await;
452
453 if let Err(error) = copy_result {
454 if let Err(abort_error) = guard.abort().await {
455 log::error!("{}", abort_error);
456 }
457 return Err(error);
458 }
459
460 guard.disarm();
461 Ok(())
462}
463
464async fn list_keys_for_permission_target(
465 client: &Client,
466 bucket_name: &str,
467 key: &str,
468 is_folder: bool,
469) -> Result<Vec<String>> {
470 if !is_folder {
471 return Ok(vec![key.to_string()]);
472 }
473
474 let mut keys: Vec<String> = crate::s3::listing::list_recursive(client, bucket_name, key)
475 .await?
476 .into_iter()
477 .filter_map(|object| object.key)
478 .collect();
479 if keys.is_empty() {
480 keys.push(key.to_string());
481 }
482
483 Ok(keys)
484}
485
486#[tauri::command]
487pub async fn put_object(
488 bucket_name: String,
489 bucket_region: Option<String>,
490 key: String,
491 local_path: Option<String>,
492 expected_profile_id: String,
493 profile_state: State<'_, ProfileState>,
494 s3_state: State<'_, S3State>,
495) -> Result<()> {
496 let profile_manager = profile_state.read().await;
498 let active_profile = profile_manager
499 .get_active_profile()
500 .await?
501 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
502 drop(profile_manager);
503 super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
504 put_object_with_profile(
505 bucket_name,
506 bucket_region,
507 key,
508 local_path,
509 active_profile,
510 &s3_state,
511 )
512 .await
513}
514
515async fn put_object_with_profile(
516 bucket_name: String,
517 bucket_region: Option<String>,
518 key: String,
519 local_path: Option<String>,
520 active_profile: crate::credentials::Profile,
521 s3_state: &S3State,
522) -> Result<()> {
523 let bucket_region = {
525 let s3_manager = s3_state.read().await;
526 s3_manager.get_bucket_region(&active_profile, &bucket_name)
527 }
528 .or(bucket_region);
529
530 let client = {
532 let mut s3_manager = s3_state.write().await;
533 if let Some(ref d) = bucket_region {
534 s3_manager
535 .get_client_for_region(&active_profile, d)
536 .await?
537 .clone()
538 } else {
539 s3_manager.get_client(&active_profile).await?.clone()
540 }
541 };
542
543 let content_type = local_path
544 .as_ref()
545 .map(|_| crate::s3::infer_content_type(&key));
546 let mut request = client
547 .put_object()
548 .if_none_match("*")
549 .bucket(&bucket_name)
550 .key(&key)
551 .set_content_type(content_type.clone());
552
553 if let Some(ref path) = local_path {
554 let body = ByteStream::from_path(Path::new(path))
556 .await
557 .map_err(|e| crate::error::AppError::IoError(e.to_string()))?;
558 request = request.body(body);
559 } else {
560 request = request.content_length(0).body(ByteStream::from_static(b""));
562 }
563
564 if let Err(err) = request.send().await {
565 if matches!(
566 active_profile.credential_type,
567 crate::credentials::CredentialType::CustomEndpoint { .. }
568 ) {
569 return Err(crate::error::AppError::S3Error(format!(
570 "{}",
571 aws_sdk_s3::error::DisplayErrorContext(&err)
572 )));
573 }
574 log::warn!("put_object failed, attempting region discovery: {}", err);
575
576 if let Some(new_region) =
577 detect_and_cache_bucket_region(&active_profile, &bucket_name, s3_state).await?
578 {
579 let new_client = {
580 let mut s3_manager = s3_state.write().await;
581 s3_manager
582 .get_client_for_region(&active_profile, &new_region)
583 .await?
584 .clone()
585 };
586
587 let mut retry_request = new_client
588 .put_object()
589 .if_none_match("*")
590 .bucket(&bucket_name)
591 .key(&key)
592 .set_content_type(content_type);
593
594 if let Some(ref path) = local_path {
595 let body = ByteStream::from_path(Path::new(path))
596 .await
597 .map_err(|e| crate::error::AppError::IoError(e.to_string()))?;
598 retry_request = retry_request.body(body);
599 } else {
600 retry_request = retry_request
601 .content_length(0)
602 .body(ByteStream::from_static(b""));
603 }
604
605 retry_request.send().await.map_err(|e| {
606 crate::error::AppError::S3Error(format!(
607 "Retry put failed: {}",
608 aws_sdk_s3::error::DisplayErrorContext(&e)
609 ))
610 })?;
611 } else {
612 return Err(crate::error::AppError::S3Error(format!(
613 "{}",
614 aws_sdk_s3::error::DisplayErrorContext(&err)
615 )));
616 }
617 }
618
619 {
620 let mut s3_manager = s3_state.write().await;
621 s3_manager.remove_bucket_cache(&active_profile.id, &bucket_name);
622 }
623
624 Ok(())
625}
626
627#[tauri::command]
628pub async fn get_object(
629 bucket_name: String,
630 bucket_region: Option<String>,
631 key: String,
632 local_path: String,
633 expected_profile_id: String,
634 profile_state: State<'_, ProfileState>,
635 s3_state: State<'_, S3State>,
636) -> Result<()> {
637 let profile_manager = profile_state.read().await;
639 let active_profile = profile_manager
640 .get_active_profile()
641 .await?
642 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
643 drop(profile_manager);
644 super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
645
646 let bucket_region = {
648 let s3_manager = s3_state.read().await;
649 s3_manager.get_bucket_region(&active_profile, &bucket_name)
650 }
651 .or(bucket_region);
652
653 let client = {
655 let mut s3_manager = s3_state.write().await;
656 if let Some(ref d) = bucket_region {
657 s3_manager
658 .get_client_for_region(&active_profile, d)
659 .await?
660 .clone()
661 } else {
662 s3_manager.get_client(&active_profile).await?.clone()
663 }
664 };
665
666 let result = client
668 .get_object()
669 .bucket(&bucket_name)
670 .key(&key)
671 .send()
672 .await;
673
674 let mut output = match result {
675 Ok(output) => output,
676 Err(err) => {
677 log::warn!("get_object failed, attempting region discovery: {}", err);
678
679 if let Some(new_region) =
680 detect_and_cache_bucket_region(&active_profile, &bucket_name, &s3_state).await?
681 {
682 let new_client = {
683 let mut s3_manager = s3_state.write().await;
684 s3_manager
685 .get_client_for_region(&active_profile, &new_region)
686 .await?
687 .clone()
688 };
689
690 new_client
691 .get_object()
692 .bucket(&bucket_name)
693 .key(&key)
694 .send()
695 .await
696 .map_err(|e| {
697 crate::error::AppError::S3Error(format!("Retry get failed: {}", e))
698 })?
699 } else {
700 return Err(crate::error::AppError::S3Error(err.to_string()));
701 }
702 }
703 };
704
705 let destination =
706 crate::transfer::download::DownloadDestination::from_path(Path::new(&local_path), false)?;
707 let mut download = destination.begin()?;
708
709 while let Some(bytes) = output
711 .body
712 .try_next()
713 .await
714 .map_err(|e| crate::error::AppError::S3Error(e.to_string()))?
715 {
716 download
717 .write_all(&bytes)
718 .await
719 .map_err(|e| crate::error::AppError::IoError(e.to_string()))?;
720 }
721
722 download.finish_writing().await?;
723 download.commit()?;
724 Ok(())
725}
726
727#[tauri::command]
728pub async fn delete_object(
729 bucket_name: String,
730 bucket_region: Option<String>,
731 key: String,
732 expected_profile_id: String,
733 profile_state: State<'_, ProfileState>,
734 s3_state: State<'_, S3State>,
735) -> Result<()> {
736 let profile_manager = profile_state.read().await;
738 let active_profile = profile_manager
739 .get_active_profile()
740 .await?
741 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
742 drop(profile_manager);
743 super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
744 delete_object_with_profile(bucket_name, bucket_region, key, active_profile, &s3_state).await
745}
746
747async fn delete_object_with_profile(
748 bucket_name: String,
749 bucket_region: Option<String>,
750 key: String,
751 active_profile: crate::credentials::Profile,
752 s3_state: &S3State,
753) -> Result<()> {
754 let bucket_region = {
756 let s3_manager = s3_state.read().await;
757 s3_manager.get_bucket_region(&active_profile, &bucket_name)
758 }
759 .or(bucket_region);
760
761 let client = {
763 let mut s3_manager = s3_state.write().await;
764 if let Some(ref d) = bucket_region {
765 s3_manager
766 .get_client_for_region(&active_profile, d)
767 .await?
768 .clone()
769 } else {
770 s3_manager.get_client(&active_profile).await?.clone()
771 }
772 };
773
774 let result = client
775 .delete_object()
776 .bucket(&bucket_name)
777 .key(&key)
778 .send()
779 .await;
780
781 if let Err(err) = result {
782 log::warn!("delete_object failed, attempting region discovery: {}", err);
783
784 if let Some(new_region) =
785 detect_and_cache_bucket_region(&active_profile, &bucket_name, s3_state).await?
786 {
787 let new_client = {
788 let mut s3_manager = s3_state.write().await;
789 s3_manager
790 .get_client_for_region(&active_profile, &new_region)
791 .await?
792 .clone()
793 };
794
795 new_client
796 .delete_object()
797 .bucket(&bucket_name)
798 .key(&key)
799 .send()
800 .await
801 .map_err(|e| {
802 crate::error::AppError::S3Error(format!("Retry delete failed: {}", e))
803 })?;
804 } else {
805 return Err(crate::error::AppError::S3Error(err.to_string()));
806 }
807 }
808
809 {
810 let mut s3_manager = s3_state.write().await;
811 s3_manager.remove_bucket_cache(&active_profile.id, &bucket_name);
812 }
813
814 Ok(())
815}
816
817#[allow(clippy::too_many_arguments)]
818#[tauri::command]
819pub async fn copy_object(
820 source_bucket: String,
821 source_region: Option<String>,
822 source_key: String,
823 destination_bucket: String,
824 destination_region: Option<String>,
825 destination_key: String,
826 expected_profile_id: Option<String>,
827 profile_state: State<'_, ProfileState>,
828 s3_state: State<'_, S3State>,
829) -> Result<()> {
830 if source_bucket == destination_bucket && source_key == destination_key {
831 return Ok(());
832 }
833 validate_folder_target(
834 &source_bucket,
835 &source_key,
836 &destination_bucket,
837 &destination_key,
838 )?;
839
840 let profile_manager = profile_state.read().await;
841 let active_profile = profile_manager
842 .get_active_profile()
843 .await?
844 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
845 drop(profile_manager);
846 validate_operation_profile(expected_profile_id.as_deref(), &active_profile.id)?;
847 copy_object_with_profile(
848 source_bucket,
849 source_region,
850 source_key,
851 destination_bucket,
852 destination_region,
853 destination_key,
854 active_profile,
855 &s3_state,
856 )
857 .await
858}
859
860#[allow(clippy::too_many_arguments)]
861async fn copy_object_with_profile(
862 source_bucket: String,
863 source_region: Option<String>,
864 source_key: String,
865 destination_bucket: String,
866 destination_region: Option<String>,
867 destination_key: String,
868 active_profile: crate::credentials::Profile,
869 s3_state: &S3State,
870) -> Result<()> {
871 if source_key.ends_with('/') {
873 log::info!(
875 "Starting recursive folder copy from {}/{} to {}/{}",
876 source_bucket,
877 source_key,
878 destination_bucket,
879 destination_key
880 );
881
882 let source_region_resolved = {
884 let s3_manager = s3_state.read().await;
885 s3_manager.get_bucket_region(&active_profile, &source_bucket)
886 }
887 .or(source_region.clone());
888
889 let client = {
890 let mut s3_manager = s3_state.write().await;
891 if let Some(ref r) = source_region_resolved {
892 s3_manager
893 .get_client_for_region(&active_profile, r)
894 .await?
895 .clone()
896 } else {
897 s3_manager.get_client(&active_profile).await?.clone()
898 }
899 };
900
901 let all_keys: Vec<String> =
902 crate::s3::listing::list_recursive(&client, &source_bucket, &source_key)
903 .await?
904 .into_iter()
905 .filter_map(|object| object.key)
906 .collect();
907
908 log::info!("Found {} objects to copy in folder", all_keys.len());
909 let has_folder_marker = all_keys.iter().any(|key| key == &source_key);
910
911 for key in &all_keys {
913 let relative_path = key.strip_prefix(&source_key).unwrap_or(key);
915 let new_key = format!("{}{}", destination_key, relative_path);
916
917 copy_single_object(
919 &source_bucket,
920 source_region.clone(),
921 key,
922 &destination_bucket,
923 destination_region.clone(),
924 &new_key,
925 &active_profile,
926 s3_state,
927 )
928 .await?;
929 }
930
931 if !has_folder_marker {
933 let destination_marker = if destination_key.ends_with('/') {
934 destination_key
935 } else {
936 format!("{}/", destination_key)
937 };
938 put_object_with_profile(
939 destination_bucket.clone(),
940 destination_region,
941 destination_marker,
942 None,
943 active_profile.clone(),
944 s3_state,
945 )
946 .await?;
947 }
948
949 log::info!(
950 "Recursive folder copy completed: {} objects copied",
951 all_keys.len()
952 );
953 Ok(())
954 } else {
955 copy_single_object(
957 &source_bucket,
958 source_region.clone(),
959 &source_key,
960 &destination_bucket,
961 destination_region,
962 &destination_key,
963 &active_profile,
964 s3_state,
965 )
966 .await?;
967
968 Ok(())
969 }
970}
971
972#[allow(clippy::too_many_arguments)]
974async fn copy_single_object(
975 source_bucket: &str,
976 source_region: Option<String>,
977 source_key: &str,
978 destination_bucket: &str,
979 destination_region: Option<String>,
980 destination_key: &str,
981 active_profile: &crate::credentials::Profile,
982 s3_state: &S3State,
983) -> Result<String> {
984 let destination_region = {
986 let s3_manager = s3_state.read().await;
987 s3_manager.get_bucket_region(active_profile, destination_bucket)
988 }
989 .or(destination_region);
990
991 let client = {
992 let mut s3_manager = s3_state.write().await;
993 if let Some(ref d) = destination_region {
995 s3_manager
996 .get_client_for_region(active_profile, d)
997 .await?
998 .clone()
999 } else {
1000 s3_manager.get_client(active_profile).await?.clone()
1001 }
1002 };
1003
1004 let source_client = {
1005 let mut manager = s3_state.write().await;
1006 let region = manager
1007 .get_bucket_region(active_profile, source_bucket)
1008 .or(source_region);
1009 if let Some(region) = region {
1010 manager
1011 .get_client_for_region(active_profile, ®ion)
1012 .await?
1013 .clone()
1014 } else {
1015 manager.get_client(active_profile).await?.clone()
1016 }
1017 };
1018 let head = source_client
1019 .head_object()
1020 .bucket(source_bucket)
1021 .key(source_key)
1022 .send()
1023 .await
1024 .map_err(|error| crate::error::AppError::S3Error(error.to_string()))?;
1025 let etag = head
1026 .e_tag()
1027 .ok_or_else(|| {
1028 crate::error::AppError::S3Error("Cannot safely copy an object without an ETag".into())
1029 })?
1030 .to_string();
1031 let acl = match source_client
1032 .get_object_acl()
1033 .bucket(source_bucket)
1034 .key(source_key)
1035 .set_version_id(head.version_id.clone())
1036 .send()
1037 .await
1038 {
1039 Ok(output) => Some(copy_acl_headers(&output)?),
1040 Err(error)
1041 if matches!(
1042 classify_acl_error(&s3_error_message(&error)),
1043 Some(("unsupported", _))
1044 ) =>
1045 {
1046 None
1047 }
1048 Err(error) => {
1049 return Err(crate::error::AppError::S3Error(format!(
1050 "Cannot preserve source permissions: {error}"
1051 )))
1052 }
1053 };
1054 copy_object_from_head(
1055 (&source_client, source_bucket, source_key),
1056 (&client, destination_bucket, destination_key),
1057 &head,
1058 acl.as_ref(),
1059 )
1060 .await?;
1061
1062 {
1063 let mut s3_manager = s3_state.write().await;
1064 s3_manager.remove_bucket_cache(&active_profile.id, destination_bucket);
1065 }
1066
1067 Ok(etag)
1068}
1069
1070async fn copy_object_from_head(
1071 source: (&Client, &str, &str),
1072 destination: (&Client, &str, &str),
1073 head: &aws_sdk_s3::operation::head_object::HeadObjectOutput,
1074 acl: Option<&CopyAclHeaders>,
1075) -> Result<()> {
1076 let size = head
1077 .content_length()
1078 .and_then(|value| u64::try_from(value).ok())
1079 .ok_or_else(|| {
1080 crate::error::AppError::S3Error("S3 did not return a valid object size".into())
1081 })?;
1082 if size > 5 * 1024 * 1024 * 1024 {
1083 multipart_copy_object(
1084 source,
1085 destination,
1086 head.content_type().unwrap_or("application/octet-stream"),
1087 head,
1088 acl,
1089 )
1090 .await
1091 } else {
1092 let build = |acl: Option<&CopyAclHeaders>| {
1093 let mut request = destination
1094 .0
1095 .copy_object()
1096 .if_none_match("*")
1097 .bucket(destination.1)
1098 .key(destination.2)
1099 .copy_source(copy_source(source.1, source.2, head.version_id()))
1100 .set_copy_source_if_match(head.e_tag.clone())
1101 .set_storage_class(head.storage_class.clone())
1102 .set_server_side_encryption(head.server_side_encryption.clone())
1103 .set_ssekms_key_id(head.ssekms_key_id.clone())
1104 .set_bucket_key_enabled(head.bucket_key_enabled);
1105 if let Some(acl) = acl {
1106 request = request
1107 .set_grant_full_control(CopyAclHeaders::joined(&acl.full_control))
1108 .set_grant_read(CopyAclHeaders::joined(&acl.read))
1109 .set_grant_read_acp(CopyAclHeaders::joined(&acl.read_acp))
1110 .set_grant_write_acp(CopyAclHeaders::joined(&acl.write_acp));
1111 }
1112 request
1113 };
1114 let mut result = build(acl).send().await;
1115 if let Err(error) = &result {
1116 if acl.is_some()
1117 && matches!(
1118 classify_acl_error(&s3_error_message(error)),
1119 Some(("unsupported", _))
1120 )
1121 {
1122 result = build(None).send().await;
1123 }
1124 }
1125 result.map_err(|error| crate::error::AppError::S3Error(error.to_string()))?;
1126 Ok(())
1127 }
1128}
1129
1130fn build_delete_request(chunk: &[String]) -> Result<Delete> {
1131 let mut delete_ids = Vec::new();
1132 for key in chunk {
1133 let obj_id = ObjectIdentifier::builder().key(key).build().map_err(|e| {
1134 crate::error::AppError::S3Error(format!("Invalid object key '{}': {}", key, e))
1135 })?;
1136 delete_ids.push(obj_id);
1137 }
1138
1139 Delete::builder()
1140 .set_objects(Some(delete_ids))
1141 .build()
1142 .map_err(|e| {
1143 crate::error::AppError::S3Error(format!("Failed to build delete request: {}", e))
1144 })
1145}
1146
1147fn validate_delete_result(
1148 bucket_name: &str,
1149 response: &aws_sdk_s3::operation::delete_objects::DeleteObjectsOutput,
1150) -> Result<()> {
1151 let Some(errors) = response.errors.as_ref() else {
1152 return Ok(());
1153 };
1154
1155 if errors.is_empty() {
1156 return Ok(());
1157 }
1158
1159 let failures = errors
1160 .iter()
1161 .map(|err| {
1162 let key = err.key.as_deref().unwrap_or("<unknown>");
1163 let code = err.code.as_deref().unwrap_or("Unknown");
1164 let message = err.message.as_deref().unwrap_or("Delete failed");
1165 format!("{key} ({code}: {message})")
1166 })
1167 .collect::<Vec<_>>()
1168 .join(", ");
1169
1170 Err(crate::error::AppError::S3Error(format!(
1171 "Failed to delete some objects in bucket '{}': {}",
1172 bucket_name, failures
1173 )))
1174}
1175
1176async fn delete_keys_individually(
1177 client: &aws_sdk_s3::Client,
1178 bucket_name: &str,
1179 keys: &[String],
1180) -> Result<()> {
1181 for key in keys {
1182 client
1183 .delete_object()
1184 .bucket(bucket_name)
1185 .key(key)
1186 .send()
1187 .await
1188 .map_err(|err| {
1189 crate::error::AppError::S3Error(format!(
1190 "Fallback delete failed for '{}': {}",
1191 key, err
1192 ))
1193 })?;
1194 }
1195
1196 Ok(())
1197}
1198
1199#[tauri::command]
1200pub async fn delete_objects(
1201 bucket_name: String,
1202 bucket_region: Option<String>,
1203 keys: Vec<String>,
1204 expected_profile_id: String,
1205 profile_state: State<'_, ProfileState>,
1206 s3_state: State<'_, S3State>,
1207) -> Result<()> {
1208 if keys.is_empty() {
1209 return Ok(());
1210 }
1211
1212 let profile_manager = profile_state.read().await;
1213 let active_profile = profile_manager
1214 .get_active_profile()
1215 .await?
1216 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
1217 drop(profile_manager);
1218 super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
1219 delete_objects_with_profile(bucket_name, bucket_region, keys, active_profile, &s3_state).await
1220}
1221
1222async fn delete_objects_with_profile(
1223 bucket_name: String,
1224 bucket_region: Option<String>,
1225 keys: Vec<String>,
1226 active_profile: crate::credentials::Profile,
1227 s3_state: &S3State,
1228) -> Result<()> {
1229 let bucket_region = {
1231 let s3_manager = s3_state.read().await;
1232 s3_manager.get_bucket_region(&active_profile, &bucket_name)
1233 }
1234 .or(bucket_region);
1235
1236 let client = {
1237 let mut s3_manager = s3_state.write().await;
1238 if let Some(ref d) = bucket_region {
1239 s3_manager
1240 .get_client_for_region(&active_profile, d)
1241 .await?
1242 .clone()
1243 } else {
1244 s3_manager.get_client(&active_profile).await?.clone()
1245 }
1246 };
1247
1248 let result = async {
1249 for chunk in keys.chunks(1000) {
1252 let delete = build_delete_request(chunk)?;
1253
1254 let result = client
1255 .delete_objects()
1256 .bucket(&bucket_name)
1257 .delete(delete.clone())
1258 .send()
1259 .await;
1260
1261 match result {
1262 Ok(output) => validate_delete_result(&bucket_name, &output)?,
1263 Err(err) => {
1264 log::warn!(
1266 "delete_objects failed, attempting region discovery: {}",
1267 err
1268 );
1269 let detected_region = {
1270 let retry_client = {
1271 let mut s3_manager = s3_state.write().await;
1272 s3_manager.get_client(&active_profile).await?.clone()
1273 };
1274 crate::s3::get_bucket_region(&retry_client, &bucket_name)
1275 .await
1276 .ok()
1277 };
1278
1279 if let Some(new_region) = detected_region {
1280 let new_client = {
1281 let mut s3_manager = s3_state.write().await;
1282 s3_manager.set_bucket_region(&active_profile, &bucket_name, new_region.clone());
1283 s3_manager
1284 .get_client_for_region(&active_profile, &new_region)
1285 .await?
1286 .clone()
1287 };
1288
1289 match new_client
1290 .delete_objects()
1291 .bucket(&bucket_name)
1292 .delete(delete)
1293 .send()
1294 .await
1295 {
1296 Ok(output) => validate_delete_result(&bucket_name, &output)?,
1297 Err(retry_err) => {
1298 log::warn!(
1299 "delete_objects retry failed, falling back to single deletes: {}",
1300 retry_err
1301 );
1302 delete_keys_individually(&new_client, &bucket_name, chunk).await?;
1303 }
1304 }
1305 } else {
1306 log::warn!(
1307 "delete_objects region discovery failed, falling back to single deletes: {}",
1308 err
1309 );
1310 delete_keys_individually(&client, &bucket_name, chunk).await?;
1311 }
1312 }
1313 }
1314 }
1315
1316 Ok(())
1317 }
1318 .await;
1319
1320 {
1321 let mut s3_manager = s3_state.write().await;
1322 s3_manager.remove_bucket_cache(&active_profile.id, &bucket_name);
1323 }
1324
1325 result
1326}
1327
1328#[allow(clippy::too_many_arguments)]
1329#[tauri::command]
1330pub async fn move_object(
1331 source_bucket: String,
1332 source_region: Option<String>,
1333 source_key: String,
1334 destination_bucket: String,
1335 destination_region: Option<String>,
1336 destination_key: String,
1337 expected_profile_id: Option<String>,
1338 profile_state: State<'_, ProfileState>,
1339 s3_state: State<'_, S3State>,
1340) -> Result<()> {
1341 if source_bucket == destination_bucket && source_key == destination_key {
1342 return Ok(());
1343 }
1344 validate_folder_target(
1345 &source_bucket,
1346 &source_key,
1347 &destination_bucket,
1348 &destination_key,
1349 )?;
1350
1351 let profile_manager = profile_state.read().await;
1352 let active_profile = profile_manager
1353 .get_active_profile()
1354 .await?
1355 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
1356 drop(profile_manager);
1357 validate_operation_profile(expected_profile_id.as_deref(), &active_profile.id)?;
1358 move_object_with_profile(
1359 source_bucket,
1360 source_region,
1361 source_key,
1362 destination_bucket,
1363 destination_region,
1364 destination_key,
1365 active_profile,
1366 &s3_state,
1367 )
1368 .await
1369}
1370
1371#[allow(clippy::too_many_arguments)]
1372async fn move_object_with_profile(
1373 source_bucket: String,
1374 source_region: Option<String>,
1375 source_key: String,
1376 destination_bucket: String,
1377 destination_region: Option<String>,
1378 destination_key: String,
1379 active_profile: crate::credentials::Profile,
1380 s3_state: &S3State,
1381) -> Result<()> {
1382 if source_key.ends_with('/') {
1384 let source_region_resolved = {
1388 let s3_manager = s3_state.read().await;
1389 s3_manager.get_bucket_region(&active_profile, &source_bucket)
1390 }
1391 .or(source_region.clone());
1392
1393 let client = {
1394 let mut s3_manager = s3_state.write().await;
1395 if let Some(ref r) = source_region_resolved {
1396 s3_manager
1397 .get_client_for_region(&active_profile, r)
1398 .await?
1399 .clone()
1400 } else {
1401 s3_manager.get_client(&active_profile).await?.clone()
1402 }
1403 };
1404
1405 let all_keys: Vec<String> =
1406 crate::s3::listing::list_recursive(&client, &source_bucket, &source_key)
1407 .await?
1408 .into_iter()
1409 .filter_map(|object| object.key)
1410 .collect();
1411
1412 let unique_keys: HashSet<String> = all_keys.into_iter().collect();
1413 let mut all_keys: Vec<String> = unique_keys.into_iter().collect();
1414 all_keys.sort();
1415
1416 let destination_folder_key = if destination_key.ends_with('/') {
1417 destination_key.clone()
1418 } else {
1419 format!("{}/", destination_key)
1420 };
1421
1422 let mut copied = Vec::new();
1423 for key in &all_keys {
1425 if key == &source_key {
1427 let etag = copy_single_object(
1428 &source_bucket,
1429 source_region.clone(),
1430 key,
1431 &destination_bucket,
1432 destination_region.clone(),
1433 &destination_folder_key,
1434 &active_profile,
1435 s3_state,
1436 )
1437 .await?;
1438 copied.push((key.clone(), etag));
1439 } else {
1440 let relative_path = key.strip_prefix(&source_key).unwrap_or(key);
1441 let new_key = format!("{}{}", destination_key, relative_path);
1442
1443 let etag = copy_single_object(
1444 &source_bucket,
1445 source_region.clone(),
1446 key,
1447 &destination_bucket,
1448 destination_region.clone(),
1449 &new_key,
1450 &active_profile,
1451 s3_state,
1452 )
1453 .await?;
1454 copied.push((key.clone(), etag));
1455 }
1456 }
1457
1458 let deletion = async {
1459 for (key, etag) in copied {
1460 delete_copied_source(&client, &source_bucket, &key, &etag).await?;
1461 }
1462 Ok(())
1463 }
1464 .await;
1465 s3_state
1466 .write()
1467 .await
1468 .remove_bucket_cache(&active_profile.id, &source_bucket);
1469
1470 deletion
1471 } else {
1472 let etag = copy_single_object(
1473 &source_bucket,
1474 source_region.clone(),
1475 &source_key,
1476 &destination_bucket,
1477 destination_region,
1478 &destination_key,
1479 &active_profile,
1480 s3_state,
1481 )
1482 .await?;
1483 let client = {
1484 let mut manager = s3_state.write().await;
1485 let region = manager
1486 .get_bucket_region(&active_profile, &source_bucket)
1487 .or(source_region);
1488 match region {
1489 Some(region) => manager
1490 .get_client_for_region(&active_profile, ®ion)
1491 .await?
1492 .clone(),
1493 None => manager.get_client(&active_profile).await?.clone(),
1494 }
1495 };
1496 let result = delete_copied_source(&client, &source_bucket, &source_key, &etag).await;
1497 s3_state
1498 .write()
1499 .await
1500 .remove_bucket_cache(&active_profile.id, &source_bucket);
1501 result
1502 }
1503}
1504
1505async fn delete_copied_source(client: &Client, bucket: &str, key: &str, etag: &str) -> Result<()> {
1506 client.delete_object().bucket(bucket).key(key).if_match(etag).send().await
1507 .map_err(|error| crate::error::AppError::S3Error(format!(
1508 "Copied {key}, but could not conditionally remove the source. It may have changed, or the provider may not support conditional deletion. The destination copy remains: {error}"
1509 )))?;
1510 Ok(())
1511}
1512
1513pub(super) async fn save_object_text(
1514 client: &Client,
1515 bucket: &str,
1516 key: &str,
1517 content: String,
1518 expected_etag: &str,
1519) -> Result<Option<String>> {
1520 let conflict = || {
1521 crate::error::AppError::S3Error(
1522 "This object has changed since it was opened. Copy your edits, then reopen it before saving.".into()
1523 )
1524 };
1525 if expected_etag.is_empty() {
1526 return Err(conflict());
1527 }
1528 let head = client
1529 .head_object()
1530 .bucket(bucket)
1531 .key(key)
1532 .send()
1533 .await
1534 .map_err(|error| crate::error::AppError::S3Error(error.to_string()))?;
1535 if head.e_tag() != Some(expected_etag) {
1536 return Err(conflict());
1537 }
1538 if head.sse_customer_algorithm().is_some() {
1539 return Err(crate::error::AppError::ConfigError(
1540 "This object requires a customer encryption key and cannot be edited safely.".into(),
1541 ));
1542 }
1543 let acl = match client
1544 .get_object_acl()
1545 .bucket(bucket)
1546 .key(key)
1547 .set_version_id(head.version_id.clone())
1548 .send()
1549 .await
1550 {
1551 Ok(output) => Some(copy_acl_headers(&output)?),
1552 Err(error)
1553 if matches!(
1554 classify_acl_error(&s3_error_message(&error)),
1555 Some(("unsupported", _))
1556 ) =>
1557 {
1558 None
1559 }
1560 Err(error) => {
1561 return Err(crate::error::AppError::S3Error(format!(
1562 "Cannot save because the current permissions could not be preserved: {error}"
1563 )))
1564 }
1565 };
1566 let tags = match client
1567 .get_object_tagging()
1568 .bucket(bucket)
1569 .key(key)
1570 .set_version_id(head.version_id.clone())
1571 .send()
1572 .await
1573 {
1574 Ok(output) => encode_object_tags(output.tag_set()),
1575 Err(error)
1576 if matches!(
1577 classify_acl_error(&s3_error_message(&error)),
1578 Some(("unsupported", _))
1579 ) =>
1580 {
1581 None
1582 }
1583 Err(error) => {
1584 return Err(crate::error::AppError::S3Error(format!(
1585 "Cannot save because the current tags could not be preserved: {error}"
1586 )))
1587 }
1588 };
1589 let bytes = content.into_bytes();
1590 let build_request = |acl: Option<&CopyAclHeaders>| {
1591 let mut request = client
1592 .put_object()
1593 .bucket(bucket)
1594 .key(key)
1595 .if_match(expected_etag)
1596 .body(aws_sdk_s3::primitives::ByteStream::from(bytes.clone()))
1597 .set_content_type(head.content_type.clone())
1598 .set_cache_control(head.cache_control.clone())
1599 .set_content_disposition(head.content_disposition.clone())
1600 .set_content_encoding(head.content_encoding.clone())
1601 .set_content_language(head.content_language.clone())
1602 .set_metadata(head.metadata.clone())
1603 .set_website_redirect_location(head.website_redirect_location.clone())
1604 .set_storage_class(head.storage_class.clone())
1605 .set_server_side_encryption(head.server_side_encryption.clone())
1606 .set_ssekms_key_id(head.ssekms_key_id.clone())
1607 .set_bucket_key_enabled(head.bucket_key_enabled)
1608 .set_object_lock_mode(head.object_lock_mode.clone())
1609 .set_object_lock_retain_until_date(head.object_lock_retain_until_date)
1610 .set_object_lock_legal_hold_status(head.object_lock_legal_hold_status.clone())
1611 .set_tagging(tags.clone());
1612 #[allow(deprecated)]
1613 {
1614 request = request.set_expires(head.expires);
1615 }
1616 if let Some(acl) = acl {
1617 request = request
1618 .set_grant_full_control(CopyAclHeaders::joined(&acl.full_control))
1619 .set_grant_read(CopyAclHeaders::joined(&acl.read))
1620 .set_grant_read_acp(CopyAclHeaders::joined(&acl.read_acp))
1621 .set_grant_write_acp(CopyAclHeaders::joined(&acl.write_acp));
1622 }
1623 request
1624 };
1625 let mut result = build_request(acl.as_ref()).send().await;
1626 if let Err(error) = &result {
1627 if acl.is_some()
1628 && matches!(
1629 classify_acl_error(&s3_error_message(error)),
1630 Some(("unsupported", _))
1631 )
1632 {
1633 result = build_request(None).send().await;
1634 }
1635 }
1636 result.map(|output| output.e_tag).map_err(|error| {
1637 if error
1638 .raw_response()
1639 .is_some_and(|response| matches!(response.status().as_u16(), 409 | 412))
1640 {
1641 conflict()
1642 } else {
1643 crate::error::AppError::S3Error(format!("Save failed: {error}"))
1644 }
1645 })
1646}
1647
1648#[tauri::command]
1649pub async fn set_object_content_type(
1650 bucket_name: String,
1651 bucket_region: Option<String>,
1652 key: String,
1653 content_type: String,
1654 expected_profile_id: String,
1655 profile_state: State<'_, ProfileState>,
1656 s3_state: State<'_, S3State>,
1657) -> Result<()> {
1658 const MAX_SINGLE_COPY_SIZE: u64 = 5 * 1024 * 1024 * 1024;
1659
1660 let content_type = crate::s3::validate_content_type(&content_type)?;
1661 let profile_manager = profile_state.read().await;
1662 let active_profile = profile_manager
1663 .get_active_profile()
1664 .await?
1665 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
1666 drop(profile_manager);
1667 super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
1668
1669 let resolved_region = {
1670 let s3_manager = s3_state.read().await;
1671 s3_manager.get_bucket_region(&active_profile, &bucket_name)
1672 }
1673 .or(bucket_region);
1674
1675 let client = {
1676 let mut s3_manager = s3_state.write().await;
1677 if let Some(ref region) = resolved_region {
1678 s3_manager
1679 .get_client_for_region(&active_profile, region)
1680 .await?
1681 .clone()
1682 } else {
1683 s3_manager.get_client(&active_profile).await?.clone()
1684 }
1685 };
1686
1687 let head = client
1688 .head_object()
1689 .bucket(&bucket_name)
1690 .key(&key)
1691 .send()
1692 .await
1693 .map_err(|error| crate::error::AppError::S3Error(error.to_string()))?;
1694
1695 if head.content_type() == Some(content_type.as_str()) {
1696 return Ok(());
1697 }
1698 if head.e_tag().is_none() {
1699 return Err(crate::error::AppError::S3Error(format!(
1700 "Cannot safely update Content-Type because S3 did not return an ETag for s3://{bucket_name}/{key}"
1701 )));
1702 }
1703
1704 let object_size = head
1705 .content_length()
1706 .ok_or_else(|| {
1707 crate::error::AppError::S3Error(format!(
1708 "S3 did not return the size of s3://{bucket_name}/{key}"
1709 ))
1710 })
1711 .and_then(|value| {
1712 u64::try_from(value).map_err(|_| {
1713 crate::error::AppError::S3Error(format!(
1714 "S3 returned an invalid negative size for s3://{bucket_name}/{key}"
1715 ))
1716 })
1717 })?;
1718 if head.sse_customer_algorithm().is_some() {
1719 return Err(crate::error::AppError::ConfigError(
1720 "Content-Type cannot be changed safely for an SSE-C encrypted object because its customer encryption key is not available"
1721 .to_string(),
1722 ));
1723 }
1724
1725 let acl_headers = match client
1726 .get_object_acl()
1727 .bucket(&bucket_name)
1728 .key(&key)
1729 .set_version_id(head.version_id.clone())
1730 .send()
1731 .await
1732 {
1733 Ok(output) => Some(copy_acl_headers(&output)?),
1734 Err(error) => {
1735 let error_string = s3_error_message(&error);
1736 if matches!(classify_acl_error(&error_string), Some(("unsupported", _))) {
1737 None
1738 } else {
1739 return Err(crate::error::AppError::S3Error(format!(
1740 "Cannot safely update Content-Type because the current object ACL could not be read and preserved: {error_string}"
1741 )));
1742 }
1743 }
1744 };
1745
1746 let copy_source = copy_source(&bucket_name, &key, head.version_id());
1747 if object_size > MAX_SINGLE_COPY_SIZE {
1748 multipart_copy_content_type(
1749 &client,
1750 &bucket_name,
1751 &key,
1752 &content_type,
1753 &head,
1754 acl_headers.as_ref(),
1755 )
1756 .await?;
1757
1758 let mut s3_manager = s3_state.write().await;
1759 s3_manager.remove_bucket_cache(&active_profile.id, &bucket_name);
1760 return Ok(());
1761 }
1762
1763 let build_request = |acl: Option<&CopyAclHeaders>| {
1764 let mut request = client
1765 .copy_object()
1766 .bucket(&bucket_name)
1767 .key(&key)
1768 .copy_source(©_source)
1769 .content_type(&content_type)
1770 .metadata_directive(MetadataDirective::Replace)
1771 .tagging_directive(TaggingDirective::Copy)
1772 .set_copy_source_if_match(head.e_tag.clone())
1773 .set_cache_control(head.cache_control.clone())
1774 .set_content_disposition(head.content_disposition.clone())
1775 .set_content_encoding(head.content_encoding.clone())
1776 .set_content_language(head.content_language.clone())
1777 .set_metadata(head.metadata.clone())
1778 .set_website_redirect_location(head.website_redirect_location.clone())
1779 .set_storage_class(head.storage_class.clone())
1780 .set_server_side_encryption(head.server_side_encryption.clone())
1781 .set_ssekms_key_id(head.ssekms_key_id.clone())
1782 .set_bucket_key_enabled(head.bucket_key_enabled)
1783 .set_object_lock_mode(head.object_lock_mode.clone())
1784 .set_object_lock_retain_until_date(head.object_lock_retain_until_date)
1785 .set_object_lock_legal_hold_status(head.object_lock_legal_hold_status.clone());
1786
1787 #[allow(deprecated)]
1788 {
1789 request = request.set_expires(head.expires);
1790 }
1791
1792 if let Some(acl) = acl {
1793 request = request
1794 .set_grant_full_control(CopyAclHeaders::joined(&acl.full_control))
1795 .set_grant_read(CopyAclHeaders::joined(&acl.read))
1796 .set_grant_read_acp(CopyAclHeaders::joined(&acl.read_acp))
1797 .set_grant_write_acp(CopyAclHeaders::joined(&acl.write_acp));
1798 }
1799
1800 request
1801 };
1802
1803 let result = build_request(acl_headers.as_ref()).send().await;
1804 if let Err(error) = result {
1805 let error_string = s3_error_message(&error);
1806 if acl_headers.is_some()
1807 && matches!(classify_acl_error(&error_string), Some(("unsupported", _)))
1808 {
1809 build_request(None).send().await.map_err(|retry_error| {
1813 crate::error::AppError::S3Error(format!(
1814 "Content-Type update failed after retrying without ACL headers: {retry_error}"
1815 ))
1816 })?;
1817 } else {
1818 return Err(crate::error::AppError::S3Error(format!(
1819 "Content-Type update failed: {error_string}"
1820 )));
1821 }
1822 }
1823
1824 {
1825 let mut s3_manager = s3_state.write().await;
1826 s3_manager.remove_bucket_cache(&active_profile.id, &bucket_name);
1827 }
1828
1829 Ok(())
1830}
1831
1832#[derive(serde::Serialize)]
1833pub struct ObjectMetadata {
1834 pub key: String,
1835 pub size: i64,
1836 pub last_modified: Option<String>,
1837 pub content_type: Option<String>,
1838 pub e_tag: Option<String>,
1839 pub storage_class: Option<String>,
1840 pub user_metadata: std::collections::HashMap<String, String>,
1841}
1842
1843#[derive(serde::Serialize)]
1844pub struct ObjectAclGrant {
1845 pub grantee_type: Option<String>,
1846 pub display_name: Option<String>,
1847 pub id: Option<String>,
1848 pub uri: Option<String>,
1849 pub email_address: Option<String>,
1850 pub permission: Option<String>,
1851}
1852
1853#[derive(serde::Serialize)]
1854pub struct ObjectPermissions {
1855 pub key: String,
1856 pub is_folder: bool,
1857 pub status: String,
1858 pub message: Option<String>,
1859 pub owner_display_name: Option<String>,
1860 pub owner_id: Option<String>,
1861 pub grants: Vec<ObjectAclGrant>,
1862 pub target_count: usize,
1863}
1864
1865#[derive(serde::Serialize)]
1866pub struct SetObjectPermissionsResult {
1867 pub affected_count: usize,
1868}
1869
1870#[tauri::command]
1871pub async fn get_object_permissions(
1872 bucket_name: String,
1873 bucket_region: Option<String>,
1874 key: String,
1875 is_folder: bool,
1876 expected_profile_id: String,
1877 profile_state: State<'_, ProfileState>,
1878 s3_state: State<'_, S3State>,
1879) -> Result<ObjectPermissions> {
1880 let profile_manager = profile_state.read().await;
1881 let active_profile = profile_manager
1882 .get_active_profile()
1883 .await?
1884 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
1885 drop(profile_manager);
1886 super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
1887
1888 let bucket_region = {
1889 let s3_manager = s3_state.read().await;
1890 s3_manager.get_bucket_region(&active_profile, &bucket_name)
1891 }
1892 .or(bucket_region);
1893
1894 let mut client = {
1895 let mut s3_manager = s3_state.write().await;
1896 if let Some(ref region) = bucket_region {
1897 s3_manager
1898 .get_client_for_region(&active_profile, region)
1899 .await?
1900 .clone()
1901 } else {
1902 s3_manager.get_client(&active_profile).await?.clone()
1903 }
1904 };
1905
1906 let mut target_keys =
1907 match list_keys_for_permission_target(&client, &bucket_name, &key, is_folder).await {
1908 Ok(keys) => keys,
1909 Err(err) => {
1910 log::warn!(
1911 "Permission target listing failed, attempting region discovery: {}",
1912 err
1913 );
1914 if let Some(new_region) =
1915 detect_and_cache_bucket_region(&active_profile, &bucket_name, &s3_state).await?
1916 {
1917 client = {
1918 let mut s3_manager = s3_state.write().await;
1919 s3_manager
1920 .get_client_for_region(&active_profile, &new_region)
1921 .await?
1922 .clone()
1923 };
1924 list_keys_for_permission_target(&client, &bucket_name, &key, is_folder).await?
1925 } else {
1926 return Err(err);
1927 }
1928 }
1929 };
1930
1931 target_keys.sort();
1932 let representative_key = target_keys
1933 .first()
1934 .cloned()
1935 .ok_or_else(|| crate::error::AppError::S3Error("No permission target found".to_string()))?;
1936
1937 let output = match client
1938 .get_object_acl()
1939 .bucket(&bucket_name)
1940 .key(&representative_key)
1941 .send()
1942 .await
1943 {
1944 Ok(output) => output,
1945 Err(err) => {
1946 let error_string = s3_error_message(&err);
1947 if let Some((status, message)) = classify_acl_error(&error_string) {
1948 return Ok(ObjectPermissions {
1949 key,
1950 is_folder,
1951 status: status.to_string(),
1952 message: Some(message.to_string()),
1953 owner_display_name: None,
1954 owner_id: None,
1955 grants: Vec::new(),
1956 target_count: target_keys.len(),
1957 });
1958 }
1959 return Err(crate::error::AppError::S3Error(error_string));
1960 }
1961 };
1962
1963 let grants = output
1964 .grants()
1965 .iter()
1966 .map(|grant| {
1967 let grantee = grant.grantee();
1968 ObjectAclGrant {
1969 grantee_type: grantee.map(|g| g.r#type().as_str().to_string()),
1970 display_name: grantee
1971 .and_then(|g| g.display_name())
1972 .map(|value| value.to_string()),
1973 id: grantee.and_then(|g| g.id()).map(|value| value.to_string()),
1974 uri: grantee.and_then(|g| g.uri()).map(|value| value.to_string()),
1975 email_address: grantee
1976 .and_then(|g| g.email_address())
1977 .map(|value| value.to_string()),
1978 permission: grant.permission().map(|value| value.as_str().to_string()),
1979 }
1980 })
1981 .collect();
1982
1983 Ok(ObjectPermissions {
1984 key,
1985 is_folder,
1986 status: "available".to_string(),
1987 message: None,
1988 owner_display_name: output
1989 .owner()
1990 .and_then(|owner| owner.display_name())
1991 .map(|value| value.to_string()),
1992 owner_id: output
1993 .owner()
1994 .and_then(|owner| owner.id())
1995 .map(|value| value.to_string()),
1996 grants,
1997 target_count: target_keys.len(),
1998 })
1999}
2000
2001#[tauri::command]
2002#[allow(clippy::too_many_arguments)]
2003pub async fn set_object_permissions(
2004 bucket_name: String,
2005 bucket_region: Option<String>,
2006 key: String,
2007 is_folder: bool,
2008 canned_acl: String,
2009 expected_profile_id: String,
2010 profile_state: State<'_, ProfileState>,
2011 s3_state: State<'_, S3State>,
2012) -> Result<SetObjectPermissionsResult> {
2013 let acl = parse_object_canned_acl(&canned_acl)?;
2014 let profile_manager = profile_state.read().await;
2015 let active_profile = profile_manager
2016 .get_active_profile()
2017 .await?
2018 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
2019 drop(profile_manager);
2020 super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
2021
2022 let bucket_region = {
2023 let s3_manager = s3_state.read().await;
2024 s3_manager.get_bucket_region(&active_profile, &bucket_name)
2025 }
2026 .or(bucket_region);
2027
2028 let mut client = {
2029 let mut s3_manager = s3_state.write().await;
2030 if let Some(ref region) = bucket_region {
2031 s3_manager
2032 .get_client_for_region(&active_profile, region)
2033 .await?
2034 .clone()
2035 } else {
2036 s3_manager.get_client(&active_profile).await?.clone()
2037 }
2038 };
2039
2040 let target_keys =
2041 match list_keys_for_permission_target(&client, &bucket_name, &key, is_folder).await {
2042 Ok(keys) => keys,
2043 Err(err) => {
2044 log::warn!(
2045 "Permission target listing failed, attempting region discovery: {}",
2046 err
2047 );
2048 if let Some(new_region) =
2049 detect_and_cache_bucket_region(&active_profile, &bucket_name, &s3_state).await?
2050 {
2051 client = {
2052 let mut s3_manager = s3_state.write().await;
2053 s3_manager
2054 .get_client_for_region(&active_profile, &new_region)
2055 .await?
2056 .clone()
2057 };
2058 list_keys_for_permission_target(&client, &bucket_name, &key, is_folder).await?
2059 } else {
2060 return Err(err);
2061 }
2062 }
2063 };
2064
2065 for target_key in &target_keys {
2066 client
2067 .put_object_acl()
2068 .bucket(&bucket_name)
2069 .key(target_key)
2070 .acl(acl.clone())
2071 .send()
2072 .await
2073 .map_err(map_acl_error)?;
2074 }
2075
2076 {
2077 let profile_id = active_profile.id.clone();
2078 let mut s3_manager = s3_state.write().await;
2079 s3_manager.remove_bucket_cache(&profile_id, &bucket_name);
2080 }
2081
2082 Ok(SetObjectPermissionsResult {
2083 affected_count: target_keys.len(),
2084 })
2085}
2086
2087#[tauri::command]
2088pub async fn get_object_metadata(
2089 bucket_name: String,
2090 bucket_region: Option<String>,
2091 key: String,
2092 expected_profile_id: String,
2093 profile_state: State<'_, ProfileState>,
2094 s3_state: State<'_, S3State>,
2095) -> Result<ObjectMetadata> {
2096 let profile_manager = profile_state.read().await;
2097 let active_profile = profile_manager
2098 .get_active_profile()
2099 .await?
2100 .ok_or_else(|| crate::error::AppError::ProfileNotFound("No active profile".into()))?;
2101 drop(profile_manager);
2102 super::operations::validate_operation_profile(Some(&expected_profile_id), &active_profile.id)?;
2103
2104 let bucket_region = {
2106 let s3_manager = s3_state.read().await;
2107 s3_manager.get_bucket_region(&active_profile, &bucket_name)
2108 }
2109 .or(bucket_region);
2110
2111 let client = {
2112 let mut s3_manager = s3_state.write().await;
2113 if let Some(ref d) = bucket_region {
2114 s3_manager
2115 .get_client_for_region(&active_profile, d)
2116 .await?
2117 .clone()
2118 } else {
2119 s3_manager.get_client(&active_profile).await?.clone()
2120 }
2121 };
2122
2123 let result = client
2124 .head_object()
2125 .bucket(&bucket_name)
2126 .key(&key)
2127 .send()
2128 .await;
2129
2130 let output = match result {
2131 Ok(out) => out,
2132 Err(err) => {
2133 let error_str = err.to_string();
2134 if error_str.contains("403") || error_str.contains("Access Denied") {
2137 return Err(crate::error::AppError::AccessDenied(error_str));
2138 }
2139
2140 log::warn!("head_object failed, attempting region discovery: {}", err);
2142 let detected_region = {
2143 let retry_client = {
2144 let mut s3_manager = s3_state.write().await;
2145 s3_manager.get_client(&active_profile).await?.clone()
2146 };
2147 crate::s3::get_bucket_region(&retry_client, &bucket_name)
2148 .await
2149 .ok()
2150 };
2151
2152 if let Some(new_region) = detected_region {
2153 let new_client = {
2154 let mut s3_manager = s3_state.write().await;
2155 s3_manager.set_bucket_region(&active_profile, &bucket_name, new_region.clone());
2156 s3_manager
2157 .get_client_for_region(&active_profile, &new_region)
2158 .await?
2159 .clone()
2160 };
2161 new_client
2162 .head_object()
2163 .bucket(&bucket_name)
2164 .key(&key)
2165 .send()
2166 .await
2167 .map_err(|e| {
2168 let e_str = e.to_string();
2169 if e_str.contains("403") || e_str.contains("Access Denied") {
2170 crate::error::AppError::AccessDenied(e_str)
2171 } else {
2172 crate::error::AppError::S3Error(format!("Retry head failed: {}", e_str))
2173 }
2174 })?
2175 } else {
2176 return Err(crate::error::AppError::S3Error(error_str));
2177 }
2178 }
2179 };
2180
2181 let last_modified = output.last_modified.map(|d| d.to_string());
2182
2183 let user_metadata = output.metadata.unwrap_or_default();
2185
2186 Ok(ObjectMetadata {
2187 key,
2188 size: output.content_length.unwrap_or(0),
2189 last_modified,
2190 content_type: output.content_type,
2191 e_tag: output.e_tag,
2192 storage_class: output.storage_class.map(|s| s.as_str().to_string()),
2193 user_metadata: user_metadata.into_iter().collect(),
2194 })
2195}
2196
2197#[cfg(test)]
2198mod tests {
2199 use super::{
2200 classify_acl_error, copy_source, encode_object_tags, multipart_copy_content_type,
2201 quoted_acl_value,
2202 };
2203 use crate::credentials::{CredentialType, Profile};
2204 use aws_sdk_s3::primitives::ByteStream;
2205 use aws_sdk_s3::types::{Tag, Tagging};
2206
2207 #[test]
2208 fn copy_source_encodes_keys_and_pins_versioned_objects() {
2209 assert_eq!(
2210 copy_source("bucket", "folder/a file#.txt", None),
2211 "bucket/folder%2Fa%20file%23.txt"
2212 );
2213 assert_eq!(
2214 copy_source("bucket", "folder/a.txt", Some("version+one=")),
2215 "bucket/folder%2Fa.txt?versionId=version%2Bone%3D"
2216 );
2217 }
2218
2219 #[test]
2220 fn multipart_copy_tag_header_is_url_encoded() {
2221 let tags = vec![
2222 Tag::builder()
2223 .key("team name")
2224 .value("web+docs")
2225 .build()
2226 .unwrap(),
2227 Tag::builder().key("empty").value("").build().unwrap(),
2228 ];
2229
2230 assert_eq!(
2231 encode_object_tags(&tags).as_deref(),
2232 Some("team%20name=web%2Bdocs&empty=")
2233 );
2234 assert_eq!(encode_object_tags(&[]), None);
2235 }
2236
2237 #[test]
2238 fn acl_preservation_escapes_values_and_classifies_provider_errors() {
2239 assert_eq!(
2240 quoted_acl_value("id", "user\\\"one").unwrap(),
2241 "id=\"user\\\\\\\"one\""
2242 );
2243 assert!(quoted_acl_value("id", "bad\nvalue").is_err());
2244 assert_eq!(
2245 classify_acl_error("AccessControlListNotSupported"),
2246 Some((
2247 "unsupported",
2248 "ACL permissions are not supported for this bucket or provider. The bucket may use Object Ownership with ACLs disabled."
2249 ))
2250 );
2251 assert!(matches!(
2252 classify_acl_error("403 AccessDenied"),
2253 Some(("access_denied", _))
2254 ));
2255 }
2256
2257 #[tokio::test]
2259 #[ignore = "requires an S3-compatible integration-test endpoint"]
2260 async fn multipart_content_type_copy_preserves_object_state() {
2261 let endpoint = std::env::var("BROWS3_S3_TEST_ENDPOINT")
2262 .expect("BROWS3_S3_TEST_ENDPOINT must identify the test S3 endpoint");
2263 let access_key =
2264 std::env::var("BROWS3_S3_TEST_ACCESS_KEY").unwrap_or_else(|_| "minioadmin".into());
2265 let secret_key =
2266 std::env::var("BROWS3_S3_TEST_SECRET_KEY").unwrap_or_else(|_| "minioadmin".into());
2267 let profile = Profile::new(
2268 "content-type-integration".to_string(),
2269 CredentialType::CustomEndpoint {
2270 endpoint_url: endpoint,
2271 access_key_id: access_key,
2272 secret_access_key: secret_key,
2273 },
2274 Some("us-east-1".to_string()),
2275 );
2276 let sdk_config = crate::s3::client::load_sdk_config(&profile, None).await;
2277 let client = crate::s3::client::client_from_sdk_config(&sdk_config, &profile);
2278 let bucket = format!("brows3-content-type-{}", uuid::Uuid::new_v4().simple());
2279 let key = "folder/a file.bin";
2280 client
2281 .create_bucket()
2282 .bucket(&bucket)
2283 .send()
2284 .await
2285 .expect("test bucket should be created");
2286
2287 let path = std::env::temp_dir().join(format!(
2288 "brows3-content-type-{}.bin",
2289 uuid::Uuid::new_v4().simple()
2290 ));
2291 let file = tokio::fs::File::create(&path)
2292 .await
2293 .expect("sparse test file should be created");
2294 let size = 129 * 1024 * 1024;
2295 file.set_len(size)
2296 .await
2297 .expect("sparse test file should be sized");
2298 drop(file);
2299
2300 client
2301 .put_object()
2302 .bucket(&bucket)
2303 .key(key)
2304 .content_type("application/octet-stream")
2305 .cache_control("max-age=60")
2306 .metadata("owner", "brows3")
2307 .body(
2308 ByteStream::from_path(&path)
2309 .await
2310 .expect("test body should be readable"),
2311 )
2312 .send()
2313 .await
2314 .expect("source object should be uploaded");
2315 client
2316 .put_object_tagging()
2317 .bucket(&bucket)
2318 .key(key)
2319 .tagging(
2320 Tagging::builder()
2321 .tag_set(
2322 Tag::builder()
2323 .key("team name")
2324 .value("web+docs")
2325 .build()
2326 .unwrap(),
2327 )
2328 .build()
2329 .unwrap(),
2330 )
2331 .send()
2332 .await
2333 .expect("source tags should be applied");
2334
2335 let head = client
2336 .head_object()
2337 .bucket(&bucket)
2338 .key(key)
2339 .send()
2340 .await
2341 .expect("source metadata should be readable");
2342 multipart_copy_content_type(
2343 &client,
2344 &bucket,
2345 key,
2346 "text/html; charset=utf-8",
2347 &head,
2348 None,
2349 )
2350 .await
2351 .expect("multipart copy should complete");
2352
2353 let copied = client
2354 .head_object()
2355 .bucket(&bucket)
2356 .key(key)
2357 .send()
2358 .await
2359 .expect("copied metadata should be readable");
2360 assert_eq!(copied.content_length(), Some(size as i64));
2361 assert_eq!(copied.content_type(), Some("text/html; charset=utf-8"));
2362 assert_eq!(copied.cache_control(), Some("max-age=60"));
2363 assert_eq!(
2364 copied
2365 .metadata()
2366 .and_then(|metadata| metadata.get("owner"))
2367 .map(String::as_str),
2368 Some("brows3")
2369 );
2370
2371 let tags = client
2372 .get_object_tagging()
2373 .bucket(&bucket)
2374 .key(key)
2375 .send()
2376 .await
2377 .expect("copied tags should be readable");
2378 assert_eq!(tags.tag_set().len(), 1);
2379 assert_eq!(tags.tag_set()[0].key(), "team name");
2380 assert_eq!(tags.tag_set()[0].value(), "web+docs");
2381 let incomplete = client
2382 .list_multipart_uploads()
2383 .bucket(&bucket)
2384 .send()
2385 .await
2386 .expect("multipart uploads should be listable");
2387 assert!(incomplete.uploads().is_empty());
2388
2389 client
2390 .delete_object()
2391 .bucket(&bucket)
2392 .key(key)
2393 .send()
2394 .await
2395 .expect("test object should be deleted");
2396 client
2397 .delete_bucket()
2398 .bucket(&bucket)
2399 .send()
2400 .await
2401 .expect("test bucket should be deleted");
2402 tokio::fs::remove_file(path)
2403 .await
2404 .expect("sparse test file should be deleted");
2405 }
2406}
2407
2408#[cfg(test)]
2409mod operation_profile_tests {
2410 use super::validate_operation_profile;
2411
2412 #[test]
2413 fn recursive_targets_cannot_point_inside_the_source_folder() {
2414 for destination in ["folder", "folder/", "folder/nested", "folder/nested/"] {
2415 assert!(
2416 super::validate_folder_target("bucket", "folder/", "bucket", destination).is_err()
2417 );
2418 }
2419 for (bucket, key) in [
2420 ("other", "folder/nested/"),
2421 ("bucket", "folder-copy/"),
2422 ("bucket", "sibling/"),
2423 ] {
2424 assert!(super::validate_folder_target("bucket", "folder/", bucket, key).is_ok());
2425 }
2426 assert!(super::validate_folder_target("bucket", "file", "bucket", "file-copy").is_ok());
2427 }
2428
2429 #[test]
2430 fn rejects_operations_from_a_different_profile() {
2431 assert!(validate_operation_profile(Some("profile-a"), "profile-b").is_err());
2432 assert!(validate_operation_profile(Some("profile-a"), "profile-a").is_ok());
2433 assert!(validate_operation_profile(None, "profile-a").is_err());
2434 }
2435}
2436
2437#[cfg(test)]
2438mod move_profile_tests {
2439 use super::*;
2440 use crate::credentials::{CredentialType, Profile, ProfileManager};
2441 use crate::s3::S3ClientManager;
2442 use std::sync::Arc;
2443 use tokio::io::{AsyncReadExt, AsyncWriteExt};
2444 use tokio::sync::RwLock;
2445
2446 #[tokio::test]
2447 async fn changed_move_source_is_never_deleted_unconditionally() {
2448 let (client, server) =
2449 crate::commands::test_s3::scripted_client(vec![crate::commands::test_s3::response(
2450 412,
2451 "",
2452 "<Error><Code>PreconditionFailed</Code></Error>",
2453 )])
2454 .await;
2455 let error = delete_copied_source(&client, "bucket", "source", "\"copied\"")
2456 .await
2457 .unwrap_err();
2458 assert!(error.to_string().contains("destination copy remains"));
2459 let requests = server.await.unwrap();
2460 assert_eq!(requests.len(), 1);
2461 assert!(requests[0].contains("if-match: \"copied\""));
2462 }
2463
2464 #[tokio::test]
2465 async fn move_keeps_its_profile_when_selection_changes_after_copy() {
2466 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
2467 let endpoint = format!("http://{}", listener.local_addr().unwrap());
2468 let directory =
2469 std::env::temp_dir().join(format!("brows3-move-test-{}", uuid::Uuid::new_v4()));
2470 std::fs::create_dir_all(&directory).unwrap();
2471 let mut profiles = ProfileManager::new(directory.clone(), true).unwrap();
2472 let profile = profiles
2473 .add_profile(Profile::new(
2474 "A".into(),
2475 CredentialType::CustomEndpoint {
2476 endpoint_url: endpoint,
2477 access_key_id: "TEST-A".into(),
2478 secret_access_key: "test-secret".into(),
2479 },
2480 Some("us-east-1".into()),
2481 ))
2482 .await
2483 .unwrap();
2484 let other = profiles
2485 .add_profile(Profile::new(
2486 "B".into(),
2487 CredentialType::Environment,
2488 Some("us-east-1".into()),
2489 ))
2490 .await
2491 .unwrap();
2492 profiles.set_active_profile(&profile.id).await.unwrap();
2493 let captured = profiles.get_active_profile().await.unwrap().unwrap();
2494 let profiles = Arc::new(RwLock::new(profiles));
2495 let server_profiles = profiles.clone();
2496 let other_id = other.id.clone();
2497 let server = tokio::spawn(async move {
2498 let mut requests = Vec::new();
2499 for index in 0..4 {
2500 let (mut socket, _) = listener.accept().await.unwrap();
2501 let mut request = Vec::new();
2502 let mut byte = [0];
2503 while !request.ends_with(b"\r\n\r\n") {
2504 socket.read_exact(&mut byte).await.unwrap();
2505 request.push(byte[0]);
2506 }
2507 requests.push(String::from_utf8(request).unwrap());
2508 let body = if index == 2 {
2509 server_profiles
2510 .write()
2511 .await
2512 .set_active_profile(&other_id)
2513 .await
2514 .unwrap();
2515 "<CopyObjectResult><ETag>"test"</ETag><LastModified>2026-01-01T00:00:00Z</LastModified></CopyObjectResult>"
2516 } else if index == 1 {
2517 "<AccessControlPolicy><AccessControlList/></AccessControlPolicy>"
2518 } else {
2519 ""
2520 };
2521 let response = format!(
2522 "HTTP/1.1 200 OK\r\nETag: \"test\"\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
2523 body.len(),
2524 body
2525 );
2526 socket.write_all(response.as_bytes()).await.unwrap();
2527 }
2528 requests
2529 });
2530 let s3 = Arc::new(RwLock::new(S3ClientManager::new()));
2531 tokio::time::timeout(
2532 std::time::Duration::from_secs(15),
2533 move_object_with_profile(
2534 "bucket".into(),
2535 Some("us-east-1".into()),
2536 "source.txt".into(),
2537 "bucket".into(),
2538 Some("us-east-1".into()),
2539 "dest.txt".into(),
2540 captured,
2541 &s3,
2542 ),
2543 )
2544 .await
2545 .unwrap()
2546 .unwrap();
2547 let requests = server.await.unwrap();
2548 assert!(requests[0].starts_with("HEAD /bucket/source.txt"));
2549 assert!(requests[2].starts_with("PUT /bucket/dest.txt"));
2550 assert!(requests[3].starts_with("DELETE /bucket/source.txt"));
2551 assert!(requests[3].contains("if-match: \"test\""));
2552 assert!(requests
2553 .iter()
2554 .all(|request| request.contains("Credential=TEST-A/")));
2555 assert_eq!(
2556 profiles
2557 .read()
2558 .await
2559 .get_active_profile()
2560 .await
2561 .unwrap()
2562 .unwrap()
2563 .id,
2564 other.id
2565 );
2566 std::fs::remove_dir_all(directory).unwrap();
2567 }
2568}
2569
2570#[cfg(test)]
2571mod text_save_tests {
2572 use super::save_object_text;
2573 use crate::commands::test_s3::{response, scripted_client};
2574
2575 fn head(etag: &str) -> String {
2576 response(200, &format!("ETag: {etag}\r\nContent-Type: text/plain\r\nCache-Control: max-age=60\r\nx-amz-meta-owner: brows3\r\nx-amz-version-id: v1\r\n"), "")
2577 }
2578
2579 fn acl() -> String {
2580 response(200, "", "<AccessControlPolicy><Owner><ID>owner</ID></Owner><AccessControlList><Grant><Grantee xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"CanonicalUser\"><ID>owner</ID></Grantee><Permission>FULL_CONTROL</Permission></Grant></AccessControlList></AccessControlPolicy>")
2581 }
2582
2583 fn tags() -> String {
2584 response(200, "", "<Tagging><TagSet><Tag><Key>team name</Key><Value>web+docs</Value></Tag></TagSet></Tagging>")
2585 }
2586
2587 #[tokio::test]
2588 async fn save_preserves_attributes_and_returns_the_written_etag() {
2589 let (client, server) = scripted_client(vec![
2590 head("\"old\""),
2591 acl(),
2592 tags(),
2593 response(200, "ETag: \"new\"\r\n", ""),
2594 ])
2595 .await;
2596 assert_eq!(
2597 save_object_text(&client, "bucket", "file.txt", "edited".into(), "\"old\"")
2598 .await
2599 .unwrap()
2600 .as_deref(),
2601 Some("\"new\"")
2602 );
2603 let requests = server.await.unwrap();
2604 assert!(requests[1].contains("versionId=v1"));
2605 assert!(requests[2].contains("versionId=v1"));
2606 let put = requests[3].to_ascii_lowercase();
2607 assert!(put.starts_with("put /bucket/file.txt"));
2608 for header in [
2609 "if-match: \"old\"",
2610 "content-type: text/plain",
2611 "cache-control: max-age=60",
2612 "x-amz-meta-owner: brows3",
2613 "x-amz-grant-full-control: id=\"owner\"",
2614 "x-amz-tagging: team%20name=web%2bdocs",
2615 ] {
2616 assert!(put.contains(header), "Missing {header}: {put}");
2617 }
2618 assert!(put.contains("edited"));
2619 }
2620
2621 #[tokio::test]
2622 async fn disabled_acls_retry_without_grants_and_keep_the_write_condition() {
2623 let (client, server) = scripted_client(vec![
2624 head("\"old\""), acl(), tags(),
2625 response(400, "", "<Error><Code>AccessControlListNotSupported</Code><Message>ACLs are disabled</Message></Error>"),
2626 response(200, "ETag: \"new\"\r\n", ""),
2627 ]).await;
2628 assert_eq!(
2629 save_object_text(&client, "bucket", "file.txt", "edited".into(), "\"old\"")
2630 .await
2631 .unwrap()
2632 .as_deref(),
2633 Some("\"new\"")
2634 );
2635 let requests = server.await.unwrap();
2636 assert!(requests[3].contains("x-amz-grant-full-control:"));
2637 assert!(!requests[4].contains("x-amz-grant-"));
2638 assert!(requests[4].contains("if-match: \"old\""));
2639 assert!(requests[4].contains("x-amz-tagging: team%20name=web%2Bdocs"));
2640 }
2641
2642 #[tokio::test]
2643 async fn providers_without_acls_or_tags_can_still_save_conditionally() {
2644 let unsupported = response(501, "", "<Error><Code>NotImplemented</Code></Error>");
2645 let (client, server) = scripted_client(vec![
2646 head("\"old\""),
2647 unsupported.clone(),
2648 unsupported,
2649 response(200, "ETag: \"new\"\r\n", ""),
2650 ])
2651 .await;
2652 save_object_text(&client, "bucket", "file.txt", "edited".into(), "\"old\"")
2653 .await
2654 .unwrap();
2655 let requests = server.await.unwrap();
2656 assert!(!requests[3].contains("x-amz-grant-"));
2657 assert!(requests[3].contains("if-match: \"old\""));
2658 }
2659
2660 #[tokio::test]
2661 async fn changed_objects_are_rejected_before_writing() {
2662 let (client, server) = scripted_client(vec![head("\"changed\"")]).await;
2663 let error = save_object_text(&client, "bucket", "file.txt", "edited".into(), "\"old\"")
2664 .await
2665 .unwrap_err();
2666 assert!(error.to_string().contains("changed since it was opened"));
2667 assert_eq!(server.await.unwrap().len(), 1);
2668 }
2669
2670 #[tokio::test]
2671 async fn a_concurrent_write_is_reported_as_a_conflict() {
2672 let (client, server) = scripted_client(vec![
2673 head("\"old\""),
2674 acl(),
2675 tags(),
2676 response(412, "", "<Error><Code>PreconditionFailed</Code></Error>"),
2677 ])
2678 .await;
2679 let error = save_object_text(&client, "bucket", "file.txt", "edited".into(), "\"old\"")
2680 .await
2681 .unwrap_err();
2682 assert!(error.to_string().contains("changed since it was opened"));
2683 assert_eq!(server.await.unwrap().len(), 4);
2684 }
2685
2686 #[tokio::test]
2687 async fn unreadable_permissions_prevent_a_destructive_save() {
2688 let (client, server) = scripted_client(vec![
2689 head("\"old\""),
2690 response(403, "", "<Error><Code>AccessDenied</Code></Error>"),
2691 ])
2692 .await;
2693 let error = save_object_text(&client, "bucket", "file.txt", "edited".into(), "\"old\"")
2694 .await
2695 .unwrap_err();
2696 assert!(error
2697 .to_string()
2698 .contains("permissions could not be preserved"));
2699 assert_eq!(server.await.unwrap().len(), 2);
2700 }
2701}
2702
2703#[cfg(test)]
2704mod large_copy_tests {
2705 use super::copy_object_from_head;
2706 use crate::commands::test_s3::{response, scripted_client};
2707 use aws_sdk_s3::operation::head_object::HeadObjectOutput;
2708
2709 const LARGE_SIZE: u64 = 5 * 1024 * 1024 * 1024 + 1;
2710
2711 #[tokio::test]
2712 async fn ordinary_copy_preserves_acl_and_refuses_destination_replacement() {
2713 let (client, server) = scripted_client(vec![response(
2714 200,
2715 "",
2716 "<CopyObjectResult><ETag>"copy"</ETag></CopyObjectResult>",
2717 )])
2718 .await;
2719 let acl = super::CopyAclHeaders {
2720 read: vec!["uri=\"http://acs.amazonaws.com/groups/global/AllUsers\"".into()],
2721 ..Default::default()
2722 };
2723 copy_object_from_head(
2724 (&client, "source", "file"),
2725 (&client, "dest", "file"),
2726 &head(10),
2727 Some(&acl),
2728 )
2729 .await
2730 .unwrap();
2731 let requests = server.await.unwrap();
2732 assert!(requests[0].contains("if-none-match: *"));
2733 assert!(requests[0]
2734 .contains("x-amz-grant-read: uri=\"http://acs.amazonaws.com/groups/global/AllUsers\""));
2735 }
2736
2737 fn head(size: u64) -> HeadObjectOutput {
2738 HeadObjectOutput::builder()
2739 .content_length(size as i64)
2740 .e_tag("\"source\"")
2741 .version_id("v1")
2742 .content_type("text/plain")
2743 .cache_control("max-age=60")
2744 .metadata("owner", "brows3")
2745 .build()
2746 }
2747
2748 fn start_responses() -> Vec<String> {
2749 vec![
2750 response(200, "", "<Tagging><TagSet><Tag><Key>team</Key><Value>docs</Value></Tag></TagSet></Tagging>"),
2751 response(200, "", "<InitiateMultipartUploadResult><UploadId>upload</UploadId></InitiateMultipartUploadResult>"),
2752 ]
2753 }
2754
2755 #[tokio::test]
2756 async fn large_copy_uses_contiguous_parts_and_preserves_metadata() {
2757 let plan = crate::s3::plan_multipart_upload(LARGE_SIZE).unwrap();
2758 let mut responses = start_responses();
2759 responses.extend(plan.parts.iter().map(|_| {
2760 response(
2761 200,
2762 "",
2763 "<CopyPartResult><ETag>"part"</ETag></CopyPartResult>",
2764 )
2765 }));
2766 responses.push(response(200, "", "<CompleteMultipartUploadResult><ETag>"complete"</ETag></CompleteMultipartUploadResult>"));
2767 let (client, server) = scripted_client(responses).await;
2768 copy_object_from_head(
2769 (&client, "source", "original.txt"),
2770 (&client, "destination", "renamed.txt"),
2771 &head(LARGE_SIZE),
2772 None,
2773 )
2774 .await
2775 .unwrap();
2776 let requests = server.await.unwrap();
2777 assert!(requests[0].starts_with("GET /source/original.txt?tagging"));
2778 assert!(requests[0].contains("versionId=v1"));
2779 assert!(requests[1].starts_with("POST /destination/renamed.txt?uploads"));
2780 for header in [
2781 "content-type: text/plain",
2782 "cache-control: max-age=60",
2783 "x-amz-meta-owner: brows3",
2784 "x-amz-tagging: team=docs",
2785 ] {
2786 assert!(requests[1].contains(header));
2787 }
2788 for (request, part) in requests[2..requests.len() - 1].iter().zip(plan.parts) {
2789 assert!(request.starts_with("PUT /destination/renamed.txt?"));
2790 assert!(request.contains("x-amz-copy-source: source/original.txt?versionId=v1"));
2791 assert!(request.contains("x-amz-copy-source-if-match: \"source\""));
2792 assert!(request.contains(&format!(
2793 "x-amz-copy-source-range: bytes={}-{}",
2794 part.offset,
2795 part.offset + part.length - 1
2796 )));
2797 }
2798 assert!(requests
2799 .last()
2800 .unwrap()
2801 .starts_with("POST /destination/renamed.txt?uploadId=upload"));
2802 }
2803
2804 #[tokio::test]
2805 async fn failed_large_copy_aborts_without_completing_or_deleting_the_source() {
2806 let mut responses = start_responses();
2807 responses.push(response(
2808 412,
2809 "",
2810 "<Error><Code>PreconditionFailed</Code></Error>",
2811 ));
2812 responses.push(response(204, "", ""));
2813 let (client, server) = scripted_client(responses).await;
2814 assert!(copy_object_from_head(
2815 (&client, "source", "original.txt"),
2816 (&client, "destination", "renamed.txt"),
2817 &head(LARGE_SIZE),
2818 None,
2819 )
2820 .await
2821 .is_err());
2822 let requests = server.await.unwrap();
2823 assert_eq!(requests.len(), 4);
2824 assert!(requests[3].starts_with("DELETE /destination/renamed.txt?"));
2825 assert!(requests[3].contains("uploadId=upload"));
2826 }
2827
2828 #[tokio::test]
2829 async fn objects_at_the_single_copy_limit_keep_using_copy_object() {
2830 let (client, server) = scripted_client(vec![response(
2831 200,
2832 "",
2833 "<CopyObjectResult><ETag>"copy"</ETag></CopyObjectResult>",
2834 )])
2835 .await;
2836 copy_object_from_head(
2837 (&client, "source", "original.txt"),
2838 (&client, "destination", "renamed.txt"),
2839 &head(LARGE_SIZE - 1),
2840 None,
2841 )
2842 .await
2843 .unwrap();
2844 let requests = server.await.unwrap();
2845 assert_eq!(requests.len(), 1);
2846 assert!(requests[0].starts_with("PUT /destination/renamed.txt"));
2847 assert!(requests[0].contains("x-amz-copy-source: source/original.txt?versionId=v1"));
2848 }
2849}
2850
2851#[cfg(test)]
2852mod partial_delete_tests {
2853 use super::delete_objects_with_profile;
2854 use crate::commands::test_s3::{response, scripted_endpoint};
2855 use crate::credentials::{CredentialType, Profile};
2856 use crate::s3::{FolderContent, S3ClientManager};
2857 use std::sync::Arc;
2858 use tokio::sync::RwLock;
2859
2860 #[tokio::test]
2861 async fn partial_delete_reports_the_failed_key_and_invalidates_cached_results() {
2862 let (endpoint, server) = scripted_endpoint(vec![response(200, "", "<DeleteResult><Deleted><Key>deleted.txt</Key></Deleted><Error><Key>denied.txt</Key><Code>AccessDenied</Code><Message>Denied</Message></Error></DeleteResult>")]).await;
2863 let profile = Profile::new(
2864 "test".into(),
2865 CredentialType::CustomEndpoint {
2866 endpoint_url: endpoint,
2867 access_key_id: "TEST".into(),
2868 secret_access_key: "test-secret".into(),
2869 },
2870 Some("us-east-1".into()),
2871 );
2872 let mut manager = S3ClientManager::new();
2873 manager.set_sorted_folder_content(
2874 &profile.id,
2875 "bucket",
2876 "",
2877 "name",
2878 "asc",
2879 FolderContent::default(),
2880 );
2881 let state = Arc::new(RwLock::new(manager));
2882 let error = delete_objects_with_profile(
2883 "bucket".into(),
2884 None,
2885 vec!["deleted.txt".into(), "denied.txt".into()],
2886 profile.clone(),
2887 &state,
2888 )
2889 .await
2890 .unwrap_err();
2891 assert!(error.to_string().contains("denied.txt (AccessDenied"));
2892 assert!(state
2893 .read()
2894 .await
2895 .get_sorted_folder_content(&profile.id, "bucket", "", "name", "asc")
2896 .is_none());
2897 assert_eq!(server.await.unwrap().len(), 1);
2898 }
2899}
2900
2901#[cfg(test)]
2902mod folder_creation_tests {
2903 use super::put_object_with_profile;
2904 use crate::commands::test_s3::{response, scripted_endpoint};
2905 use crate::credentials::{CredentialType, Profile};
2906 use crate::s3::S3ClientManager;
2907 use std::sync::Arc;
2908 use tokio::sync::RwLock;
2909
2910 #[tokio::test]
2911 #[ignore = "requires a disposable S3-compatible bucket"]
2912 async fn folder_round_trip_against_compatibility_endpoint() {
2913 let bucket = std::env::var("BROWS3_S3_TEST_BUCKET").unwrap();
2914 let region = std::env::var("BROWS3_S3_TEST_REGION").unwrap_or_else(|_| "us-east-1".into());
2915 let profile = Profile::new(
2916 "Compatibility test".into(),
2917 CredentialType::CustomEndpoint {
2918 endpoint_url: std::env::var("BROWS3_S3_TEST_ENDPOINT").unwrap(),
2919 access_key_id: std::env::var("BROWS3_S3_TEST_ACCESS_KEY").unwrap(),
2920 secret_access_key: std::env::var("BROWS3_S3_TEST_SECRET_KEY").unwrap(),
2921 },
2922 Some(region),
2923 );
2924 let key = format!("brows3-test-{}/", uuid::Uuid::new_v4());
2925 let state = Arc::new(RwLock::new(S3ClientManager::new()));
2926 put_object_with_profile(
2927 bucket.clone(),
2928 None,
2929 key.clone(),
2930 None,
2931 profile.clone(),
2932 &state,
2933 )
2934 .await
2935 .unwrap();
2936 let client = crate::s3::client::build_s3_client(&profile, None)
2937 .await
2938 .unwrap();
2939 let result = client.head_object().bucket(&bucket).key(&key).send().await;
2940 client
2941 .delete_object()
2942 .bucket(&bucket)
2943 .key(&key)
2944 .send()
2945 .await
2946 .unwrap();
2947 assert_eq!(result.unwrap().content_length(), Some(0));
2948 }
2949
2950 #[tokio::test]
2951 async fn empty_folder_put_signs_a_fixed_content_length() {
2952 let (endpoint, server) = scripted_endpoint(vec![response(200, "", "")]).await;
2953 let profile = Profile::new(
2954 "Garage".into(),
2955 CredentialType::CustomEndpoint {
2956 endpoint_url: endpoint,
2957 access_key_id: "TEST".into(),
2958 secret_access_key: "test-secret".into(),
2959 },
2960 Some("garage".into()),
2961 );
2962 let state = Arc::new(RwLock::new(S3ClientManager::new()));
2963 put_object_with_profile(
2964 "bucket".into(),
2965 None,
2966 "folder/".into(),
2967 None,
2968 profile,
2969 &state,
2970 )
2971 .await
2972 .unwrap();
2973 let requests = server.await.unwrap();
2974 let request = requests[0].to_lowercase();
2975 assert!(request.starts_with("put /bucket/folder/"));
2976 assert!(request.contains("content-length: 0\r\n"));
2977 assert!(request.contains("signedheaders=content-length;"));
2978 assert!(!request.contains("transfer-encoding: chunked"));
2979 }
2980}