s3-wire 0.1.1

An async, streaming S3-compatible client for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use super::{CompletedPart, PartNumber, UploadId};
use crate::operation::{Checksum, ObjectKey, RequestIds};

/// Request to complete a multipart upload.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CompleteMultipartUploadRequest {
    /// Destination object key.
    pub key: ObjectKey,
    upload_id: UploadId,
    completed_parts: Vec<CompletedPart>,
}

impl CompleteMultipartUploadRequest {
    /// Validates that the upload ID is present and parts are non-empty, unique,
    /// and strictly ascending.
    pub fn new(
        key: ObjectKey,
        upload_id: UploadId,
        completed_parts: Vec<CompletedPart>,
    ) -> Result<Self, MultipartError> {
        validate_completed_parts(&completed_parts)?;
        Ok(Self {
            key,
            upload_id,
            completed_parts,
        })
    }

    /// Returns the validated, ordered completed parts.
    pub fn completed_parts(&self) -> &[CompletedPart] {
        &self.completed_parts
    }

    /// Returns the validated, non-empty upload identifier.
    pub const fn upload_id(&self) -> &UploadId {
        &self.upload_id
    }
}

/// Result of completing a multipart upload.
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CompleteMultipartUploadOutput {
    /// Service-provided object location. This is not exposed as a signed URL.
    pub location: Option<String>,
    /// Bucket reported by the service.
    pub bucket: Option<String>,
    /// Completed object key.
    pub key: Option<ObjectKey>,
    /// Entity tag of the completed object.
    pub e_tag: Option<String>,
    /// Version identifier, when enabled.
    pub version_id: Option<String>,
    /// Checksums returned by the service.
    pub checksum: Checksum,
    /// Service request identifiers.
    pub request_ids: RequestIds,
}

/// Request to abort an in-progress multipart upload.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AbortMultipartUploadRequest {
    key: ObjectKey,
    upload_id: UploadId,
}

impl AbortMultipartUploadRequest {
    /// Constructs an abort request from a validated upload identifier.
    pub fn new(key: ObjectKey, upload_id: UploadId) -> Self {
        Self { key, upload_id }
    }

    /// Returns the destination object key.
    pub const fn key(&self) -> &ObjectKey {
        &self.key
    }

    /// Returns the validated multipart upload identifier.
    pub const fn upload_id(&self) -> &UploadId {
        &self.upload_id
    }
}

/// Invalid multipart state or descriptor.
#[derive(Clone, Debug, Eq, PartialEq, thiserror::Error)]
pub enum MultipartError {
    /// A part number is outside S3's 1 through 10,000 range.
    #[error("multipart part number {0} is outside 1..=10000")]
    InvalidPartNumber(u16),
    /// An uploaded part has no usable entity tag.
    #[error("multipart part {part_number} has an empty ETag")]
    EmptyETag {
        /// Part with the invalid entity tag.
        part_number: u16,
    },
    /// A completed part number was recorded more than once.
    #[error("multipart part {0:?} was recorded more than once")]
    DuplicatePart(PartNumber),
    /// Completion was attempted without any completed parts.
    #[error("a multipart upload cannot be completed without parts")]
    NoCompletedParts,
    /// Completed parts are duplicated or out of ascending order.
    #[error("multipart part {next:?} does not follow {previous:?} in ascending order")]
    OutOfOrder {
        /// Last accepted part number.
        previous: PartNumber,
        /// Rejected part number.
        next: PartNumber,
    },
}

fn validate_completed_parts(parts: &[CompletedPart]) -> Result<(), MultipartError> {
    if parts.is_empty() {
        return Err(MultipartError::NoCompletedParts);
    }
    for window in parts.windows(2) {
        if window[1].part_number() <= window[0].part_number() {
            return Err(MultipartError::OutOfOrder {
                previous: window[0].part_number(),
                next: window[1].part_number(),
            });
        }
    }
    Ok(())
}