1516 lines
68 KiB
Rust
1516 lines
68 KiB
Rust
use crate::{error::DBError, protocol::Protocol, server::Server};
|
|
use tokio::time::{timeout, Duration};
|
|
use futures::future::select_all;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Cmd {
|
|
Ping,
|
|
Echo(String),
|
|
Select(u64), // Changed from u16 to u64
|
|
Get(String),
|
|
Set(String, String),
|
|
SetPx(String, String, u128),
|
|
SetEx(String, String, u128),
|
|
// Advanced SET with options: (key, value, ex_ms, nx, xx, get)
|
|
SetOpts(String, String, Option<u128>, bool, bool, bool),
|
|
MGet(Vec<String>),
|
|
MSet(Vec<(String, String)>),
|
|
Keys,
|
|
DbSize,
|
|
ConfigGet(String),
|
|
Info(Option<String>),
|
|
Del(String),
|
|
Type(String),
|
|
Incr(String),
|
|
Multi,
|
|
Exec,
|
|
Discard,
|
|
// Hash commands
|
|
HSet(String, Vec<(String, String)>),
|
|
HGet(String, String),
|
|
HGetAll(String),
|
|
HDel(String, Vec<String>),
|
|
HExists(String, String),
|
|
HKeys(String),
|
|
HVals(String),
|
|
HLen(String),
|
|
HMGet(String, Vec<String>),
|
|
HSetNx(String, String, String),
|
|
HIncrBy(String, String, i64),
|
|
HIncrByFloat(String, String, f64),
|
|
HScan(String, u64, Option<String>, Option<u64>), // key, cursor, pattern, count
|
|
Scan(u64, Option<String>, Option<u64>), // cursor, pattern, count
|
|
Ttl(String),
|
|
Expire(String, i64),
|
|
PExpire(String, i64),
|
|
ExpireAt(String, i64),
|
|
PExpireAt(String, i64),
|
|
Persist(String),
|
|
Exists(String),
|
|
ExistsMulti(Vec<String>),
|
|
DelMulti(Vec<String>),
|
|
Quit,
|
|
Client(Vec<String>),
|
|
ClientSetName(String),
|
|
ClientGetName,
|
|
Command(Vec<String>),
|
|
// List commands
|
|
LPush(String, Vec<String>),
|
|
RPush(String, Vec<String>),
|
|
LPop(String, Option<u64>),
|
|
RPop(String, Option<u64>),
|
|
BLPop(Vec<String>, f64),
|
|
BRPop(Vec<String>, f64),
|
|
LLen(String),
|
|
LRem(String, i64, String),
|
|
LTrim(String, i64, i64),
|
|
LIndex(String, i64),
|
|
LRange(String, i64, i64),
|
|
FlushDb,
|
|
Unknow(String),
|
|
// AGE (rage) commands — stateless
|
|
AgeGenEnc,
|
|
AgeGenSign,
|
|
AgeEncrypt(String, String), // recipient, message
|
|
AgeDecrypt(String, String), // identity, ciphertext_b64
|
|
AgeSign(String, String), // signing_secret, message
|
|
AgeVerify(String, String, String), // verify_pub, message, signature_b64
|
|
|
|
// NEW: persistent named-key commands
|
|
AgeKeygen(String), // name
|
|
AgeSignKeygen(String), // name
|
|
AgeEncryptName(String, String), // name, message
|
|
AgeDecryptName(String, String), // name, ciphertext_b64
|
|
AgeSignName(String, String), // name, message
|
|
AgeVerifyName(String, String, String), // name, message, signature_b64
|
|
AgeList,
|
|
}
|
|
|
|
impl Cmd {
|
|
pub fn from(s: &str) -> Result<(Self, Protocol, &str), DBError> {
|
|
let (protocol, remaining) = Protocol::from(s)?;
|
|
match protocol.clone() {
|
|
Protocol::Array(p) => {
|
|
let cmd = p.into_iter().map(|x| x.decode()).collect::<Vec<_>>();
|
|
if cmd.is_empty() {
|
|
return Err(DBError("cmd length is 0".to_string()));
|
|
}
|
|
Ok((
|
|
match cmd[0].to_lowercase().as_str() {
|
|
"select" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError("wrong number of arguments for SELECT".to_string()));
|
|
}
|
|
let idx = cmd[1].parse::<u64>().map_err(|_| DBError("ERR DB index is not an integer".to_string()))?;
|
|
Cmd::Select(idx)
|
|
}
|
|
"echo" => Cmd::Echo(cmd[1].clone()),
|
|
"ping" => Cmd::Ping,
|
|
"get" => Cmd::Get(cmd[1].clone()),
|
|
"set" => {
|
|
if cmd.len() < 3 {
|
|
return Err(DBError("wrong number of arguments for SET".to_string()));
|
|
}
|
|
let key = cmd[1].clone();
|
|
let val = cmd[2].clone();
|
|
|
|
// Parse optional flags: EX sec | PX ms | NX | XX | GET
|
|
let mut ex_ms: Option<u128> = None;
|
|
let mut nx = false;
|
|
let mut xx = false;
|
|
let mut getflag = false;
|
|
|
|
let mut i = 3;
|
|
while i < cmd.len() {
|
|
match cmd[i].to_lowercase().as_str() {
|
|
"ex" => {
|
|
if i + 1 >= cmd.len() {
|
|
return Err(DBError("ERR syntax error".to_string()));
|
|
}
|
|
let secs: u128 = cmd[i + 1].parse().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
ex_ms = Some(secs * 1000);
|
|
i += 2;
|
|
}
|
|
"px" => {
|
|
if i + 1 >= cmd.len() {
|
|
return Err(DBError("ERR syntax error".to_string()));
|
|
}
|
|
let ms: u128 = cmd[i + 1].parse().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
ex_ms = Some(ms);
|
|
i += 2;
|
|
}
|
|
"nx" => { nx = true; i += 1; }
|
|
"xx" => { xx = true; i += 1; }
|
|
"get" => { getflag = true; i += 1; }
|
|
_ => {
|
|
return Err(DBError(format!("unsupported cmd {:?}", cmd)));
|
|
}
|
|
}
|
|
}
|
|
|
|
// If no options, keep legacy behavior
|
|
if ex_ms.is_none() && !nx && !xx && !getflag {
|
|
Cmd::Set(key, val)
|
|
} else {
|
|
Cmd::SetOpts(key, val, ex_ms, nx, xx, getflag)
|
|
}
|
|
}
|
|
"setex" => {
|
|
if cmd.len() != 4 {
|
|
return Err(DBError(format!("wrong number of arguments for SETEX command")));
|
|
}
|
|
Cmd::SetEx(cmd[1].clone(), cmd[3].clone(), cmd[2].parse().unwrap())
|
|
}
|
|
"mget" => {
|
|
if cmd.len() < 2 {
|
|
return Err(DBError("wrong number of arguments for MGET command".to_string()));
|
|
}
|
|
Cmd::MGet(cmd[1..].to_vec())
|
|
}
|
|
"mset" => {
|
|
if cmd.len() < 3 || ((cmd.len() - 1) % 2 != 0) {
|
|
return Err(DBError("wrong number of arguments for MSET command".to_string()));
|
|
}
|
|
let mut pairs = Vec::new();
|
|
let mut i = 1;
|
|
while i + 1 < cmd.len() {
|
|
pairs.push((cmd[i].clone(), cmd[i + 1].clone()));
|
|
i += 2;
|
|
}
|
|
Cmd::MSet(pairs)
|
|
}
|
|
"config" => {
|
|
if cmd.len() != 3 || cmd[1].to_lowercase() != "get" {
|
|
return Err(DBError(format!("unsupported cmd {:?}", cmd)));
|
|
} else {
|
|
Cmd::ConfigGet(cmd[2].clone())
|
|
}
|
|
}
|
|
"keys" => {
|
|
if cmd.len() != 2 || cmd[1] != "*" {
|
|
return Err(DBError(format!("unsupported cmd {:?}", cmd)));
|
|
} else {
|
|
Cmd::Keys
|
|
}
|
|
}
|
|
"dbsize" => {
|
|
if cmd.len() != 1 {
|
|
return Err(DBError(format!("wrong number of arguments for DBSIZE command")));
|
|
}
|
|
Cmd::DbSize
|
|
}
|
|
"info" => {
|
|
let section = if cmd.len() == 2 {
|
|
Some(cmd[1].clone())
|
|
} else {
|
|
None
|
|
};
|
|
Cmd::Info(section)
|
|
}
|
|
"del" => {
|
|
if cmd.len() < 2 {
|
|
return Err(DBError(format!("wrong number of arguments for DEL command")));
|
|
}
|
|
if cmd.len() == 2 {
|
|
Cmd::Del(cmd[1].clone())
|
|
} else {
|
|
Cmd::DelMulti(cmd[1..].to_vec())
|
|
}
|
|
}
|
|
"type" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError(format!("unsupported cmd {:?}", cmd)));
|
|
}
|
|
Cmd::Type(cmd[1].clone())
|
|
}
|
|
"incr" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError(format!("unsupported cmd {:?}", cmd)));
|
|
}
|
|
Cmd::Incr(cmd[1].clone())
|
|
}
|
|
"multi" => {
|
|
if cmd.len() != 1 {
|
|
return Err(DBError(format!("unsupported cmd {:?}", cmd)));
|
|
}
|
|
Cmd::Multi
|
|
}
|
|
"exec" => {
|
|
if cmd.len() != 1 {
|
|
return Err(DBError(format!("unsupported cmd {:?}", cmd)));
|
|
}
|
|
Cmd::Exec
|
|
}
|
|
"discard" => Cmd::Discard,
|
|
// Hash commands
|
|
"hset" => {
|
|
if cmd.len() < 4 || (cmd.len() - 2) % 2 != 0 {
|
|
return Err(DBError(format!("wrong number of arguments for HSET command")));
|
|
}
|
|
let mut pairs = Vec::new();
|
|
let mut i = 2;
|
|
while i + 1 < cmd.len() {
|
|
pairs.push((cmd[i].clone(), cmd[i + 1].clone()));
|
|
i += 2;
|
|
}
|
|
Cmd::HSet(cmd[1].clone(), pairs)
|
|
}
|
|
"hget" => {
|
|
if cmd.len() != 3 {
|
|
return Err(DBError(format!("wrong number of arguments for HGET command")));
|
|
}
|
|
Cmd::HGet(cmd[1].clone(), cmd[2].clone())
|
|
}
|
|
"hgetall" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError(format!("wrong number of arguments for HGETALL command")));
|
|
}
|
|
Cmd::HGetAll(cmd[1].clone())
|
|
}
|
|
"hdel" => {
|
|
if cmd.len() < 3 {
|
|
return Err(DBError(format!("wrong number of arguments for HDEL command")));
|
|
}
|
|
Cmd::HDel(cmd[1].clone(), cmd[2..].to_vec())
|
|
}
|
|
"hexists" => {
|
|
if cmd.len() != 3 {
|
|
return Err(DBError(format!("wrong number of arguments for HEXISTS command")));
|
|
}
|
|
Cmd::HExists(cmd[1].clone(), cmd[2].clone())
|
|
}
|
|
"hkeys" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError(format!("wrong number of arguments for HKEYS command")));
|
|
}
|
|
Cmd::HKeys(cmd[1].clone())
|
|
}
|
|
"hvals" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError(format!("wrong number of arguments for HVALS command")));
|
|
}
|
|
Cmd::HVals(cmd[1].clone())
|
|
}
|
|
"hlen" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError(format!("wrong number of arguments for HLEN command")));
|
|
}
|
|
Cmd::HLen(cmd[1].clone())
|
|
}
|
|
"hmget" => {
|
|
if cmd.len() < 3 {
|
|
return Err(DBError(format!("wrong number of arguments for HMGET command")));
|
|
}
|
|
Cmd::HMGet(cmd[1].clone(), cmd[2..].to_vec())
|
|
}
|
|
"hsetnx" => {
|
|
if cmd.len() != 4 {
|
|
return Err(DBError(format!("wrong number of arguments for HSETNX command")));
|
|
}
|
|
Cmd::HSetNx(cmd[1].clone(), cmd[2].clone(), cmd[3].clone())
|
|
}
|
|
"hincrby" => {
|
|
if cmd.len() != 4 {
|
|
return Err(DBError(format!("wrong number of arguments for HINCRBY command")));
|
|
}
|
|
let delta = cmd[3].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
Cmd::HIncrBy(cmd[1].clone(), cmd[2].clone(), delta)
|
|
}
|
|
"hincrbyfloat" => {
|
|
if cmd.len() != 4 {
|
|
return Err(DBError(format!("wrong number of arguments for HINCRBYFLOAT command")));
|
|
}
|
|
let delta = cmd[3].parse::<f64>().map_err(|_| DBError("ERR value is not a valid float".to_string()))?;
|
|
Cmd::HIncrByFloat(cmd[1].clone(), cmd[2].clone(), delta)
|
|
}
|
|
"hscan" => {
|
|
if cmd.len() < 3 {
|
|
return Err(DBError(format!("wrong number of arguments for HSCAN command")));
|
|
}
|
|
|
|
let key = cmd[1].clone();
|
|
let cursor = cmd[2].parse::<u64>().map_err(|_|
|
|
DBError("ERR invalid cursor".to_string()))?;
|
|
|
|
let mut pattern = None;
|
|
let mut count = None;
|
|
let mut i = 3;
|
|
|
|
while i < cmd.len() {
|
|
match cmd[i].to_lowercase().as_str() {
|
|
"match" => {
|
|
if i + 1 >= cmd.len() {
|
|
return Err(DBError("ERR syntax error".to_string()));
|
|
}
|
|
pattern = Some(cmd[i + 1].clone());
|
|
i += 2;
|
|
}
|
|
"count" => {
|
|
if i + 1 >= cmd.len() {
|
|
return Err(DBError("ERR syntax error".to_string()));
|
|
}
|
|
count = Some(cmd[i + 1].parse::<u64>().map_err(|_|
|
|
DBError("ERR value is not an integer or out of range".to_string()))?);
|
|
i += 2;
|
|
}
|
|
_ => {
|
|
return Err(DBError(format!("ERR syntax error")));
|
|
}
|
|
}
|
|
}
|
|
|
|
Cmd::HScan(key, cursor, pattern, count)
|
|
}
|
|
"scan" => {
|
|
if cmd.len() < 2 {
|
|
return Err(DBError(format!("wrong number of arguments for SCAN command")));
|
|
}
|
|
|
|
let cursor = cmd[1].parse::<u64>().map_err(|_|
|
|
DBError("ERR invalid cursor".to_string()))?;
|
|
|
|
let mut pattern = None;
|
|
let mut count = None;
|
|
let mut i = 2;
|
|
|
|
while i < cmd.len() {
|
|
match cmd[i].to_lowercase().as_str() {
|
|
"match" => {
|
|
if i + 1 >= cmd.len() {
|
|
return Err(DBError("ERR syntax error".to_string()));
|
|
}
|
|
pattern = Some(cmd[i + 1].clone());
|
|
i += 2;
|
|
}
|
|
"count" => {
|
|
if i + 1 >= cmd.len() {
|
|
return Err(DBError("ERR syntax error".to_string()));
|
|
}
|
|
count = Some(cmd[i + 1].parse::<u64>().map_err(|_|
|
|
DBError("ERR value is not an integer or out of range".to_string()))?);
|
|
i += 2;
|
|
}
|
|
_ => {
|
|
return Err(DBError(format!("ERR syntax error")));
|
|
}
|
|
}
|
|
}
|
|
|
|
Cmd::Scan(cursor, pattern, count)
|
|
}
|
|
"ttl" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError(format!("wrong number of arguments for TTL command")));
|
|
}
|
|
Cmd::Ttl(cmd[1].clone())
|
|
}
|
|
"expire" => {
|
|
if cmd.len() != 3 {
|
|
return Err(DBError("wrong number of arguments for EXPIRE command".to_string()));
|
|
}
|
|
let secs = cmd[2].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
Cmd::Expire(cmd[1].clone(), secs)
|
|
}
|
|
"pexpire" => {
|
|
if cmd.len() != 3 {
|
|
return Err(DBError("wrong number of arguments for PEXPIRE command".to_string()));
|
|
}
|
|
let ms = cmd[2].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
Cmd::PExpire(cmd[1].clone(), ms)
|
|
}
|
|
"expireat" => {
|
|
if cmd.len() != 3 {
|
|
return Err(DBError("wrong number of arguments for EXPIREAT command".to_string()));
|
|
}
|
|
let ts = cmd[2].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
Cmd::ExpireAt(cmd[1].clone(), ts)
|
|
}
|
|
"pexpireat" => {
|
|
if cmd.len() != 3 {
|
|
return Err(DBError("wrong number of arguments for PEXPIREAT command".to_string()));
|
|
}
|
|
let ts_ms = cmd[2].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
Cmd::PExpireAt(cmd[1].clone(), ts_ms)
|
|
}
|
|
"persist" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError("wrong number of arguments for PERSIST command".to_string()));
|
|
}
|
|
Cmd::Persist(cmd[1].clone())
|
|
}
|
|
"exists" => {
|
|
if cmd.len() < 2 {
|
|
return Err(DBError(format!("wrong number of arguments for EXISTS command")));
|
|
}
|
|
if cmd.len() == 2 {
|
|
Cmd::Exists(cmd[1].clone())
|
|
} else {
|
|
Cmd::ExistsMulti(cmd[1..].to_vec())
|
|
}
|
|
}
|
|
"quit" => {
|
|
if cmd.len() != 1 {
|
|
return Err(DBError(format!("wrong number of arguments for QUIT command")));
|
|
}
|
|
Cmd::Quit
|
|
}
|
|
"client" => {
|
|
if cmd.len() > 1 {
|
|
match cmd[1].to_lowercase().as_str() {
|
|
"setname" => {
|
|
if cmd.len() == 3 {
|
|
Cmd::ClientSetName(cmd[2].clone())
|
|
} else {
|
|
return Err(DBError("wrong number of arguments for 'client setname' command".to_string()));
|
|
}
|
|
}
|
|
"getname" => {
|
|
if cmd.len() == 2 {
|
|
Cmd::ClientGetName
|
|
} else {
|
|
return Err(DBError("wrong number of arguments for 'client getname' command".to_string()));
|
|
}
|
|
}
|
|
_ => Cmd::Client(cmd[1..].to_vec()),
|
|
}
|
|
} else {
|
|
Cmd::Client(vec![])
|
|
}
|
|
}
|
|
"command" => {
|
|
let args = if cmd.len() > 1 { cmd[1..].to_vec() } else { vec![] };
|
|
Cmd::Command(args)
|
|
}
|
|
"lpush" => {
|
|
if cmd.len() < 3 {
|
|
return Err(DBError(format!("wrong number of arguments for LPUSH command")));
|
|
}
|
|
Cmd::LPush(cmd[1].clone(), cmd[2..].to_vec())
|
|
}
|
|
"rpush" => {
|
|
if cmd.len() < 3 {
|
|
return Err(DBError(format!("wrong number of arguments for RPUSH command")));
|
|
}
|
|
Cmd::RPush(cmd[1].clone(), cmd[2..].to_vec())
|
|
}
|
|
"lpop" => {
|
|
if cmd.len() < 2 || cmd.len() > 3 {
|
|
return Err(DBError(format!("wrong number of arguments for LPOP command")));
|
|
}
|
|
let count = if cmd.len() == 3 {
|
|
Some(cmd[2].parse::<u64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?)
|
|
} else {
|
|
None
|
|
};
|
|
Cmd::LPop(cmd[1].clone(), count)
|
|
}
|
|
"rpop" => {
|
|
if cmd.len() < 2 || cmd.len() > 3 {
|
|
return Err(DBError(format!("wrong number of arguments for RPOP command")));
|
|
}
|
|
let count = if cmd.len() == 3 {
|
|
Some(cmd[2].parse::<u64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?)
|
|
} else {
|
|
None
|
|
};
|
|
Cmd::RPop(cmd[1].clone(), count)
|
|
}
|
|
"blpop" => {
|
|
if cmd.len() < 3 {
|
|
return Err(DBError(format!("wrong number of arguments for BLPOP command")));
|
|
}
|
|
// keys are all but the last argument
|
|
let keys = cmd[1..cmd.len()-1].to_vec();
|
|
let timeout_f = cmd[cmd.len()-1]
|
|
.parse::<f64>()
|
|
.map_err(|_| DBError("ERR timeout is not a number".to_string()))?;
|
|
Cmd::BLPop(keys, timeout_f)
|
|
}
|
|
"brpop" => {
|
|
if cmd.len() < 3 {
|
|
return Err(DBError(format!("wrong number of arguments for BRPOP command")));
|
|
}
|
|
// keys are all but the last argument
|
|
let keys = cmd[1..cmd.len()-1].to_vec();
|
|
let timeout_f = cmd[cmd.len()-1]
|
|
.parse::<f64>()
|
|
.map_err(|_| DBError("ERR timeout is not a number".to_string()))?;
|
|
Cmd::BRPop(keys, timeout_f)
|
|
}
|
|
"llen" => {
|
|
if cmd.len() != 2 {
|
|
return Err(DBError(format!("wrong number of arguments for LLEN command")));
|
|
}
|
|
Cmd::LLen(cmd[1].clone())
|
|
}
|
|
"lrem" => {
|
|
if cmd.len() != 4 {
|
|
return Err(DBError(format!("wrong number of arguments for LREM command")));
|
|
}
|
|
let count = cmd[2].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
Cmd::LRem(cmd[1].clone(), count, cmd[3].clone())
|
|
}
|
|
"ltrim" => {
|
|
if cmd.len() != 4 {
|
|
return Err(DBError(format!("wrong number of arguments for LTRIM command")));
|
|
}
|
|
let start = cmd[2].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
let stop = cmd[3].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
Cmd::LTrim(cmd[1].clone(), start, stop)
|
|
}
|
|
"lindex" => {
|
|
if cmd.len() != 3 {
|
|
return Err(DBError(format!("wrong number of arguments for LINDEX command")));
|
|
}
|
|
let index = cmd[2].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
Cmd::LIndex(cmd[1].clone(), index)
|
|
}
|
|
"lrange" => {
|
|
if cmd.len() != 4 {
|
|
return Err(DBError(format!("wrong number of arguments for LRANGE command")));
|
|
}
|
|
let start = cmd[2].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
let stop = cmd[3].parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?;
|
|
Cmd::LRange(cmd[1].clone(), start, stop)
|
|
}
|
|
"flushdb" => {
|
|
if cmd.len() != 1 {
|
|
return Err(DBError("wrong number of arguments for FLUSHDB command".to_string()));
|
|
}
|
|
Cmd::FlushDb
|
|
}
|
|
"age" => {
|
|
if cmd.len() < 2 {
|
|
return Err(DBError("wrong number of arguments for AGE".to_string()));
|
|
}
|
|
match cmd[1].to_lowercase().as_str() {
|
|
// stateless
|
|
"genenc" => { if cmd.len() != 2 { return Err(DBError("AGE GENENC takes no args".to_string())); }
|
|
Cmd::AgeGenEnc }
|
|
"gensign" => { if cmd.len() != 2 { return Err(DBError("AGE GENSIGN takes no args".to_string())); }
|
|
Cmd::AgeGenSign }
|
|
"encrypt" => { if cmd.len() != 4 { return Err(DBError("AGE ENCRYPT <recipient> <message>".to_string())); }
|
|
Cmd::AgeEncrypt(cmd[2].clone(), cmd[3].clone()) }
|
|
"decrypt" => { if cmd.len() != 4 { return Err(DBError("AGE DECRYPT <identity> <ciphertext_b64>".to_string())); }
|
|
Cmd::AgeDecrypt(cmd[2].clone(), cmd[3].clone()) }
|
|
"sign" => { if cmd.len() != 4 { return Err(DBError("AGE SIGN <signing_secret> <message>".to_string())); }
|
|
Cmd::AgeSign(cmd[2].clone(), cmd[3].clone()) }
|
|
"verify" => { if cmd.len() != 5 { return Err(DBError("AGE VERIFY <verify_pub> <message> <signature_b64>".to_string())); }
|
|
Cmd::AgeVerify(cmd[2].clone(), cmd[3].clone(), cmd[4].clone()) }
|
|
|
|
// persistent names
|
|
"keygen" => { if cmd.len() != 3 { return Err(DBError("AGE KEYGEN <name>".to_string())); }
|
|
Cmd::AgeKeygen(cmd[2].clone()) }
|
|
"signkeygen" => { if cmd.len() != 3 { return Err(DBError("AGE SIGNKEYGEN <name>".to_string())); }
|
|
Cmd::AgeSignKeygen(cmd[2].clone()) }
|
|
"encryptname" => { if cmd.len() != 4 { return Err(DBError("AGE ENCRYPTNAME <name> <message>".to_string())); }
|
|
Cmd::AgeEncryptName(cmd[2].clone(), cmd[3].clone()) }
|
|
"decryptname" => { if cmd.len() != 4 { return Err(DBError("AGE DECRYPTNAME <name> <ciphertext_b64>".to_string())); }
|
|
Cmd::AgeDecryptName(cmd[2].clone(), cmd[3].clone()) }
|
|
"signname" => { if cmd.len() != 4 { return Err(DBError("AGE SIGNNAME <name> <message>".to_string())); }
|
|
Cmd::AgeSignName(cmd[2].clone(), cmd[3].clone()) }
|
|
"verifyname" => { if cmd.len() != 5 { return Err(DBError("AGE VERIFYNAME <name> <message> <signature_b64>".to_string())); }
|
|
Cmd::AgeVerifyName(cmd[2].clone(), cmd[3].clone(), cmd[4].clone()) }
|
|
"list" => { if cmd.len() != 2 { return Err(DBError("AGE LIST".to_string())); }
|
|
Cmd::AgeList }
|
|
_ => return Err(DBError(format!("unsupported AGE subcommand {:?}", cmd))),
|
|
}
|
|
}
|
|
_ => Cmd::Unknow(cmd[0].clone()),
|
|
},
|
|
protocol,
|
|
remaining
|
|
))
|
|
}
|
|
_ => Err(DBError(format!(
|
|
"fail to parse as cmd for {:?}",
|
|
protocol
|
|
))),
|
|
}
|
|
}
|
|
|
|
pub async fn run(self, server: &mut Server) -> Result<Protocol, DBError> {
|
|
// Handle queued commands for transactions
|
|
if server.queued_cmd.is_some()
|
|
&& !matches!(self, Cmd::Exec)
|
|
&& !matches!(self, Cmd::Multi)
|
|
&& !matches!(self, Cmd::Discard)
|
|
{
|
|
let protocol = self.clone().to_protocol();
|
|
server.queued_cmd.as_mut().unwrap().push((self, protocol));
|
|
return Ok(Protocol::SimpleString("QUEUED".to_string()));
|
|
}
|
|
|
|
match self {
|
|
Cmd::Select(db) => select_cmd(server, db).await,
|
|
Cmd::Ping => Ok(Protocol::SimpleString("PONG".to_string())),
|
|
Cmd::Echo(s) => Ok(Protocol::BulkString(s)),
|
|
Cmd::Get(k) => get_cmd(server, &k).await,
|
|
Cmd::Set(k, v) => set_cmd(server, &k, &v).await,
|
|
Cmd::SetPx(k, v, x) => set_px_cmd(server, &k, &v, &x).await,
|
|
Cmd::SetEx(k, v, x) => set_ex_cmd(server, &k, &v, &x).await,
|
|
Cmd::SetOpts(k, v, ex_ms, nx, xx, getflag) => set_with_opts_cmd(server, &k, &v, ex_ms, nx, xx, getflag).await,
|
|
Cmd::MGet(keys) => mget_cmd(server, &keys).await,
|
|
Cmd::MSet(pairs) => mset_cmd(server, &pairs).await,
|
|
Cmd::Del(k) => del_cmd(server, &k).await,
|
|
Cmd::DelMulti(keys) => del_multi_cmd(server, &keys).await,
|
|
Cmd::ConfigGet(name) => config_get_cmd(&name, server),
|
|
Cmd::Keys => keys_cmd(server).await,
|
|
Cmd::DbSize => dbsize_cmd(server).await,
|
|
Cmd::Info(section) => info_cmd(server, §ion).await,
|
|
Cmd::Type(k) => type_cmd(server, &k).await,
|
|
Cmd::Incr(key) => incr_cmd(server, &key).await,
|
|
Cmd::Multi => {
|
|
server.queued_cmd = Some(Vec::<(Cmd, Protocol)>::new());
|
|
Ok(Protocol::SimpleString("OK".to_string()))
|
|
}
|
|
Cmd::Exec => exec_cmd(server).await,
|
|
Cmd::Discard => {
|
|
if server.queued_cmd.is_some() {
|
|
server.queued_cmd = None;
|
|
Ok(Protocol::SimpleString("OK".to_string()))
|
|
} else {
|
|
Ok(Protocol::err("ERR DISCARD without MULTI"))
|
|
}
|
|
}
|
|
// Hash commands
|
|
Cmd::HSet(key, pairs) => hset_cmd(server, &key, &pairs).await,
|
|
Cmd::HGet(key, field) => hget_cmd(server, &key, &field).await,
|
|
Cmd::HGetAll(key) => hgetall_cmd(server, &key).await,
|
|
Cmd::HDel(key, fields) => hdel_cmd(server, &key, &fields).await,
|
|
Cmd::HExists(key, field) => hexists_cmd(server, &key, &field).await,
|
|
Cmd::HKeys(key) => hkeys_cmd(server, &key).await,
|
|
Cmd::HVals(key) => hvals_cmd(server, &key).await,
|
|
Cmd::HLen(key) => hlen_cmd(server, &key).await,
|
|
Cmd::HMGet(key, fields) => hmget_cmd(server, &key, &fields).await,
|
|
Cmd::HSetNx(key, field, value) => hsetnx_cmd(server, &key, &field, &value).await,
|
|
Cmd::HIncrBy(key, field, delta) => hincrby_cmd(server, &key, &field, delta).await,
|
|
Cmd::HIncrByFloat(key, field, delta) => hincrbyfloat_cmd(server, &key, &field, delta).await,
|
|
Cmd::HScan(key, cursor, pattern, count) => hscan_cmd(server, &key, &cursor, pattern.as_deref(), &count).await,
|
|
Cmd::Scan(cursor, pattern, count) => scan_cmd(server, &cursor, pattern.as_deref(), &count).await,
|
|
Cmd::Ttl(key) => ttl_cmd(server, &key).await,
|
|
Cmd::Expire(key, secs) => expire_cmd(server, &key, secs).await,
|
|
Cmd::PExpire(key, ms) => pexpire_cmd(server, &key, ms).await,
|
|
Cmd::ExpireAt(key, ts_secs) => expireat_cmd(server, &key, ts_secs).await,
|
|
Cmd::PExpireAt(key, ts_ms) => pexpireat_cmd(server, &key, ts_ms).await,
|
|
Cmd::Persist(key) => persist_cmd(server, &key).await,
|
|
Cmd::Exists(key) => exists_cmd(server, &key).await,
|
|
Cmd::ExistsMulti(keys) => exists_multi_cmd(server, &keys).await,
|
|
Cmd::Quit => Ok(Protocol::SimpleString("OK".to_string())),
|
|
Cmd::Client(_) => Ok(Protocol::SimpleString("OK".to_string())),
|
|
Cmd::ClientSetName(name) => client_setname_cmd(server, &name).await,
|
|
Cmd::ClientGetName => client_getname_cmd(server).await,
|
|
Cmd::Command(args) => command_cmd(&args),
|
|
// List commands
|
|
Cmd::LPush(key, elements) => lpush_cmd(server, &key, &elements).await,
|
|
Cmd::RPush(key, elements) => rpush_cmd(server, &key, &elements).await,
|
|
Cmd::LPop(key, count) => lpop_cmd(server, &key, &count).await,
|
|
Cmd::RPop(key, count) => rpop_cmd(server, &key, &count).await,
|
|
Cmd::BLPop(keys, timeout) => blpop_cmd(server, &keys, timeout).await,
|
|
Cmd::BRPop(keys, timeout) => brpop_cmd(server, &keys, timeout).await,
|
|
Cmd::LLen(key) => llen_cmd(server, &key).await,
|
|
Cmd::LRem(key, count, element) => lrem_cmd(server, &key, count, &element).await,
|
|
Cmd::LTrim(key, start, stop) => ltrim_cmd(server, &key, start, stop).await,
|
|
Cmd::LIndex(key, index) => lindex_cmd(server, &key, index).await,
|
|
Cmd::LRange(key, start, stop) => lrange_cmd(server, &key, start, stop).await,
|
|
Cmd::FlushDb => flushdb_cmd(server).await,
|
|
// AGE (rage): stateless
|
|
Cmd::AgeGenEnc => Ok(crate::age::cmd_age_genenc().await),
|
|
Cmd::AgeGenSign => Ok(crate::age::cmd_age_gensign().await),
|
|
Cmd::AgeEncrypt(recipient, message) => Ok(crate::age::cmd_age_encrypt(&recipient, &message).await),
|
|
Cmd::AgeDecrypt(identity, ct_b64) => Ok(crate::age::cmd_age_decrypt(&identity, &ct_b64).await),
|
|
Cmd::AgeSign(secret, message) => Ok(crate::age::cmd_age_sign(&secret, &message).await),
|
|
Cmd::AgeVerify(vpub, msg, sig_b64) => Ok(crate::age::cmd_age_verify(&vpub, &msg, &sig_b64).await),
|
|
|
|
// AGE (rage): persistent named keys
|
|
Cmd::AgeKeygen(name) => Ok(crate::age::cmd_age_keygen(server, &name).await),
|
|
Cmd::AgeSignKeygen(name) => Ok(crate::age::cmd_age_signkeygen(server, &name).await),
|
|
Cmd::AgeEncryptName(name, message) => Ok(crate::age::cmd_age_encrypt_name(server, &name, &message).await),
|
|
Cmd::AgeDecryptName(name, ct_b64) => Ok(crate::age::cmd_age_decrypt_name(server, &name, &ct_b64).await),
|
|
Cmd::AgeSignName(name, message) => Ok(crate::age::cmd_age_sign_name(server, &name, &message).await),
|
|
Cmd::AgeVerifyName(name, message, sig_b64) => Ok(crate::age::cmd_age_verify_name(server, &name, &message, &sig_b64).await),
|
|
Cmd::AgeList => Ok(crate::age::cmd_age_list(server).await),
|
|
Cmd::Unknow(s) => Ok(Protocol::err(&format!("ERR unknown command `{}`", s))),
|
|
}
|
|
}
|
|
|
|
pub fn to_protocol(self) -> Protocol {
|
|
match self {
|
|
Cmd::Select(db) => Protocol::Array(vec![Protocol::BulkString("select".to_string()), Protocol::BulkString(db.to_string())]),
|
|
Cmd::Ping => Protocol::Array(vec![Protocol::BulkString("ping".to_string())]),
|
|
Cmd::Echo(s) => Protocol::Array(vec![Protocol::BulkString("echo".to_string()), Protocol::BulkString(s)]),
|
|
Cmd::Get(k) => Protocol::Array(vec![Protocol::BulkString("get".to_string()), Protocol::BulkString(k)]),
|
|
Cmd::Set(k, v) => Protocol::Array(vec![Protocol::BulkString("set".to_string()), Protocol::BulkString(k), Protocol::BulkString(v)]),
|
|
_ => Protocol::SimpleString("...".to_string())
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn flushdb_cmd(server: &mut Server) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.flushdb() {
|
|
Ok(_) => Ok(Protocol::SimpleString("OK".to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn select_cmd(server: &mut Server, db: u64) -> Result<Protocol, DBError> {
|
|
// Test if we can access the database (this will create it if needed)
|
|
server.selected_db = db;
|
|
match server.current_storage() {
|
|
Ok(_) => Ok(Protocol::SimpleString("OK".to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn lindex_cmd(server: &Server, key: &str, index: i64) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.lindex(key, index) {
|
|
Ok(Some(element)) => Ok(Protocol::BulkString(element)),
|
|
Ok(None) => Ok(Protocol::Null),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn lrange_cmd(server: &Server, key: &str, start: i64, stop: i64) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.lrange(key, start, stop) {
|
|
Ok(elements) => Ok(Protocol::Array(elements.into_iter().map(Protocol::BulkString).collect())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn ltrim_cmd(server: &Server, key: &str, start: i64, stop: i64) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.ltrim(key, start, stop) {
|
|
Ok(_) => Ok(Protocol::SimpleString("OK".to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn lrem_cmd(server: &Server, key: &str, count: i64, element: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.lrem(key, count, element) {
|
|
Ok(removed_count) => Ok(Protocol::SimpleString(removed_count.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn llen_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.llen(key) {
|
|
Ok(len) => Ok(Protocol::SimpleString(len.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn lpop_cmd(server: &Server, key: &str, count: &Option<u64>) -> Result<Protocol, DBError> {
|
|
let count_val = count.unwrap_or(1);
|
|
match server.current_storage()?.lpop(key, count_val) {
|
|
Ok(elements) => {
|
|
if elements.is_empty() {
|
|
if count.is_some() {
|
|
Ok(Protocol::Array(vec![]))
|
|
} else {
|
|
Ok(Protocol::Null)
|
|
}
|
|
} else if count.is_some() {
|
|
Ok(Protocol::Array(elements.into_iter().map(Protocol::BulkString).collect()))
|
|
} else {
|
|
Ok(Protocol::BulkString(elements[0].clone()))
|
|
}
|
|
},
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn rpop_cmd(server: &Server, key: &str, count: &Option<u64>) -> Result<Protocol, DBError> {
|
|
let count_val = count.unwrap_or(1);
|
|
match server.current_storage()?.rpop(key, count_val) {
|
|
Ok(elements) => {
|
|
if elements.is_empty() {
|
|
if count.is_some() {
|
|
Ok(Protocol::Array(vec![]))
|
|
} else {
|
|
Ok(Protocol::Null)
|
|
}
|
|
} else if count.is_some() {
|
|
Ok(Protocol::Array(elements.into_iter().map(Protocol::BulkString).collect()))
|
|
} else {
|
|
Ok(Protocol::BulkString(elements[0].clone()))
|
|
}
|
|
},
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
// BLPOP implementation
|
|
async fn blpop_cmd(server: &Server, keys: &[String], timeout_secs: f64) -> Result<Protocol, DBError> {
|
|
// Immediate, non-blocking attempt in key order
|
|
for k in keys {
|
|
let elems = server.current_storage()?.lpop(k, 1)?;
|
|
if !elems.is_empty() {
|
|
return Ok(Protocol::Array(vec![
|
|
Protocol::BulkString(k.clone()),
|
|
Protocol::BulkString(elems[0].clone()),
|
|
]));
|
|
}
|
|
}
|
|
|
|
// If timeout is zero, return immediately with Null
|
|
if timeout_secs <= 0.0 {
|
|
return Ok(Protocol::Null);
|
|
}
|
|
|
|
// Register waiters for each key
|
|
let db_index = server.selected_db;
|
|
let mut ids: Vec<u64> = Vec::with_capacity(keys.len());
|
|
let mut names: Vec<String> = Vec::with_capacity(keys.len());
|
|
let mut rxs: Vec<tokio::sync::oneshot::Receiver<(String, String)>> = Vec::with_capacity(keys.len());
|
|
|
|
for k in keys {
|
|
let (id, rx) = server.register_waiter(db_index, k, crate::server::PopSide::Left).await;
|
|
ids.push(id);
|
|
names.push(k.clone());
|
|
rxs.push(rx);
|
|
}
|
|
|
|
// Wait for the first delivery or timeout
|
|
let wait_fut = async move {
|
|
let mut futures_vec = rxs;
|
|
loop {
|
|
if futures_vec.is_empty() {
|
|
return None;
|
|
}
|
|
let (res, idx, remaining) = select_all(futures_vec).await;
|
|
match res {
|
|
Ok((k, elem)) => {
|
|
return Some((k, elem, idx, remaining));
|
|
}
|
|
Err(_canceled) => {
|
|
// That waiter was canceled; continue with the rest
|
|
futures_vec = remaining;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
match timeout(Duration::from_secs_f64(timeout_secs), wait_fut).await {
|
|
Ok(Some((k, elem, idx, _remaining))) => {
|
|
// Unregister other waiters
|
|
for (i, key_name) in names.iter().enumerate() {
|
|
if i != idx {
|
|
server.unregister_waiter(db_index, key_name, ids[i]).await;
|
|
}
|
|
}
|
|
Ok(Protocol::Array(vec![
|
|
Protocol::BulkString(k),
|
|
Protocol::BulkString(elem),
|
|
]))
|
|
}
|
|
Ok(None) => {
|
|
// No futures left; unregister all waiters
|
|
for (i, key_name) in names.iter().enumerate() {
|
|
server.unregister_waiter(db_index, key_name, ids[i]).await;
|
|
}
|
|
Ok(Protocol::Null)
|
|
}
|
|
Err(_elapsed) => {
|
|
// Timeout: unregister all waiters
|
|
for (i, key_name) in names.iter().enumerate() {
|
|
server.unregister_waiter(db_index, key_name, ids[i]).await;
|
|
}
|
|
Ok(Protocol::Null)
|
|
}
|
|
}
|
|
}
|
|
|
|
// BRPOP implementation (mirror of BLPOP, popping from the right)
|
|
async fn brpop_cmd(server: &Server, keys: &[String], timeout_secs: f64) -> Result<Protocol, DBError> {
|
|
// Immediate, non-blocking attempt in key order using RPOP
|
|
for k in keys {
|
|
let elems = server.current_storage()?.rpop(k, 1)?;
|
|
if !elems.is_empty() {
|
|
return Ok(Protocol::Array(vec![
|
|
Protocol::BulkString(k.clone()),
|
|
Protocol::BulkString(elems[0].clone()),
|
|
]));
|
|
}
|
|
}
|
|
|
|
// If timeout is zero, return immediately with Null
|
|
if timeout_secs <= 0.0 {
|
|
return Ok(Protocol::Null);
|
|
}
|
|
|
|
// Register waiters for each key (Right side)
|
|
let db_index = server.selected_db;
|
|
let mut ids: Vec<u64> = Vec::with_capacity(keys.len());
|
|
let mut names: Vec<String> = Vec::with_capacity(keys.len());
|
|
let mut rxs: Vec<tokio::sync::oneshot::Receiver<(String, String)>> = Vec::with_capacity(keys.len());
|
|
|
|
for k in keys {
|
|
let (id, rx) = server.register_waiter(db_index, k, crate::server::PopSide::Right).await;
|
|
ids.push(id);
|
|
names.push(k.clone());
|
|
rxs.push(rx);
|
|
}
|
|
|
|
// Wait for the first delivery or timeout
|
|
let wait_fut = async move {
|
|
let mut futures_vec = rxs;
|
|
loop {
|
|
if futures_vec.is_empty() {
|
|
return None;
|
|
}
|
|
let (res, idx, remaining) = select_all(futures_vec).await;
|
|
match res {
|
|
Ok((k, elem)) => {
|
|
return Some((k, elem, idx, remaining));
|
|
}
|
|
Err(_canceled) => {
|
|
// That waiter was canceled; continue with the rest
|
|
futures_vec = remaining;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
match timeout(Duration::from_secs_f64(timeout_secs), wait_fut).await {
|
|
Ok(Some((k, elem, idx, _remaining))) => {
|
|
// Unregister other waiters
|
|
for (i, key_name) in names.iter().enumerate() {
|
|
if i != idx {
|
|
server.unregister_waiter(db_index, key_name, ids[i]).await;
|
|
}
|
|
}
|
|
Ok(Protocol::Array(vec![
|
|
Protocol::BulkString(k),
|
|
Protocol::BulkString(elem),
|
|
]))
|
|
}
|
|
Ok(None) => {
|
|
// No futures left; unregister all waiters
|
|
for (i, key_name) in names.iter().enumerate() {
|
|
server.unregister_waiter(db_index, key_name, ids[i]).await;
|
|
}
|
|
Ok(Protocol::Null)
|
|
}
|
|
Err(_elapsed) => {
|
|
// Timeout: unregister all waiters
|
|
for (i, key_name) in names.iter().enumerate() {
|
|
server.unregister_waiter(db_index, key_name, ids[i]).await;
|
|
}
|
|
Ok(Protocol::Null)
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn lpush_cmd(server: &Server, key: &str, elements: &[String]) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.lpush(key, elements.to_vec()) {
|
|
Ok(len) => {
|
|
// Attempt to deliver to any blocked BLPOP waiters
|
|
let _ = server.drain_waiters_after_push(key).await;
|
|
Ok(Protocol::SimpleString(len.to_string()))
|
|
}
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn rpush_cmd(server: &Server, key: &str, elements: &[String]) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.rpush(key, elements.to_vec()) {
|
|
Ok(len) => {
|
|
// Attempt to deliver to any blocked BLPOP waiters
|
|
let _ = server.drain_waiters_after_push(key).await;
|
|
Ok(Protocol::SimpleString(len.to_string()))
|
|
}
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn exec_cmd(server: &mut Server) -> Result<Protocol, DBError> {
|
|
// Move the queued commands out of `server` so we drop the borrow immediately.
|
|
let cmds = if let Some(cmds) = server.queued_cmd.take() {
|
|
cmds
|
|
} else {
|
|
return Ok(Protocol::err("ERR EXEC without MULTI"));
|
|
};
|
|
|
|
let mut out = Vec::new();
|
|
for (cmd, _) in cmds {
|
|
// Use Box::pin to handle recursion in async function
|
|
let res = Box::pin(cmd.run(server)).await?;
|
|
out.push(res);
|
|
}
|
|
Ok(Protocol::Array(out))
|
|
}
|
|
|
|
async fn incr_cmd(server: &Server, key: &String) -> Result<Protocol, DBError> {
|
|
let storage = server.current_storage()?;
|
|
let current_value = storage.get(key)?;
|
|
|
|
let new_value = match current_value {
|
|
Some(v) => {
|
|
match v.parse::<i64>() {
|
|
Ok(num) => num + 1,
|
|
Err(_) => return Ok(Protocol::err("ERR value is not an integer or out of range")),
|
|
}
|
|
}
|
|
None => 1,
|
|
};
|
|
|
|
storage.set(key.clone(), new_value.to_string())?;
|
|
Ok(Protocol::SimpleString(new_value.to_string()))
|
|
}
|
|
|
|
fn config_get_cmd(name: &String, server: &Server) -> Result<Protocol, DBError> {
|
|
let value = match name.as_str() {
|
|
"dir" => Some(server.option.dir.clone()),
|
|
"dbfilename" => Some(format!("{}.db", server.selected_db)),
|
|
"databases" => Some("16".to_string()), // Hardcoded as per original logic
|
|
_ => None,
|
|
};
|
|
|
|
if let Some(val) = value {
|
|
Ok(Protocol::Array(vec![
|
|
Protocol::BulkString(name.clone()),
|
|
Protocol::BulkString(val),
|
|
]))
|
|
} else {
|
|
// Return an empty array for unknown config options, which is standard Redis behavior
|
|
Ok(Protocol::Array(vec![]))
|
|
}
|
|
}
|
|
|
|
async fn keys_cmd(server: &Server) -> Result<Protocol, DBError> {
|
|
let keys = server.current_storage()?.keys("*")?;
|
|
Ok(Protocol::Array(
|
|
keys.into_iter().map(Protocol::BulkString).collect(),
|
|
))
|
|
}
|
|
|
|
async fn dbsize_cmd(server: &Server) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.dbsize() {
|
|
Ok(n) => Ok(Protocol::SimpleString(n.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn info_cmd(server: &Server, section: &Option<String>) -> Result<Protocol, DBError> {
|
|
let storage_info = server.current_storage()?.info()?;
|
|
let mut info_map: std::collections::HashMap<String, String> = storage_info.into_iter().collect();
|
|
|
|
info_map.insert("redis_version".to_string(), "7.0.0".to_string());
|
|
info_map.insert("selected_db".to_string(), server.selected_db.to_string());
|
|
info_map.insert("backend".to_string(), format!("{:?}", server.option.backend));
|
|
|
|
|
|
let mut info_string = String::new();
|
|
info_string.push_str("# Server\n");
|
|
info_string.push_str(&format!("redis_version:{}\n", info_map.get("redis_version").unwrap()));
|
|
info_string.push_str(&format!("backend:{}\n", info_map.get("backend").unwrap()));
|
|
info_string.push_str(&format!("encrypted:{}\n", info_map.get("is_encrypted").unwrap()));
|
|
|
|
info_string.push_str("# Keyspace\n");
|
|
info_string.push_str(&format!("db{}:keys={},expires=0,avg_ttl=0\n", info_map.get("selected_db").unwrap(), info_map.get("db_size").unwrap()));
|
|
|
|
match section {
|
|
Some(s) => {
|
|
let sl = s.to_lowercase();
|
|
if sl == "replication" {
|
|
Ok(Protocol::BulkString(
|
|
"role:master\nmaster_replid:8371b4fb1155b71f4a04d3e1bc3e18c4a990aeea\nmaster_repl_offset:0\n".to_string()
|
|
))
|
|
} else {
|
|
// Return general info for unknown sections (e.g., SERVER)
|
|
Ok(Protocol::BulkString(info_string))
|
|
}
|
|
}
|
|
None => Ok(Protocol::BulkString(info_string)),
|
|
}
|
|
}
|
|
|
|
async fn type_cmd(server: &Server, k: &String) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.get_key_type(k)? {
|
|
Some(type_str) => Ok(Protocol::SimpleString(type_str)),
|
|
None => Ok(Protocol::SimpleString("none".to_string())),
|
|
}
|
|
}
|
|
|
|
async fn del_cmd(server: &Server, k: &str) -> Result<Protocol, DBError> {
|
|
server.current_storage()?.del(k.to_string())?;
|
|
Ok(Protocol::SimpleString("1".to_string()))
|
|
}
|
|
|
|
async fn set_ex_cmd(
|
|
server: &Server,
|
|
k: &str,
|
|
v: &str,
|
|
x: &u128,
|
|
) -> Result<Protocol, DBError> {
|
|
server.current_storage()?.setx(k.to_string(), v.to_string(), *x * 1000)?;
|
|
Ok(Protocol::SimpleString("OK".to_string()))
|
|
}
|
|
|
|
async fn set_px_cmd(
|
|
server: &Server,
|
|
k: &str,
|
|
v: &str,
|
|
x: &u128,
|
|
) -> Result<Protocol, DBError> {
|
|
server.current_storage()?.setx(k.to_string(), v.to_string(), *x)?;
|
|
Ok(Protocol::SimpleString("OK".to_string()))
|
|
}
|
|
|
|
async fn set_cmd(server: &Server, k: &str, v: &str) -> Result<Protocol, DBError> {
|
|
server.current_storage()?.set(k.to_string(), v.to_string())?;
|
|
Ok(Protocol::SimpleString("OK".to_string()))
|
|
}
|
|
|
|
// Advanced SET with options: EX/PX/NX/XX/GET
|
|
async fn set_with_opts_cmd(
|
|
server: &Server,
|
|
key: &str,
|
|
value: &str,
|
|
ex_ms: Option<u128>,
|
|
nx: bool,
|
|
xx: bool,
|
|
get_old: bool,
|
|
) -> Result<Protocol, DBError> {
|
|
let storage = server.current_storage()?;
|
|
|
|
// Determine existence (for NX/XX)
|
|
let exists = storage.exists(key)?;
|
|
|
|
// If both NX and XX, condition can never be satisfied -> no-op
|
|
let mut should_set = true;
|
|
if nx && exists {
|
|
should_set = false;
|
|
}
|
|
if xx && !exists {
|
|
should_set = false;
|
|
}
|
|
|
|
// Fetch old value if needed for GET
|
|
let old_val = if get_old {
|
|
storage.get(key)?
|
|
} else {
|
|
None
|
|
};
|
|
|
|
if should_set {
|
|
if let Some(ms) = ex_ms {
|
|
storage.setx(key.to_string(), value.to_string(), ms)?;
|
|
} else {
|
|
storage.set(key.to_string(), value.to_string())?;
|
|
}
|
|
}
|
|
|
|
if get_old {
|
|
// Return previous value (or Null), regardless of NX/XX outcome only if set executed?
|
|
// We follow Redis semantics: return old value if set executed, else Null
|
|
if should_set {
|
|
Ok(old_val.map_or(Protocol::Null, Protocol::BulkString))
|
|
} else {
|
|
Ok(Protocol::Null)
|
|
}
|
|
} else {
|
|
if should_set {
|
|
Ok(Protocol::SimpleString("OK".to_string()))
|
|
} else {
|
|
Ok(Protocol::Null)
|
|
}
|
|
}
|
|
}
|
|
|
|
// MGET: return array of bulk strings or Null for missing
|
|
async fn mget_cmd(server: &Server, keys: &[String]) -> Result<Protocol, DBError> {
|
|
let mut out: Vec<Protocol> = Vec::with_capacity(keys.len());
|
|
let storage = server.current_storage()?;
|
|
for k in keys {
|
|
match storage.get(k)? {
|
|
Some(v) => out.push(Protocol::BulkString(v)),
|
|
None => out.push(Protocol::Null),
|
|
}
|
|
}
|
|
Ok(Protocol::Array(out))
|
|
}
|
|
|
|
// MSET: set multiple key/value pairs, return OK
|
|
async fn mset_cmd(server: &Server, pairs: &[(String, String)]) -> Result<Protocol, DBError> {
|
|
let storage = server.current_storage()?;
|
|
for (k, v) in pairs {
|
|
storage.set(k.clone(), v.clone())?;
|
|
}
|
|
Ok(Protocol::SimpleString("OK".to_string()))
|
|
}
|
|
|
|
// DEL with multiple keys: return count of keys actually deleted
|
|
async fn del_multi_cmd(server: &Server, keys: &[String]) -> Result<Protocol, DBError> {
|
|
let storage = server.current_storage()?;
|
|
let mut deleted = 0i64;
|
|
for k in keys {
|
|
if storage.exists(k)? {
|
|
storage.del(k.clone())?;
|
|
deleted += 1;
|
|
}
|
|
}
|
|
Ok(Protocol::SimpleString(deleted.to_string()))
|
|
}
|
|
|
|
// EXISTS with multiple keys: return count existing
|
|
async fn exists_multi_cmd(server: &Server, keys: &[String]) -> Result<Protocol, DBError> {
|
|
let storage = server.current_storage()?;
|
|
let mut count = 0i64;
|
|
for k in keys {
|
|
if storage.exists(k)? {
|
|
count += 1;
|
|
}
|
|
}
|
|
Ok(Protocol::SimpleString(count.to_string()))
|
|
}
|
|
|
|
async fn get_cmd(server: &Server, k: &str) -> Result<Protocol, DBError> {
|
|
let v = server.current_storage()?.get(k)?;
|
|
Ok(v.map_or(Protocol::Null, Protocol::BulkString))
|
|
}
|
|
|
|
// Hash command implementations
|
|
async fn hset_cmd(server: &Server, key: &str, pairs: &[(String, String)]) -> Result<Protocol, DBError> {
|
|
let new_fields = server.current_storage()?.hset(key, pairs.to_vec())?;
|
|
Ok(Protocol::SimpleString(new_fields.to_string()))
|
|
}
|
|
|
|
async fn hget_cmd(server: &Server, key: &str, field: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hget(key, field) {
|
|
Ok(Some(value)) => Ok(Protocol::BulkString(value)),
|
|
Ok(None) => Ok(Protocol::Null),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn hgetall_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hgetall(key) {
|
|
Ok(pairs) => {
|
|
let mut result = Vec::new();
|
|
for (field, value) in pairs {
|
|
result.push(Protocol::BulkString(field));
|
|
result.push(Protocol::BulkString(value));
|
|
}
|
|
Ok(Protocol::Array(result))
|
|
}
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn hdel_cmd(server: &Server, key: &str, fields: &[String]) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hdel(key, fields.to_vec()) {
|
|
Ok(deleted) => Ok(Protocol::SimpleString(deleted.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn hexists_cmd(server: &Server, key: &str, field: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hexists(key, field) {
|
|
Ok(exists) => Ok(Protocol::SimpleString(if exists { "1" } else { "0" }.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn hkeys_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hkeys(key) {
|
|
Ok(keys) => Ok(Protocol::Array(
|
|
keys.into_iter().map(Protocol::BulkString).collect(),
|
|
)),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn hvals_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hvals(key) {
|
|
Ok(values) => Ok(Protocol::Array(
|
|
values.into_iter().map(Protocol::BulkString).collect(),
|
|
)),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn hlen_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hlen(key) {
|
|
Ok(len) => Ok(Protocol::SimpleString(len.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn hmget_cmd(server: &Server, key: &str, fields: &[String]) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hmget(key, fields.to_vec()) {
|
|
Ok(values) => {
|
|
let result: Vec<Protocol> = values
|
|
.into_iter()
|
|
.map(|v| v.map_or(Protocol::Null, Protocol::BulkString))
|
|
.collect();
|
|
Ok(Protocol::Array(result))
|
|
}
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn hsetnx_cmd(server: &Server, key: &str, field: &str, value: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hsetnx(key, field, value) {
|
|
Ok(was_set) => Ok(Protocol::SimpleString(if was_set { "1" } else { "0" }.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn hincrby_cmd(server: &Server, key: &str, field: &str, delta: i64) -> Result<Protocol, DBError> {
|
|
let storage = server.current_storage()?;
|
|
let current = storage.hget(key, field)?;
|
|
let base: i64 = match current {
|
|
Some(v) => v.parse::<i64>().map_err(|_| DBError("ERR value is not an integer or out of range".to_string()))?,
|
|
None => 0,
|
|
};
|
|
let new_val = base.checked_add(delta).ok_or_else(|| DBError("ERR increment or decrement would overflow".to_string()))?;
|
|
// Update the field
|
|
storage.hset(key, vec![(field.to_string(), new_val.to_string())])?;
|
|
Ok(Protocol::SimpleString(new_val.to_string()))
|
|
}
|
|
|
|
async fn hincrbyfloat_cmd(server: &Server, key: &str, field: &str, delta: f64) -> Result<Protocol, DBError> {
|
|
let storage = server.current_storage()?;
|
|
let current = storage.hget(key, field)?;
|
|
let base: f64 = match current {
|
|
Some(v) => v.parse::<f64>().map_err(|_| DBError("ERR value is not a valid float".to_string()))?,
|
|
None => 0.0,
|
|
};
|
|
let new_val = base + delta;
|
|
// Update the field
|
|
storage.hset(key, vec![(field.to_string(), new_val.to_string())])?;
|
|
Ok(Protocol::SimpleString(new_val.to_string()))
|
|
}
|
|
|
|
async fn scan_cmd(
|
|
server: &Server,
|
|
cursor: &u64,
|
|
pattern: Option<&str>,
|
|
count: &Option<u64>
|
|
) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.scan(*cursor, pattern, *count) {
|
|
Ok((next_cursor, key_value_pairs)) => {
|
|
let mut result = Vec::new();
|
|
result.push(Protocol::BulkString(next_cursor.to_string()));
|
|
// For SCAN, we only return the keys, not the values
|
|
let keys: Vec<Protocol> = key_value_pairs.into_iter().map(|(key, _)| Protocol::BulkString(key)).collect();
|
|
result.push(Protocol::Array(keys));
|
|
Ok(Protocol::Array(result))
|
|
}
|
|
Err(e) => Ok(Protocol::err(&format!("ERR {}", e.0))),
|
|
}
|
|
}
|
|
|
|
async fn hscan_cmd(
|
|
server: &Server,
|
|
key: &str,
|
|
cursor: &u64,
|
|
pattern: Option<&str>,
|
|
count: &Option<u64>
|
|
) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.hscan(key, *cursor, pattern, *count) {
|
|
Ok((next_cursor, field_value_pairs)) => {
|
|
let mut result = Vec::new();
|
|
result.push(Protocol::BulkString(next_cursor.to_string()));
|
|
// For HSCAN, we return field-value pairs flattened
|
|
let mut fields_and_values = Vec::new();
|
|
for (field, value) in field_value_pairs {
|
|
fields_and_values.push(Protocol::BulkString(field));
|
|
fields_and_values.push(Protocol::BulkString(value));
|
|
}
|
|
result.push(Protocol::Array(fields_and_values));
|
|
Ok(Protocol::Array(result))
|
|
}
|
|
Err(e) => Ok(Protocol::err(&format!("ERR {}", e.0))),
|
|
}
|
|
}
|
|
|
|
async fn ttl_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.ttl(key) {
|
|
Ok(ttl) => Ok(Protocol::SimpleString(ttl.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn exists_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.exists(key) {
|
|
Ok(exists) => Ok(Protocol::SimpleString(if exists { "1" } else { "0" }.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
// EXPIRE key seconds -> 1 if timeout set, 0 otherwise
|
|
async fn expire_cmd(server: &Server, key: &str, secs: i64) -> Result<Protocol, DBError> {
|
|
if secs < 0 {
|
|
return Ok(Protocol::SimpleString("0".to_string()));
|
|
}
|
|
match server.current_storage()?.expire_seconds(key, secs as u64) {
|
|
Ok(applied) => Ok(Protocol::SimpleString(if applied { "1" } else { "0" }.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
// PEXPIRE key milliseconds -> 1 if timeout set, 0 otherwise
|
|
async fn pexpire_cmd(server: &Server, key: &str, ms: i64) -> Result<Protocol, DBError> {
|
|
if ms < 0 {
|
|
return Ok(Protocol::SimpleString("0".to_string()));
|
|
}
|
|
match server.current_storage()?.pexpire_millis(key, ms as u128) {
|
|
Ok(applied) => Ok(Protocol::SimpleString(if applied { "1" } else { "0" }.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
// PERSIST key -> 1 if timeout removed, 0 otherwise
|
|
async fn persist_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.persist(key) {
|
|
Ok(removed) => Ok(Protocol::SimpleString(if removed { "1" } else { "0" }.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
// EXPIREAT key timestamp-seconds -> 1 if timeout set, 0 otherwise
|
|
async fn expireat_cmd(server: &Server, key: &str, ts_secs: i64) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.expire_at_seconds(key, ts_secs) {
|
|
Ok(applied) => Ok(Protocol::SimpleString(if applied { "1" } else { "0" }.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
// PEXPIREAT key timestamp-milliseconds -> 1 if timeout set, 0 otherwise
|
|
async fn pexpireat_cmd(server: &Server, key: &str, ts_ms: i64) -> Result<Protocol, DBError> {
|
|
match server.current_storage()?.pexpire_at_millis(key, ts_ms) {
|
|
Ok(applied) => Ok(Protocol::SimpleString(if applied { "1" } else { "0" }.to_string())),
|
|
Err(e) => Ok(Protocol::err(&e.0)),
|
|
}
|
|
}
|
|
|
|
async fn client_setname_cmd(server: &mut Server, name: &str) -> Result<Protocol, DBError> {
|
|
server.client_name = Some(name.to_string());
|
|
Ok(Protocol::SimpleString("OK".to_string()))
|
|
}
|
|
|
|
async fn client_getname_cmd(server: &Server) -> Result<Protocol, DBError> {
|
|
match &server.client_name {
|
|
Some(name) => Ok(Protocol::BulkString(name.clone())),
|
|
None => Ok(Protocol::Null),
|
|
}
|
|
}
|
|
|
|
// Minimal COMMAND subcommands stub to satisfy redis-cli probes.
|
|
// - COMMAND DOCS ... => return empty array
|
|
// - COMMAND INFO ... => return empty array
|
|
// - Any other => empty array
|
|
fn command_cmd(args: &[String]) -> Result<Protocol, DBError> {
|
|
if args.is_empty() {
|
|
return Ok(Protocol::Array(vec![]));
|
|
}
|
|
let sub = args[0].to_lowercase();
|
|
match sub.as_str() {
|
|
"docs" => Ok(Protocol::Array(vec![])),
|
|
"info" => Ok(Protocol::Array(vec![])),
|
|
_ => Ok(Protocol::Array(vec![])),
|
|
}
|
|
}
|