opendal/services/mini_moka/
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::time::Duration;
20
21use log::debug;
22use mini_moka::sync::Cache;
23use mini_moka::sync::CacheBuilder;
24
25use crate::raw::adapters::typed_kv;
26use crate::raw::Access;
27use crate::services::MiniMokaConfig;
28use crate::*;
29
30impl Configurator for MiniMokaConfig {
31    type Builder = MiniMokaBuilder;
32    fn into_builder(self) -> Self::Builder {
33        MiniMokaBuilder { config: self }
34    }
35}
36
37/// [mini-moka](https://github.com/moka-rs/mini-moka) backend support.
38#[doc = include_str!("docs.md")]
39#[derive(Default, Debug)]
40pub struct MiniMokaBuilder {
41    config: MiniMokaConfig,
42}
43
44impl MiniMokaBuilder {
45    /// Sets the max capacity of the cache.
46    ///
47    /// Refer to [`mini-moka::sync::CacheBuilder::max_capacity`](https://docs.rs/mini-moka/latest/mini_moka/sync/struct.CacheBuilder.html#method.max_capacity)
48    pub fn max_capacity(mut self, v: u64) -> Self {
49        if v != 0 {
50            self.config.max_capacity = Some(v);
51        }
52        self
53    }
54
55    /// Sets the time to live of the cache.
56    ///
57    /// Refer to [`mini-moka::sync::CacheBuilder::time_to_live`](https://docs.rs/mini-moka/latest/mini_moka/sync/struct.CacheBuilder.html#method.time_to_live)
58    pub fn time_to_live(mut self, v: Duration) -> Self {
59        if !v.is_zero() {
60            self.config.time_to_live = Some(v);
61        }
62        self
63    }
64
65    /// Sets the time to idle of the cache.
66    ///
67    /// Refer to [`mini-moka::sync::CacheBuilder::time_to_idle`](https://docs.rs/mini-moka/latest/mini_moka/sync/struct.CacheBuilder.html#method.time_to_idle)
68    pub fn time_to_idle(mut self, v: Duration) -> Self {
69        if !v.is_zero() {
70            self.config.time_to_idle = Some(v);
71        }
72        self
73    }
74
75    /// Set root path of this backend
76    pub fn root(mut self, path: &str) -> Self {
77        self.config.root = if path.is_empty() {
78            None
79        } else {
80            Some(path.to_string())
81        };
82
83        self
84    }
85}
86
87impl Builder for MiniMokaBuilder {
88    const SCHEME: Scheme = Scheme::MiniMoka;
89    type Config = MiniMokaConfig;
90
91    fn build(self) -> Result<impl Access> {
92        debug!("backend build started: {:?}", &self);
93
94        let mut builder: CacheBuilder<String, typed_kv::Value, _> = Cache::builder();
95        // Use entries' bytes as capacity weigher.
96        builder = builder.weigher(|k, v| (k.len() + v.size()) as u32);
97        if let Some(v) = self.config.max_capacity {
98            builder = builder.max_capacity(v)
99        }
100        if let Some(v) = self.config.time_to_live {
101            builder = builder.time_to_live(v)
102        }
103        if let Some(v) = self.config.time_to_idle {
104            builder = builder.time_to_idle(v)
105        }
106
107        debug!("backend build finished: {:?}", &self);
108        let mut backend = MiniMokaBackend::new(Adapter {
109            inner: builder.build(),
110        });
111        if let Some(v) = self.config.root {
112            backend = backend.with_root(&v);
113        }
114
115        Ok(backend)
116    }
117}
118
119/// Backend is used to serve `Accessor` support in mini-moka.
120pub type MiniMokaBackend = typed_kv::Backend<Adapter>;
121
122#[derive(Clone)]
123pub struct Adapter {
124    inner: Cache<String, typed_kv::Value>,
125}
126
127impl Debug for Adapter {
128    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
129        f.debug_struct("Adapter")
130            .field("size", &self.inner.weighted_size())
131            .field("count", &self.inner.entry_count())
132            .finish()
133    }
134}
135
136impl typed_kv::Adapter for Adapter {
137    fn info(&self) -> typed_kv::Info {
138        typed_kv::Info::new(
139            Scheme::MiniMoka,
140            "mini-moka",
141            typed_kv::Capability {
142                get: true,
143                set: true,
144                delete: true,
145                scan: true,
146                shared: false,
147            },
148        )
149    }
150
151    async fn get(&self, path: &str) -> Result<Option<typed_kv::Value>> {
152        match self.inner.get(&path.to_string()) {
153            None => Ok(None),
154            Some(bs) => Ok(Some(bs)),
155        }
156    }
157
158    async fn set(&self, path: &str, value: typed_kv::Value) -> Result<()> {
159        self.inner.insert(path.to_string(), value);
160
161        Ok(())
162    }
163
164    async fn delete(&self, path: &str) -> Result<()> {
165        self.inner.invalidate(&path.to_string());
166
167        Ok(())
168    }
169
170    async fn scan(&self, path: &str) -> Result<Vec<String>> {
171        let keys = self.inner.iter().map(|kv| kv.key().to_string());
172        if path.is_empty() {
173            Ok(keys.collect())
174        } else {
175            Ok(keys.filter(|k| k.starts_with(path)).collect())
176        }
177    }
178}
opendal/services/mini_moka/backend.rs

opendal/services/mini_moka/
backend.rs
