键值存储X

Rust中各种键值存储后端的抽象层。专为Krill的使用场景而定制。

在各个后端之间切换应该像更改配置值一样简单。

目前默认提供了内存、文件系统和Postgres实现。

用法

创建一个KVX存储实例，并使用URL指定存储后端。例如

let namespace = Namespace::parse("some-namespace")?;

// in memory backend
let store = KeyValueStore::new(&Url::parse("memory://")?, namespace)?;

// use a file backend
let store = KeyValueStore::new(&Url::parse("local://tmp")?, namespace)?;

// use a postgres backend
let store = KeyValueStore::new(&Url::parse("postgres://user:password@host/database-name")?, namespace)?;

存储可以使用命名空间进行范围限定。命名空间可以进一步划分为（可能嵌套的）范围。

请注意，键、范围和命名空间具有Segment类型，这是将命名空间、范围和键编码到文件系统所必需的。

存储支持基本的键值操作

fn is_empty(&self) -> Result<bool>;
fn has(&self, key: &Key) -> Result<bool>;
fn has_scope(&self, scope: &Scope) -> Result<bool>;
fn get(&self, key: &Key) -> Result<Option<Value>>;
fn list_keys(&self, scope: &Scope) -> Result<Vec<Key>>;
fn list_scopes(&self) -> Result<Vec<Scope>>;

fn store(&self, key: &Key, value: Value) -> Result<()>;
fn move_value(&self, from: &Key, to: &Key) -> Result<()>;
fn move_scope(&self, from: &Scope, to: &Scope) -> Result<()>;
fn delete(&self, key: &Key) -> Result<()>;
fn delete_scope(&self, scope: &Scope) -> Result<()>;

fn clear(&self) -> Result<()>;

/// Migrate the namespace (and all key value pairs) for this store.
fn migrate_namespace(&mut self, to: NamespaceBuf) -> Result<()>;

可以使用事务原子地执行一系列操作

store.transaction(scope, &mut move |t: &dyn KeyValueStoreBackend| { 
    let key = "counter".parse()?;
    let value = t.get(&key)?;
    let new_value = value.as_i64().unwrap_or_default() + 1;
    t.store(&key, Value::from(new_value))?;
})?;

如果需要在事务中返回值（或者结果），则可以使用执行函数。值可以是结果类型，以防需要返回非kvx错误。

示例代码，其中self具有KeyValueStore，并希望返回全局范围内的所有键，同时验证某些保留键没有被使用。

主要收获是传递给执行函数的闭包可以返回类似于Result<Result<T, E>, kvx::Error>的东西。

pub fn list_verified_keys(&self) -> Result<Vec<Keys>, MyError> {
        self.store.execute(&Scope::global(), |kv| {
            let keys = kv.list_keys(&Scope::global())?;
            let forbidden_key = Key::new_global(segment!("reserved"));
            if keys.contains(&forbidden_key) {
                Ok(Err(MyError::ForbiddenKey))
            } else {
                Ok(Ok(keys))
            }
        })
        .map_err(MyError::from)
    }

use kvx::queue;

fn queue(store: &KeyValueStore) -> Result<(), kvx::Error> {
    let name = "job";
    let segment = Segment::parse(name).unwrap();
    let value = Value::from("value");

    // schedule a task
    queue.schedule_task(
        segment.into(),
        value,
        None,
        ScheduleMode::FinishOrReplaceExisting,
    )?;

    // claim a pending task
    let task_opt = queue.claim_scheduled_pending_task()?;

    if let Some(task) = task_opt {
        // do stuff...

        // then finish the task
        queue.finish_running_task(&Key::from(&task))?;
    }

    Ok(())
}