rustfs_rsc/client/
presigned.rs

1use std::str::FromStr;
2
3use hyper::HeaderMap;
4use hyper::{Method, Uri};
5
6use super::{PresignedArgs, QueryMap};
7use crate::error::{Result, ValueError};
8use crate::signer::presign_v4;
9use crate::time::UtcTime;
10use crate::utils::urlencode_binary;
11use crate::Minio;
12
13/// Operating presigned
14impl Minio {
15    /// Get presigned URL of an object for HTTP method, expiry time and custom request parameters.
16    /// # param
17    /// - method: HTTP method.
18    /// - bucket_name: Name of the bucket.
19    /// - object_name: Object name in the bucket.
20    /// - expires: Expiry in seconds. between 1, 604800
21    /// - response_headers Optional response_headers argument to specify response fields like date, size, type of file, data about server, etc.
22    /// - request_date: Optional request_date argument to specify a different request date. Default is current date.
23    /// - version_id: Version ID of the object.
24    /// - extra_query_params: Extra query parameters for advanced usage.
25    async fn _get_presigned_url<T1: Into<String>, T2: Into<String>>(
26        &self,
27        method: Method,
28        bucket_name: T1,
29        object_name: T2,
30        expires: usize,
31        response_headers: Option<HeaderMap>,
32        request_date: Option<UtcTime>,
33        version_id: Option<String>,
34        extra_query_params: Option<QueryMap>,
35    ) -> Result<String> {
36        if expires < 1 || expires > 604800 {
37            return Err(ValueError::from("expires must be between 1 second to 7 days").into());
38        }
39        let date: UtcTime = request_date.unwrap_or(UtcTime::default());
40        let mut query = extra_query_params.unwrap_or(QueryMap::new());
41        if let Some(id) = version_id {
42            query.insert("versionId".to_string(), id);
43        }
44        let credentials = self.fetch_credentials().await;
45        if let Some(token) = credentials.session_token() {
46            query.insert("X-Amz-Security-Token".to_string(), token.to_string());
47        }
48        if let Some(headers) = response_headers {
49            for (name, value) in &headers {
50                query.insert(name.to_string(), urlencode_binary(value.as_bytes(), false));
51            }
52        }
53        let uri = self._build_uri(Some(bucket_name.into()), Some(object_name.into()));
54        let uri = uri + "?" + &query.to_query_string();
55        let uri = Uri::from_str(&uri).map_err(|e| ValueError::new(e.to_string()))?;
56        let r = presign_v4(
57            &method,
58            &uri,
59            self.region(),
60            credentials.access_key(),
61            credentials.secret_key(),
62            &date,
63            expires,
64        );
65        Ok(r)
66    }
67
68    /// Get presigned URL of an object to download its data with expiry time.
69    /// ## Example
70    /// ``` rust
71    /// # use minio_rsc::Minio;
72    /// # use minio_rsc::client::PresignedArgs;
73    /// # async fn example(minio: Minio){
74    /// let presigned_get_object: String = minio
75    ///     .presigned_get_object(
76    ///         PresignedArgs::new("bucket", "file.txt")
77    ///             .expires(24*3600)
78    ///             .version_id("version_id"),
79    ///     )
80    ///     .await
81    ///     .unwrap();
82    /// # }
83    /// ```
84    pub async fn presigned_get_object(&self, args: PresignedArgs) -> Result<String> {
85        self._get_presigned_url(
86            Method::GET,
87            args.bucket_name,
88            args.object_name,
89            args.expires,
90            args.headers,
91            args.request_date,
92            args.version_id,
93            Some(args.querys),
94        )
95        .await
96    }
97
98    /// Get presigned URL of an object to upload data with expiry time.
99    /// ## Example
100    /// ``` rust
101    /// # use minio_rsc::Minio;
102    /// # use minio_rsc::client::PresignedArgs;
103    /// # async fn example(minio: Minio){
104    /// let presigned_put_object: String = minio
105    ///     .presigned_put_object(
106    ///         PresignedArgs::new("bucket", "file.txt")
107    ///             .expires(24*3600)
108    ///             .version_id("version_id"),
109    ///     )
110    ///     .await
111    ///     .unwrap();
112    /// # }
113    /// ```
114    pub async fn presigned_put_object(&self, args: PresignedArgs) -> Result<String> {
115        self._get_presigned_url(
116            Method::PUT,
117            args.bucket_name,
118            args.object_name,
119            args.expires,
120            args.headers,
121            args.request_date,
122            args.version_id,
123            Some(args.querys),
124        )
125        .await
126    }
127}