openkache 0.0.2

OpenKache client — 10x cheaper and faster than Redis
Documentation
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();
    }
}