opendal/services/swift/
backend.rs

1// Licensed to the Apache Software Foundation (ASF) under one
2// or more contributor license agreements.  See the NOTICE file
3// distributed with this work for additional information
4// regarding copyright ownership.  The ASF licenses this file
5// to you under the Apache License, Version 2.0 (the
6// "License"); you may not use this file except in compliance
7// with the License.  You may obtain a copy of the License at
8//
9//   http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing,
12// software distributed under the License is distributed on an
13// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14// KIND, either express or implied.  See the License for the
15// specific language governing permissions and limitations
16// under the License.
17
18use std::fmt::Debug;
19use std::fmt::Formatter;
20use std::sync::Arc;
21
22use http::Response;
23use http::StatusCode;
24use log::debug;
25
26use super::core::*;
27use super::delete::SwfitDeleter;
28use super::error::parse_error;
29use super::lister::SwiftLister;
30use super::writer::SwiftWriter;
31use crate::raw::*;
32use crate::services::SwiftConfig;
33use crate::*;
34
35impl Configurator for SwiftConfig {
36    type Builder = SwiftBuilder;
37    fn into_builder(self) -> Self::Builder {
38        SwiftBuilder { config: self }
39    }
40}
41
42/// [OpenStack Swift](https://docs.openstack.org/api-ref/object-store/#)'s REST API support.
43/// For more information about swift-compatible services, refer to [Compatible Services](#compatible-services).
44#[doc = include_str!("docs.md")]
45#[doc = include_str!("compatible_services.md")]
46#[derive(Default, Clone)]
47pub struct SwiftBuilder {
48    config: SwiftConfig,
49}
50
51impl Debug for SwiftBuilder {
52    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
53        let mut d = f.debug_struct("SwiftBuilder");
54        d.field("config", &self.config);
55        d.finish_non_exhaustive()
56    }
57}
58
59impl SwiftBuilder {
60    /// Set the remote address of this backend
61    ///
62    /// Endpoints should be full uri, e.g.
63    ///
64    /// - `http://127.0.0.1:8080/v1/AUTH_test`
65    /// - `http://192.168.66.88:8080/swift/v1`
66    /// - `https://openstack-controller.example.com:8080/v1/ccount`
67    ///
68    /// If user inputs endpoint without scheme, we will
69    /// prepend `https://` to it.
70    pub fn endpoint(mut self, endpoint: &str) -> Self {
71        self.config.endpoint = if endpoint.is_empty() {
72            None
73        } else {
74            Some(endpoint.trim_end_matches('/').to_string())
75        };
76        self
77    }
78
79    /// Set container of this backend.
80    ///
81    /// All operations will happen under this container. It is required. e.g. `snapshots`
82    pub fn container(mut self, container: &str) -> Self {
83        self.config.container = if container.is_empty() {
84            None
85        } else {
86            Some(container.trim_end_matches('/').to_string())
87        };
88        self
89    }
90
91    /// Set root of this backend.
92    ///
93    /// All operations will happen under this root.
94    pub fn root(mut self, root: &str) -> Self {
95        self.config.root = if root.is_empty() {
96            None
97        } else {
98            Some(root.to_string())
99        };
100
101        self
102    }
103
104    /// Set the token of this backend.
105    ///
106    /// Default to empty string.
107    pub fn token(mut self, token: &str) -> Self {
108        if !token.is_empty() {
109            self.config.token = Some(token.to_string());
110        }
111        self
112    }
113}
114
115impl Builder for SwiftBuilder {
116    const SCHEME: Scheme = Scheme::Swift;
117    type Config = SwiftConfig;
118
119    /// Build a SwiftBackend.
120    fn build(self) -> Result<impl Access> {
121        debug!("backend build started: {:?}", &self);
122
123        let root = normalize_root(&self.config.root.unwrap_or_default());
124        debug!("backend use root {root}");
125
126        let endpoint = match self.config.endpoint {
127            Some(endpoint) => {
128                if endpoint.starts_with("http") {
129                    endpoint
130                } else {
131                    format!("https://{endpoint}")
132                }
133            }
134            None => {
135                return Err(Error::new(
136                    ErrorKind::ConfigInvalid,
137                    "missing endpoint for Swift",
138                ));
139            }
140        };
141        debug!("backend use endpoint: {}", &endpoint);
142
143        let container = match self.config.container {
144            Some(container) => container,
145            None => {
146                return Err(Error::new(
147                    ErrorKind::ConfigInvalid,
148                    "missing container for Swift",
149                ));
150            }
151        };
152
153        let token = self.config.token.unwrap_or_default();
154
155        Ok(SwiftBackend {
156            core: Arc::new(SwiftCore {
157                info: {
158                    let am = AccessorInfo::default();
159                    am.set_scheme(Scheme::Swift)
160                        .set_root(&root)
161                        .set_native_capability(Capability {
162                            stat: true,
163                            read: true,
164
165                            write: true,
166                            write_can_empty: true,
167                            write_with_user_metadata: true,
168
169                            delete: true,
170
171                            list: true,
172                            list_with_recursive: true,
173
174                            shared: true,
175
176                            ..Default::default()
177                        });
178                    am.into()
179                },
180                root,
181                endpoint,
182                container,
183                token,
184            }),
185        })
186    }
187}
188
189/// Backend for Swift service
190#[derive(Debug, Clone)]
191pub struct SwiftBackend {
192    core: Arc<SwiftCore>,
193}
194
195impl Access for SwiftBackend {
196    type Reader = HttpBody;
197    type Writer = oio::OneShotWriter<SwiftWriter>;
198    type Lister = oio::PageLister<SwiftLister>;
199    type Deleter = oio::OneShotDeleter<SwfitDeleter>;
200
201    fn info(&self) -> Arc<AccessorInfo> {
202        self.core.info.clone()
203    }
204
205    async fn stat(&self, path: &str, _args: OpStat) -> Result<RpStat> {
206        let resp = self.core.swift_get_metadata(path).await?;
207
208        match resp.status() {
209            StatusCode::OK | StatusCode::NO_CONTENT => {
210                let headers = resp.headers();
211                let mut meta = parse_into_metadata(path, headers)?;
212                let user_meta = parse_prefixed_headers(headers, "x-object-meta-");
213                if !user_meta.is_empty() {
214                    meta = meta.with_user_metadata(user_meta);
215                }
216
217                Ok(RpStat::new(meta))
218            }
219            _ => Err(parse_error(resp)),
220        }
221    }
222
223    async fn read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::Reader)> {
224        let resp = self.core.swift_read(path, args.range(), &args).await?;
225
226        let status = resp.status();
227
228        match status {
229            StatusCode::OK | StatusCode::PARTIAL_CONTENT => Ok((RpRead::new(), resp.into_body())),
230            _ => {
231                let (part, mut body) = resp.into_parts();
232                let buf = body.to_buffer().await?;
233                Err(parse_error(Response::from_parts(part, buf)))
234            }
235        }
236    }
237
238    async fn write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::Writer)> {
239        let writer = SwiftWriter::new(self.core.clone(), args.clone(), path.to_string());
240
241        let w = oio::OneShotWriter::new(writer);
242
243        Ok((RpWrite::default(), w))
244    }
245
246    async fn delete(&self) -> Result<(RpDelete, Self::Deleter)> {
247        Ok((
248            RpDelete::default(),
249            oio::OneShotDeleter::new(SwfitDeleter::new(self.core.clone())),
250        ))
251    }
252
253    async fn list(&self, path: &str, args: OpList) -> Result<(RpList, Self::Lister)> {
254        let l = SwiftLister::new(
255            self.core.clone(),
256            path.to_string(),
257            args.recursive(),
258            args.limit(),
259        );
260
261        Ok((RpList::default(), oio::PageLister::new(l)))
262    }
263
264    async fn copy(&self, from: &str, to: &str, _args: OpCopy) -> Result<RpCopy> {
265        // cannot copy objects larger than 5 GB.
266        // Reference: https://docs.openstack.org/api-ref/object-store/#copy-object
267        let resp = self.core.swift_copy(from, to).await?;
268
269        let status = resp.status();
270
271        match status {
272            StatusCode::CREATED | StatusCode::OK => Ok(RpCopy::default()),
273            _ => Err(parse_error(resp)),
274        }
275    }
276}
opendal/services/swift/backend.rs

opendal/services/swift/
backend.rs
