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 super::DEFAULT_SCHEME;
32use crate::raw::*;
33use crate::services::SwiftConfig;
34use crate::*;
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    type Config = SwiftConfig;
117
118    /// Build a SwiftBackend.
119    fn build(self) -> Result<impl Access> {
120        debug!("backend build started: {:?}", &self);
121
122        let root = normalize_root(&self.config.root.unwrap_or_default());
123        debug!("backend use root {root}");
124
125        let endpoint = match self.config.endpoint {
126            Some(endpoint) => {
127                if endpoint.starts_with("http") {
128                    endpoint
129                } else {
130                    format!("https://{endpoint}")
131                }
132            }
133            None => {
134                return Err(Error::new(
135                    ErrorKind::ConfigInvalid,
136                    "missing endpoint for Swift",
137                ));
138            }
139        };
140        debug!("backend use endpoint: {}", &endpoint);
141
142        let container = match self.config.container {
143            Some(container) => container,
144            None => {
145                return Err(Error::new(
146                    ErrorKind::ConfigInvalid,
147                    "missing container for Swift",
148                ));
149            }
150        };
151
152        let token = self.config.token.unwrap_or_default();
153
154        Ok(SwiftBackend {
155            core: Arc::new(SwiftCore {
156                info: {
157                    let am = AccessorInfo::default();
158                    am.set_scheme(DEFAULT_SCHEME)
159                        .set_root(&root)
160                        .set_native_capability(Capability {
161                            stat: true,
162                            read: true,
163
164                            write: true,
165                            write_can_empty: true,
166                            write_with_user_metadata: true,
167
168                            delete: true,
169
170                            list: true,
171                            list_with_recursive: true,
172
173                            shared: true,
174
175                            ..Default::default()
176                        });
177                    am.into()
178                },
179                root,
180                endpoint,
181                container,
182                token,
183            }),
184        })
185    }
186}
187
188/// Backend for Swift service
189#[derive(Debug, Clone)]
190pub struct SwiftBackend {
191    core: Arc<SwiftCore>,
192}
193
194impl Access for SwiftBackend {
195    type Reader = HttpBody;
196    type Writer = oio::OneShotWriter<SwiftWriter>;
197    type Lister = oio::PageLister<SwiftLister>;
198    type Deleter = oio::OneShotDeleter<SwfitDeleter>;
199
200    fn info(&self) -> Arc<AccessorInfo> {
201        self.core.info.clone()
202    }
203
204    async fn stat(&self, path: &str, _args: OpStat) -> Result<RpStat> {
205        let resp = self.core.swift_get_metadata(path).await?;
206
207        match resp.status() {
208            StatusCode::OK | StatusCode::NO_CONTENT => {
209                let headers = resp.headers();
210                let mut meta = parse_into_metadata(path, headers)?;
211                let user_meta = parse_prefixed_headers(headers, "x-object-meta-");
212                if !user_meta.is_empty() {
213                    meta = meta.with_user_metadata(user_meta);
214                }
215
216                Ok(RpStat::new(meta))
217            }
218            _ => Err(parse_error(resp)),
219        }
220    }
221
222    async fn read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::Reader)> {
223        let resp = self.core.swift_read(path, args.range(), &args).await?;
224
225        let status = resp.status();
226
227        match status {
228            StatusCode::OK | StatusCode::PARTIAL_CONTENT => Ok((RpRead::new(), resp.into_body())),
229            _ => {
230                let (part, mut body) = resp.into_parts();
231                let buf = body.to_buffer().await?;
232                Err(parse_error(Response::from_parts(part, buf)))
233            }
234        }
235    }
236
237    async fn write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::Writer)> {
238        let writer = SwiftWriter::new(self.core.clone(), args.clone(), path.to_string());
239
240        let w = oio::OneShotWriter::new(writer);
241
242        Ok((RpWrite::default(), w))
243    }
244
245    async fn delete(&self) -> Result<(RpDelete, Self::Deleter)> {
246        Ok((
247            RpDelete::default(),
248            oio::OneShotDeleter::new(SwfitDeleter::new(self.core.clone())),
249        ))
250    }
251
252    async fn list(&self, path: &str, args: OpList) -> Result<(RpList, Self::Lister)> {
253        let l = SwiftLister::new(
254            self.core.clone(),
255            path.to_string(),
256            args.recursive(),
257            args.limit(),
258        );
259
260        Ok((RpList::default(), oio::PageLister::new(l)))
261    }
262
263    async fn copy(&self, from: &str, to: &str, _args: OpCopy) -> Result<RpCopy> {
264        // cannot copy objects larger than 5 GB.
265        // Reference: https://docs.openstack.org/api-ref/object-store/#copy-object
266        let resp = self.core.swift_copy(from, to).await?;
267
268        let status = resp.status();
269
270        match status {
271            StatusCode::CREATED | StatusCode::OK => Ok(RpCopy::default()),
272            _ => Err(parse_error(resp)),
273        }
274    }
275}
opendal/services/swift/backend.rs

opendal/services/swift/
backend.rs
