Rust 如何将PickleDB与Rocket/Juniper上下文一起使用？

我正在尝试使用内存中的键/值存储编写一个基于//Rust的GraphQL服务器

pickle数据库在开始时创建/加载，并交给rocket管理：

fn rocket() -> Rocket {
    let pickle_path = var_os(String::from("PICKLE_PATH")).unwrap_or(OsString::from("pickle.db"));
    let pickle_db_dump_policy = PickleDbDumpPolicy::PeriodicDump(Duration::from_secs(120));
    let pickle_serialization_method = SerializationMethod::Bin;

    let pickle_db: PickleDb = match Path::new(&pickle_path).exists() {
        false => PickleDb::new(pickle_path, pickle_db_dump_policy, pickle_serialization_method),
        true => PickleDb::load(pickle_path, pickle_db_dump_policy, pickle_serialization_method).unwrap(),
    };

    rocket::ignite()
        .manage(Schema::new(Query, Mutation))
        .manage(pickle_db)
        .mount(
            "/",
            routes![graphiql, get_graphql_handler, post_graphql_handler],
        )
}

我想在我的守卫中从火箭中检索PickleDb实例：

pub struct Context {
    pickle_db: PickleDb,
}

impl juniper::Context for Context {}

impl<'a, 'r> FromRequest<'a, 'r> for Context {
    type Error = ();

    fn from_request(_request: &'a Request<'r>) -> request::Outcome<Context, ()> {
        let pickle_db = _request.guard::<State<PickleDb>>()?.inner();
        Outcome::Success(Context { pickle_db })
    }
}

当我更改上下文结构以包含引用时，我会遇到一些我还不熟悉的生存期问题：

15 |     pickle_db: &PickleDb,
   |                ^ expected named lifetime parameter

我尝试使用“static”，这确实让rust非常不高兴，我尝试使用FromRequest的请求生存期（？）”r，但这也不起作用

---

我怎样才能让它工作？因为我是个新手，这是正确的方法吗

我终于有了一个解决方案，尽管对不安全的需求表明它是次优的：）

#！[允许（不安全代码）]
使用pickledb:：{pickledb，PickleDbDumpPolicy，SerializationMethod}；
使用serde:：de:：反序列化拥有；
使用serde：：序列化；
使用std：：env；
使用std:：path:：path；
使用std:：time:：Duration；
pub static mut PICKLE_DB:Option=None；
pub fn cache_init（）{
让pickle_path=env:：var（String:：from（“pickle_path”））。展开（String:：from（“pickle.db”）；
让pickle_db_dump_policy=pickledbddumppolicy:：PeriodicDump（Duration:：from_secs（120））；
让pickle\u serialization\u method=SerializationMethod:：Json；
让pickle\u db=匹配路径：：新建（&pickle\u Path）.exists（）{
false=>PickleDb:：new(
泡菜路，
pickle_db_dump_策略，
酸洗法，
),
true=>PickleDb:：load(
泡菜路，
pickle_db_dump_策略，
酸洗法，
)
.unwrap（），
};
不安全{
PICKLE\u DB=一些（PICKLE\u DB）；
}
}
pub fn cache_get（键：&str）->选项
哪里
V:反序列化拥有+std:：fmt:：调试，
{
不安全{
让pickle\u db=pickle\u db
.as_ref（）
.expect（“缓存未初始化-调用缓存_init（）”；
pickle_db.get:：（键）
}
}
pub fn cache_set（键：&str，值：&V）->结果
哪里
五:连载,，
{
不安全{
让pickle\u db=pickle\u db
.as_mut（）
.expect（“缓存未初始化-调用缓存_init（）”；
pickle_db.set:：（键，值）？；
好（（））
}
}

---

这可以简单地导入并按预期使用，但我认为当负载达到较高水平时，我会遇到问题

我终于有了一个解决方案，尽管对不安全的需求表明它是次优的：）

#！[允许（不安全代码）]
使用pickledb:：{pickledb，PickleDbDumpPolicy，SerializationMethod}；
使用serde:：de:：反序列化拥有；
使用serde：：序列化；
使用std：：env；
使用std:：path:：path；
使用std:：time:：Duration；
pub static mut PICKLE_DB:Option=None；
pub fn cache_init（）{
让pickle_path=env:：var（String:：from（“pickle_path”））。展开（String:：from（“pickle.db”）；
让pickle_db_dump_policy=pickledbddumppolicy:：PeriodicDump（Duration:：from_secs（120））；
让pickle\u serialization\u method=SerializationMethod:：Json；
让pickle\u db=匹配路径：：新建（&pickle\u Path）.exists（）{
false=>PickleDb:：new(
泡菜路，
pickle_db_dump_策略，
酸洗法，
),
true=>PickleDb:：load(
泡菜路，
pickle_db_dump_策略，
酸洗法，
)
.unwrap（），
};
不安全{
PICKLE\u DB=一些（PICKLE\u DB）；
}
}
pub fn cache_get（键：&str）->选项
哪里
V:反序列化拥有+std:：fmt:：调试，
{
不安全{
让pickle\u db=pickle\u db
.as_ref（）
.expect（“缓存未初始化-调用缓存_init（）”；
pickle_db.get:：（键）
}
}
pub fn cache_set（键：&str，值：&V）->结果
哪里
五:连载,，
{
不安全{
让pickle\u db=pickle\u db
.as_mut（）
.expect（“缓存未初始化-调用缓存_init（）”；
pickle_db.set:：（键，值）？；
好（（））
}
}

这可以简单地导入并按预期使用，但我认为当负载达到较高水平时，我会遇到问题

15 |     pickle_db: &PickleDb,
   |                ^ expected named lifetime parameter

#![allow(unsafe_code)]
use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};
use serde::de::DeserializeOwned;
use serde::Serialize;
use std::env;
use std::path::Path;
use std::time::Duration;

pub static mut PICKLE_DB: Option<PickleDb> = None;

pub fn cache_init() {
    let pickle_path = env::var(String::from("PICKLE_PATH")).unwrap_or(String::from("pickle.db"));
    let pickle_db_dump_policy = PickleDbDumpPolicy::PeriodicDump(Duration::from_secs(120));
    let pickle_serialization_method = SerializationMethod::Json;
    let pickle_db = match Path::new(&pickle_path).exists() {
        false => PickleDb::new(
            pickle_path,
            pickle_db_dump_policy,
            pickle_serialization_method,
        ),
        true => PickleDb::load(
            pickle_path,
            pickle_db_dump_policy,
            pickle_serialization_method,
        )
        .unwrap(),
    };
    unsafe {
        PICKLE_DB = Some(pickle_db);
    }
}

pub fn cache_get<V>(key: &str) -> Option<V>
where
    V: DeserializeOwned + std::fmt::Debug,
{
    unsafe {
        let pickle_db = PICKLE_DB
            .as_ref()
            .expect("cache uninitialized - call cache_init()");
        pickle_db.get::<V>(key)
    }
}

pub fn cache_set<V>(key: &str, value: &V) -> Result<(), pickledb::error::Error>
where
    V: Serialize,
{
    unsafe {
        let pickle_db = PICKLE_DB
            .as_mut()
            .expect("cache uninitialized - call cache_init()");
        pickle_db.set::<V>(key, value)?;
        Ok(())
    }
}