use std::io::{self, Write};
use crate::link::Link;
use kevy_resp::{Reply, encode_command_borrowed};
pub(super) fn export_key(
client: &mut dyn Link,
key: &[u8],
out: &mut impl Write,
) -> io::Result<Option<Option<Vec<u8>>>> {
match rebuild_frames(client, key, key)? {
Rebuilt::Frames(frame) => {
out.write_all(&frame)?;
Ok(Some(None))
}
Rebuilt::Vanished => Ok(None),
Rebuilt::UnsupportedType(ty) => Ok(Some(Some(ty))),
}
}
pub(crate) enum Rebuilt {
Frames(Vec<u8>),
Vanished,
UnsupportedType(Vec<u8>),
}
pub(crate) fn rebuild_frames(client: &mut dyn Link, key: &[u8], dst: &[u8]) -> io::Result<Rebuilt> {
let ty = match client.request_borrowed(&[b"TYPE", key])? {
Reply::Simple(t) => t,
_ => return Ok(Rebuilt::Vanished),
};
if ty == b"none" {
return Ok(Rebuilt::Vanished);
}
let mut frame = Vec::new();
encode_command_borrowed(&mut frame, &[b"DEL", dst]);
match encode_body(client, key, dst, &ty, &mut frame)? {
Some(()) => {}
None => return Ok(Rebuilt::Vanished),
}
if frame.len() == encoded_del_len(dst) {
return Ok(Rebuilt::UnsupportedType(ty));
}
append_ttl_frame(client, key, dst, &mut frame)?;
Ok(Rebuilt::Frames(frame))
}
fn encoded_del_len(dst: &[u8]) -> usize {
let mut probe = Vec::new();
encode_command_borrowed(&mut probe, &[b"DEL", dst]);
probe.len()
}
fn encode_body(
client: &mut dyn Link,
key: &[u8],
dst: &[u8],
ty: &[u8],
frame: &mut Vec<u8>,
) -> io::Result<Option<()>> {
match ty {
b"string" => {
let Reply::Bulk(v) = client.request_borrowed(&[b"GET", key])? else {
return Ok(None);
};
encode_command_borrowed(frame, &[b"SET", dst, &v]);
}
b"hash" => {
let Some(items) = fetch_bulks(client, &[b"HGETALL", key])? else {
return Ok(None);
};
encode_multi(frame, b"HSET", dst, &items);
}
b"list" => {
let Some(vals) = fetch_bulks(client, &[b"LRANGE", key, b"0", b"-1"])? else {
return Ok(None);
};
encode_multi(frame, b"RPUSH", dst, &vals);
}
b"set" => {
let Some(ms) = fetch_bulks(client, &[b"SMEMBERS", key])? else {
return Ok(None);
};
encode_multi(frame, b"SADD", dst, &ms);
}
b"zset" => {
let zrange: &[&[u8]] = &[b"ZRANGE", key, b"0", b"-1", b"WITHSCORES"];
let Some(flat) = fetch_bulks(client, zrange)? else {
return Ok(None);
};
encode_zadd(frame, dst, &flat);
}
_ => return Ok(Some(())),
}
Ok(Some(()))
}
fn fetch_bulks(client: &mut dyn Link, cmd: &[&[u8]]) -> io::Result<Option<Vec<Vec<u8>>>> {
let Reply::Array(items) = client.request_borrowed(cmd)? else {
return Ok(None);
};
if items.is_empty() {
return Ok(None);
}
Ok(Some(
items
.into_iter()
.filter_map(|r| if let Reply::Bulk(b) = r { Some(b) } else { None })
.collect(),
))
}
fn encode_multi(frame: &mut Vec<u8>, verb: &[u8], dst: &[u8], vals: &[Vec<u8>]) {
let mut argv: Vec<&[u8]> = vec![verb, dst];
argv.extend(vals.iter().map(Vec::as_slice));
encode_command_borrowed(frame, &argv);
}
fn encode_zadd(frame: &mut Vec<u8>, dst: &[u8], flat: &[Vec<u8>]) {
let mut argv: Vec<&[u8]> = vec![b"ZADD", dst];
for pair in flat.chunks(2) {
if pair.len() == 2 {
argv.push(&pair[1]);
argv.push(&pair[0]);
}
}
encode_command_borrowed(frame, &argv);
}
fn append_ttl_frame(
client: &mut dyn Link,
key: &[u8],
dst: &[u8],
frame: &mut Vec<u8>,
) -> io::Result<()> {
if let Reply::Int(ms) = client.request_borrowed(&[b"PTTL", key])?
&& ms > 0
{
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_err(io::Error::other)?
.as_millis() as i64;
encode_command_borrowed(frame, &[b"PEXPIREAT", dst, (now + ms).to_string().as_bytes()]);
}
Ok(())
}