use std::io::{BufRead, BufReader, Write};
use std::net::{TcpStream, ToSocketAddrs};
use std::time::Duration;
#[derive(Debug)]
pub struct OpenKacheError {
pub code: String,
pub message: String,
}
impl std::fmt::Display for OpenKacheError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "[{}] {}", self.code, self.message)
}
}
impl std::error::Error for OpenKacheError {}
pub struct Client {
reader: Option<BufReader<TcpStream>>,
host: String,
port: u16,
timeout: Duration,
}
impl Client {
pub fn new(host: &str, port: u16) -> Self {
Self {
reader: None,
host: host.to_string(),
port,
timeout: Duration::from_secs(5),
}
}
pub fn connect(&mut self) -> Result<(), OpenKacheError> {
if self.reader.is_some() {
return Ok(());
}
let addr = format!("{}:{}", self.host, self.port);
let addr = addr
.to_socket_addrs()
.map_err(|e| OpenKacheError {
code: "CONNECTION_REFUSED".into(),
message: e.to_string(),
})?
.next()
.ok_or_else(|| OpenKacheError {
code: "CONNECTION_REFUSED".into(),
message: "DNS resolution failed".into(),
})?;
let stream = TcpStream::connect_timeout(&addr, self.timeout).map_err(|e| {
OpenKacheError {
code: "CONNECTION_REFUSED".into(),
message: e.to_string(),
}
})?;
stream.set_read_timeout(Some(self.timeout)).ok();
self.reader = Some(BufReader::new(stream));
Ok(())
}
fn send(&mut self, cmd: &str) -> Result<String, OpenKacheError> {
let reader = self
.reader
.as_mut()
.ok_or_else(|| OpenKacheError {
code: "CONNECTION_REFUSED".into(),
message: "Not connected".into(),
})?;
let mut line = String::new();
write!(reader.get_mut(), "{}\n", cmd).map_err(|e| OpenKacheError {
code: "CONNECTION_REFUSED".into(),
message: e.to_string(),
})?;
reader.get_mut().flush().ok();
reader.read_line(&mut line).map_err(|e| OpenKacheError {
code: "CONNECTION_REFUSED".into(),
message: e.to_string(),
})?;
Ok(line.trim().to_string())
}
pub fn get(&mut self, key: &str) -> Result<Option<String>, OpenKacheError> {
let resp = self.send(&format!("GET {}", key))?;
if resp == "NOT_FOUND" {
return Ok(None);
}
if let Some(val) = resp.strip_prefix("OK ") {
return Ok(Some(val.to_string()));
}
Err(OpenKacheError {
code: "PROTOCOL_ERROR".into(),
message: format!("Unexpected response: {}", resp),
})
}
pub fn set(&mut self, key: &str, value: &str) -> Result<(), OpenKacheError> {
let resp = self.send(&format!("SET {} {}", key, value))?;
if resp == "OK" {
return Ok(());
}
Err(OpenKacheError {
code: "PROTOCOL_ERROR".into(),
message: format!("Unexpected response: {}", resp),
})
}
pub fn delete(&mut self, key: &str) -> Result<bool, OpenKacheError> {
let resp = self.send(&format!("DEL {}", key))?;
match resp.as_str() {
"OK" => Ok(true),
"NOT_FOUND" => Ok(false),
_ => Err(OpenKacheError {
code: "PROTOCOL_ERROR".into(),
message: format!("Unexpected response: {}", resp),
}),
}
}
pub fn ping(&mut self) -> Result<bool, OpenKacheError> {
let resp = self.send("PING")?;
if resp == "PONG" {
return Ok(true);
}
Err(OpenKacheError {
code: "PROTOCOL_ERROR".into(),
message: format!("Unexpected response: {}", resp),
})
}
pub fn flush(&mut self) -> Result<(), OpenKacheError> {
let resp = self.send("FLUSH")?;
if resp == "OK" {
return Ok(());
}
Err(OpenKacheError {
code: "PROTOCOL_ERROR".into(),
message: format!("Unexpected response: {}", resp),
})
}
pub fn close(&mut self) {
if let Some(reader) = self.reader.take() {
let _ = reader.into_inner().shutdown(std::net::Shutdown::Both);
}
}
}
impl Drop for Client {
fn drop(&mut self) {
self.close();
}
}