opendal/services/memory/
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::collections::BTreeMap;
19use std::fmt::Debug;
20use std::sync::Arc;
21use std::sync::Mutex;
22
23use crate::raw::adapters::typed_kv;
24use crate::raw::Access;
25use crate::services::MemoryConfig;
26use crate::*;
27
28impl Configurator for MemoryConfig {
29    type Builder = MemoryBuilder;
30    fn into_builder(self) -> Self::Builder {
31        MemoryBuilder { config: self }
32    }
33}
34
35/// In memory service support. (BTreeMap Based)
36#[doc = include_str!("docs.md")]
37#[derive(Default)]
38pub struct MemoryBuilder {
39    config: MemoryConfig,
40}
41
42impl MemoryBuilder {
43    /// Set the root for BTreeMap.
44    pub fn root(mut self, path: &str) -> Self {
45        self.config.root = Some(path.into());
46        self
47    }
48}
49
50impl Builder for MemoryBuilder {
51    const SCHEME: Scheme = Scheme::Memory;
52    type Config = MemoryConfig;
53
54    fn build(self) -> Result<impl Access> {
55        let adapter = Adapter {
56            inner: Arc::new(Mutex::new(BTreeMap::default())),
57        };
58
59        Ok(MemoryBackend::new(adapter).with_root(self.config.root.as_deref().unwrap_or_default()))
60    }
61}
62
63/// Backend is used to serve `Accessor` support in memory.
64pub type MemoryBackend = typed_kv::Backend<Adapter>;
65
66#[derive(Clone)]
67pub struct Adapter {
68    inner: Arc<Mutex<BTreeMap<String, typed_kv::Value>>>,
69}
70
71impl Debug for Adapter {
72    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
73        f.debug_struct("MemoryBackend").finish_non_exhaustive()
74    }
75}
76
77impl typed_kv::Adapter for Adapter {
78    fn info(&self) -> typed_kv::Info {
79        typed_kv::Info::new(
80            Scheme::Memory,
81            &format!("{:p}", Arc::as_ptr(&self.inner)),
82            typed_kv::Capability {
83                get: true,
84                set: true,
85                delete: true,
86                scan: true,
87                shared: false,
88            },
89        )
90    }
91
92    async fn get(&self, path: &str) -> Result<Option<typed_kv::Value>> {
93        self.blocking_get(path)
94    }
95
96    fn blocking_get(&self, path: &str) -> Result<Option<typed_kv::Value>> {
97        match self.inner.lock().unwrap().get(path) {
98            None => Ok(None),
99            Some(bs) => Ok(Some(bs.to_owned())),
100        }
101    }
102
103    async fn set(&self, path: &str, value: typed_kv::Value) -> Result<()> {
104        self.blocking_set(path, value)
105    }
106
107    fn blocking_set(&self, path: &str, value: typed_kv::Value) -> Result<()> {
108        self.inner.lock().unwrap().insert(path.to_string(), value);
109
110        Ok(())
111    }
112
113    async fn delete(&self, path: &str) -> Result<()> {
114        self.blocking_delete(path)
115    }
116
117    fn blocking_delete(&self, path: &str) -> Result<()> {
118        self.inner.lock().unwrap().remove(path);
119
120        Ok(())
121    }
122
123    async fn scan(&self, path: &str) -> Result<Vec<String>> {
124        self.blocking_scan(path)
125    }
126
127    fn blocking_scan(&self, path: &str) -> Result<Vec<String>> {
128        let inner = self.inner.lock().unwrap();
129
130        if path.is_empty() {
131            return Ok(inner.keys().cloned().collect());
132        }
133
134        let mut keys = Vec::new();
135        for (key, _) in inner.range(path.to_string()..) {
136            if !key.starts_with(path) {
137                break;
138            }
139            keys.push(key.to_string());
140        }
141        Ok(keys)
142    }
143}
144
145#[cfg(test)]
146mod tests {
147    use super::*;
148    use crate::raw::adapters::typed_kv::{Adapter, Value};
149
150    #[test]
151    fn test_accessor_metadata_name() {
152        let b1 = MemoryBuilder::default().build().unwrap();
153        assert_eq!(b1.info().name(), b1.info().name());
154
155        let b2 = MemoryBuilder::default().build().unwrap();
156        assert_ne!(b1.info().name(), b2.info().name())
157    }
158
159    #[test]
160    fn test_blocking_scan() {
161        let adapter = super::Adapter {
162            inner: Arc::new(Mutex::new(BTreeMap::default())),
163        };
164
165        adapter.blocking_set("aaa/bbb/", Value::new_dir()).unwrap();
166        adapter.blocking_set("aab/bbb/", Value::new_dir()).unwrap();
167        adapter.blocking_set("aab/ccc/", Value::new_dir()).unwrap();
168        adapter
169            .blocking_set(&format!("aab{}aaa/", std::char::MAX), Value::new_dir())
170            .unwrap();
171        adapter.blocking_set("aac/bbb/", Value::new_dir()).unwrap();
172
173        let data = adapter.blocking_scan("aab").unwrap();
174        assert_eq!(data.len(), 3);
175        for path in data {
176            assert!(path.starts_with("aab"));
177        }
178    }
179}
opendal/services/memory/backend.rs

opendal/services/memory/
backend.rs
