Skip to main content

brows3_lib/commands/
operations.rs

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(&copy_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    // Get active profile
497    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    // Check cache for bucket region first
524    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    // Get S3 client
531    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        // Upload file
555        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        // Create empty object (folder)
561        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    // Get active profile
638    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    // Check cache for bucket region first
647    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    // Get S3 client
654    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    // Get object
667    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    // Stream to file
710    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    // Get active profile
737    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    // Check cache for bucket region first
755    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    // Get S3 client
762    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    // Check if this is a folder copy (key ends with /)
872    if source_key.ends_with('/') {
873        // RECURSIVE FOLDER COPY
874        log::info!(
875            "Starting recursive folder copy from {}/{} to {}/{}",
876            source_bucket,
877            source_key,
878            destination_bucket,
879            destination_key
880        );
881
882        // Get client for listing source bucket
883        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        // Copy each object individually
912        for key in &all_keys {
913            // Calculate destination key by replacing source prefix with destination prefix
914            let relative_path = key.strip_prefix(&source_key).unwrap_or(key);
915            let new_key = format!("{}{}", destination_key, relative_path);
916
917            // Perform the copy using internal helper (non-recursive single file copy)
918            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        // Preserve explicitly-created empty folders without duplicating an existing marker.
932        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        // Single file copy
956        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/// Internal helper for copying a single object (non-recursive)
973#[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    // Check cache for bucket region first
985    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        // We need the client for the destination region to initiate the copy.
994        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, &region)
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    // Check cache for bucket region first
1230    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        // Delete in batches of 1000. Some S3-compatible providers support single-object
1250        // deletion but return service errors for DeleteObjects, so fall back per key.
1251        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                    // Retry logic for bulk delete
1265                    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    // Check if this is a folder move (key ends with /)
1383    if source_key.ends_with('/') {
1384        // RECURSIVE FOLDER MOVE
1385
1386        // Get client for listing source bucket
1387        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        // Move each object individually
1424        for key in &all_keys {
1425            // Calculate destination key by replacing source prefix with destination prefix
1426            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, &region)
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(&copy_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            // Object Ownership with ACLs disabled can still return an ACL-like
1810            // response while rejecting grant headers. Retry without ACL headers;
1811            // there is no ACL state to lose in that mode.
1812            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    // Check cache for bucket region first
2105    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 access denied (403), likely permissions, but could be region mismatch too in some cases.
2135            // But usually region mismatch is 301 or 400.
2136            if error_str.contains("403") || error_str.contains("Access Denied") {
2137                return Err(crate::error::AppError::AccessDenied(error_str));
2138            }
2139
2140            // Retry logic
2141            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    // Convert HashMap<String, String> from SDK to standard HashMap
2184    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    /// Run with BROWS3_S3_TEST_ENDPOINT=http://127.0.0.1:<port> against MinIO.
2258    #[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>&quot;test&quot;</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>&quot;copy&quot;</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>&quot;part&quot;</ETag></CopyPartResult>",
2764            )
2765        }));
2766        responses.push(response(200, "", "<CompleteMultipartUploadResult><ETag>&quot;complete&quot;</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>&quot;copy&quot;</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}