kvcache 0.1.57

kvcache
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use fred::{
  interfaces::KeysInterface,
  prelude::{Client, FredResult},
  types::{Map, MultipleKeys, Value, Value::Bytes},
};
use xbin::concat;

use crate::{Cache, Vov};

pub struct PosMerge {
  pub li: Vov,
  pub pos_li: Vec<usize>,
}

impl PosMerge {
  fn new<T: Clone>(key_li: &[T], li: Vov) -> (Vec<T>, Self) {
    let mut pos_li = Vec::new();
    let mut next_key_li = Vec::new();
    for (pos, i) in li.iter().enumerate() {
      if i.is_none() {
        next_key_li.push(key_li[pos].clone());
        pos_li.push(pos);
      }
    }
    (next_key_li, Self { li, pos_li })
  }

  fn merge(self, li: impl IntoIterator<Item = Option<Vec<u8>>>) -> Vov {
    let mut r = self.li;
    let pos_li = self.pos_li;
    for (pos, i) in li.into_iter().enumerate() {
      if i.is_some() {
        r[pos_li[pos]] = i;
      }
    }
    r
  }
}

#[derive(Clone)]
pub struct UserCache<'a> {
  pub global: Box<[u8]>,
  pub user: Box<[u8]>,
  pub kv: &'a Client,
}

pub fn kvli(prefix: &[u8], map: Map) -> Vec<(Box<[u8]>, Value)> {
  map
    .inner()
    .into_iter()
    .map(|(k, v)| (concat!(prefix, k.as_bytes()).into(), v))
    .collect()
}

pub fn prefix_key<B: AsRef<[u8]>>(
  prefix: &[u8],
  keys: impl IntoIterator<Item = B>,
) -> Vec<Box<[u8]>> {
  keys
    .into_iter()
    .map(|k| concat!(prefix, k.as_ref()).into())
    .collect()
}

pub const SPLIT: &[u8] = b":";

pub fn user_prefix(prefix: impl AsRef<[u8]>, kind: impl AsRef<[u8]>, user_id: u64) -> Box<[u8]> {
  let prefix = prefix.as_ref();
  let kind = b255::encode(kind.as_ref());
  concat!(prefix, b255::encode(vb::e([user_id])), SPLIT, kind, SPLIT).into()
}

impl<'a> UserCache<'a> {
  pub fn new(
    kv: &'a Client,
    prefix: impl AsRef<[u8]>,
    kind: impl AsRef<[u8]>,
    user_id: u64,
  ) -> Self {
    let kind = b255::encode(kind.as_ref());
    let prefix = prefix.as_ref();
    let global: Box<[u8]> = concat!(prefix, kind, SPLIT).into();

    let user: Box<[u8]> =
      concat!(prefix, b255::encode(vb::e([user_id])), SPLIT, kind, SPLIT).into();
    Self { global, user, kv }
  }

  pub fn global_kvli(&self, map: Map) -> Vec<(Box<[u8]>, Value)> {
    kvli(&self.global, map)
  }
}

impl Cache for UserCache<'_> {
  async fn _get_li(&self, key_li: MultipleKeys) -> FredResult<Vov> {
    use fred::prelude::Value::String;
    let kv = &self.kv;
    let key_li = key_li.into_values();
    let mut keys = Vec::with_capacity(key_li.len());
    for i in key_li.iter() {
      match i {
        String(i) => keys.push(i.as_bytes()),
        Bytes(i) => keys.push(i),
        _ => {}
      }
    }

    let li: Vov = kv.mget(prefix_key(&self.user, &keys)).await?;
    let (key_li, pm) = PosMerge::new(&keys, li);
    let cached: Vov = kv.mget(prefix_key(&self.global, &key_li)).await?;
    Ok(pm.merge(cached))
  }

  async fn _set_li(&self, map: Map) -> FredResult<()> {
    self.kv.mset(self.global_kvli(map)).await
  }
}