ossify 0.4.0

A modern, easy-to-use, and reqwest-powered Rust SDK for Alibaba Cloud Object Storage Service (OSS)
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use std::convert::Infallible;
use std::future::Future;

use bytes::Bytes;
use futures::{TryStream, stream};
use http::Method;
use serde::{Deserialize, Serialize};

use crate::body::StreamBody;
use crate::error::Result;
use crate::response::HeaderResponseProcessor;
use crate::{BoxError, Client, Ops, Prepared, Request};

/// UploadPart request parameters
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UploadPartParams {
    pub part_number: u32,
    pub upload_id: String,
}

impl UploadPartParams {
    pub fn new(part_number: u32, upload_id: impl Into<String>) -> Self {
        Self {
            part_number,
            upload_id: upload_id.into(),
        }
    }
}

/// UploadPart response
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub struct UploadPartResult {
    pub etag: String,
    #[serde(rename = "x-oss-hash-crc64ecma")]
    pub hash_crc64ecma: String,
    pub content_md5: String,
}

/// UploadPart operation
pub struct UploadPart<S> {
    pub object_key: String,
    pub params: UploadPartParams,
    pub stream_body: S,
}

impl<S> Ops for UploadPart<S>
where
    S: TryStream + Send + 'static,
    S::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
    Bytes: From<S::Ok>,
{
    type Response = HeaderResponseProcessor<UploadPartResult>;
    type Body = StreamBody<S>;
    type Query = UploadPartParams;

    fn prepare(self) -> Result<Prepared<UploadPartParams, S>> {
        Ok(Prepared {
            method: Method::PUT,
            key: Some(self.object_key),
            query: Some(self.params),
            body: Some(self.stream_body),
            ..Default::default()
        })
    }
}

/// Trait for UploadPart operations
pub trait UploadPartOperations {
    /// Upload part
    ///
    /// Official documentation: <https://www.alibabacloud.com/help/en/oss/developer-reference/uploadpart>
    fn upload_part<T>(
        &self,
        object_key: impl Into<String>,
        upload_id: impl Into<String>,
        part_number: u32,
        body: T,
    ) -> impl Future<Output = Result<UploadPartResult>>
    where
        T: Send + 'static,
        Bytes: From<T>;

    /// Upload part
    ///
    /// Official documentation: <https://www.alibabacloud.com/help/en/oss/developer-reference/uploadpart>
    fn upload_part_stream<S>(
        &self,
        object_key: impl Into<String>,
        upload_id: impl Into<String>,
        part_number: u32,
        stream: S,
    ) -> impl Future<Output = Result<UploadPartResult>>
    where
        S: TryStream + Send + 'static,
        S::Error: Into<BoxError>,
        Bytes: From<S::Ok>;
}

impl UploadPartOperations for Client {
    async fn upload_part<T>(
        &self,
        object_key: impl Into<String>,
        upload_id: impl Into<String>,
        part_number: u32,
        body: T,
    ) -> Result<UploadPartResult>
    where
        T: Send + 'static,
        Bytes: From<T>,
    {
        let ops = UploadPart {
            object_key: object_key.into(),
            params: UploadPartParams::new(part_number, upload_id),
            stream_body: stream::once(async move { Result::<Bytes, Infallible>::Ok(body.into()) }),
        };
        self.request(ops).await
    }

    async fn upload_part_stream<S>(
        &self,
        object_key: impl Into<String>,
        upload_id: impl Into<String>,
        part_number: u32,
        stream: S,
    ) -> Result<UploadPartResult>
    where
        S: TryStream + Send + 'static,
        S::Error: Into<BoxError>,
        Bytes: From<S::Ok>,
    {
        let ops = UploadPart {
            object_key: object_key.into(),
            params: UploadPartParams::new(part_number, upload_id),
            stream_body: stream,
        };
        self.request(ops).await
    }
}