fast-cache 0.1.0

Embedded-first thread-per-core in-memory cache with optional Redis-compatible server
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 crate::commands::CommandSpec;
use crate::protocol::{FastCommand, FastRequest, FastResponse};
use crate::server::commands::{
    DirectCommandContext, DirectFastCommand, FastCommandContext, FastDirectCommand,
    RawCommandContext, RawDirectCommand,
};
use crate::server::wire::ServerWire;
use crate::storage::{EmbeddedStore, hash_key};

use super::Set;
use super::options::SetOptions;
use super::storage::EmbeddedStringWrite;

#[cfg(feature = "server")]
impl RawDirectCommand for Set {
    fn execute(&self, ctx: RawCommandContext<'_, '_, '_>) {
        let RawCommandContext {
            store, args, out, ..
        } = ctx;
        match SetRawArgs::from_args(store, args.as_slice()) {
            SetRawArgs::Ready { key, value, ttl_ms } => {
                store.set_slice_prehashed(hash_key(key), key, value, ttl_ms);
                out.extend_from_slice(b"+OK\r\n");
            }
            SetRawArgs::Null => out.extend_from_slice(b"$-1\r\n"),
            SetRawArgs::WrongArity => ServerWire::write_resp_error(
                out,
                &format!(
                    "ERR wrong number of arguments for '{}' command",
                    <Self as CommandSpec>::NAME
                ),
            ),
            SetRawArgs::Syntax => ServerWire::write_resp_error(out, "ERR syntax error"),
        }
    }
}

#[cfg(feature = "server")]
enum SetRawArgs<'a> {
    Ready {
        key: &'a [u8],
        value: &'a [u8],
        ttl_ms: Option<u64>,
    },
    Null,
    WrongArity,
    Syntax,
}

#[cfg(feature = "server")]
impl<'a> SetRawArgs<'a> {
    fn from_args(store: &EmbeddedStore, args: &'a [&'a [u8]]) -> Self {
        match args {
            [key, value, rest @ ..] => match SetOptions::parse(rest) {
                Some(options) => Self::from_options(store, key, value, options),
                None => Self::Syntax,
            },
            _ => Self::WrongArity,
        }
    }

    fn from_options(
        store: &EmbeddedStore,
        key: &'a [u8],
        value: &'a [u8],
        options: SetOptions,
    ) -> Self {
        match options.condition.allows(store.exists(key)) {
            true => Self::Ready {
                key,
                value,
                ttl_ms: options.ttl_ms(store, key),
            },
            false => Self::Null,
        }
    }
}

#[cfg(feature = "server")]
impl EmbeddedStringWrite for Set {}

#[cfg(feature = "server")]
impl DirectFastCommand for Set {
    fn execute_direct_fast(
        &self,
        ctx: DirectCommandContext,
        request: FastRequest<'_>,
    ) -> FastResponse {
        match request.command {
            FastCommand::Set { key, value } => {
                ctx.set_owned(key.to_vec(), value.to_vec(), None);
                FastResponse::Ok
            }
            _ => FastResponse::Error(b"ERR unsupported command".to_vec()),
        }
    }
}

#[cfg(feature = "server")]
impl FastDirectCommand for Set {
    fn execute_fast(&self, ctx: FastCommandContext<'_, '_>, command: FastCommand<'_>) {
        match command {
            FastCommand::Set { key, value } => {
                <Self as EmbeddedStringWrite>::set_decoded(
                    ctx.store,
                    ctx.key_hash,
                    key,
                    value,
                    None,
                    ctx.single_threaded,
                );
                ServerWire::write_fast_ok(ctx.out);
            }
            _ => ServerWire::write_fast_error(ctx.out, "ERR unsupported command"),
        }
    }
}