Skip to content
1        10        20        30        40        50        60        70        80        901use std::{collections::HashMap, io, sync::Arc};23use tokio::{4    io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt},5    net::{TcpListener, TcpStream},6    sync::RwLock,7};89const MAX_LINE_LENGTH: usize = 64;10const MAX_BULK_LENGTH: usize = 1024 * 1024;11const MAX_ARGUMENTS: usize = 16;1213type Database = Arc<RwLock<HashMap<Vec<u8>, Vec<u8>>>>;1415/// Runs the TCP server until the listener fails or the process is shut down.16///17/// # Errors18///19/// Returns an error if accepting a TCP connection fails.20pub async fn run(listener: TcpListener) -> io::Result<()> {21    let database = Arc::new(RwLock::new(HashMap::new()));2223    loop {24        let (stream, _) = listener.accept().await?;25        let database = Arc::clone(&database);26        tokio::spawn(async move {27            if let Err(error) = serve_connection(stream, database).await {28                eprintln!("connection error: {error}");29            }30        });31    }32}3334async fn serve_connection(mut stream: TcpStream, database: Database) -> io::Result<()> {35    loop {36        let command = match read_command(&mut stream).await {37            Ok(Some(command)) => command,38            Ok(None) => return Ok(()),39            Err(error) => {40                stream.write_all(b"-ERR Protocol error\r\n").await?;41                return Err(error);42            }43        };4445        execute_command(&mut stream, &database, &command).await?;46    }47}4849async fn execute_command<W>(50    stream: &mut W,51    database: &Database,52    arguments: &[Vec<u8>],53) -> io::Result<()>54where55    W: AsyncWrite + Unpin,56{57    let Some(command) = arguments.first() else {58        return write_error(stream, "empty command").await;59    };6061    if command.eq_ignore_ascii_case(b"PING") {62        return match arguments {63            [_] => stream.write_all(b"+PONG\r\n").await,64            [_, message] => write_bulk(stream, Some(message)).await,65            _ => write_error(stream, "wrong number of arguments for 'ping' command").await,66        };67    }6869    if command.eq_ignore_ascii_case(b"GET") {70        let [_, key] = arguments else {71            return write_error(stream, "wrong number of arguments for 'get' command").await;72        };73        let value = database.read().await.get(key).cloned();74        return write_bulk(stream, value.as_deref()).await;75    }7677    if command.eq_ignore_ascii_case(b"SET") {78        let [_, key, value] = arguments else {79            return write_error(stream, "wrong number of arguments for 'set' command").await;80        };81        database.write().await.insert(key.clone(), value.clone());82        return stream.write_all(b"+OK\r\n").await;83    }8485    if command.eq_ignore_ascii_case(b"DEL") {86        let [_, key] = arguments else {87            return write_error(stream, "wrong number of arguments for 'del' command").await;88        };89        let removed = usize::from(database.write().await.remove(key).is_some());90        return stream.write_all(format!(":{removed}\r\n").as_bytes()).await;91    }9293    write_error(stream, "unknown command").await94}9596async fn write_error<W>(stream: &mut W, message: &str) -> io::Result<()>97where98    W: AsyncWrite + Unpin,99{100    stream101        .write_all(format!("-ERR {message}\r\n").as_bytes())102        .await103}104105async fn write_bulk<W>(stream: &mut W, value: Option<&[u8]>) -> io::Result<()>106where107    W: AsyncWrite + Unpin,108{109    let Some(value) = value else {110        return stream.write_all(b"$-1\r\n").await;111    };112113    stream114        .write_all(format!("${}\r\n", value.len()).as_bytes())115        .await?;116    stream.write_all(value).await?;117    stream.write_all(b"\r\n").await118}119120async fn read_command<R>(reader: &mut R) -> io::Result<Option<Vec<Vec<u8>>>>121where122    R: AsyncRead + Unpin,123{124    let mut marker = [0_u8; 1];125    if reader.read(&mut marker).await? == 0 {126        return Ok(None);127    }128    if marker[0] != b'*' {129        return Err(invalid_data("expected RESP array"));130    }131132    let argument_count = read_crlf_line(reader, MAX_LINE_LENGTH)133        .await?134        .parse::<usize>()135        .map_err(|_| invalid_data("invalid array length"))?;136    if argument_count == 0 || argument_count > MAX_ARGUMENTS {137        return Err(invalid_data("array length is out of range"));138    }139140    let mut arguments = Vec::with_capacity(argument_count);141    for _ in 0..argument_count {142        let mut marker = [0_u8; 1];143        reader.read_exact(&mut marker).await?;144        if marker[0] != b'$' {145            return Err(invalid_data("expected RESP bulk string"));146        }147148        let length = read_crlf_line(reader, MAX_LINE_LENGTH)149            .await?150            .parse::<usize>()151            .map_err(|_| invalid_data("invalid bulk string length"))?;152        if length > MAX_BULK_LENGTH {153            return Err(invalid_data("bulk string is too large"));154        }155156        let mut argument = vec![0; length];157        reader.read_exact(&mut argument).await?;158        let mut terminator = [0_u8; 2];159        reader.read_exact(&mut terminator).await?;160        if terminator != *b"\r\n" {161            return Err(invalid_data("bulk string is missing CRLF"));162        }163        arguments.push(argument);164    }165166    Ok(Some(arguments))167}168169async fn read_crlf_line<R>(reader: &mut R, maximum_length: usize) -> io::Result<String>170where171    R: AsyncRead + Unpin,172{173    let mut line = Vec::new();174    loop {175        let mut byte = [0_u8; 1];176        reader.read_exact(&mut byte).await?;177        match byte[0] {178            b'\n' if line.pop() == Some(b'\r') => {179                return String::from_utf8(line).map_err(|_| invalid_data("line is not ASCII"));180            }181            b'\n' => return Err(invalid_data("line is missing CRLF")),182            value => {183                line.push(value);184                if line.len() > maximum_length {185                    return Err(invalid_data("line is too long"));186                }187            }188        }189    }190}191192fn invalid_data(message: &str) -> io::Error {193    io::Error::new(io::ErrorKind::InvalidData, message)194}195196#[cfg(test)]197mod tests {198    use tokio::io::{AsyncReadExt, AsyncWriteExt, duplex};199200    use super::{read_command, run};201202    #[tokio::test]203    async fn parses_resp_arrays_and_binary_bulk_strings() {204        let (mut client, mut server) = duplex(128);205        client206            .write_all(b"*3\r\n$3\r\nSET\r\n$3\r\na\0b\r\n$2\r\n\xff\n\r\n")207            .await208            .unwrap();209210        let command = read_command(&mut server).await.unwrap().unwrap();211        assert_eq!(212            command,213            [b"SET".to_vec(), b"a\0b".to_vec(), b"\xff\n".to_vec()]214        );215    }216217    #[tokio::test]218    async fn rejects_malformed_resp_and_oversized_arguments() {219        for frame in [220            b"PING\r\n".as_slice(),221            b"*1\r\n$3\r\nGETxx".as_slice(),222            b"*1\r\n$1048577\r\n".as_slice(),223        ] {224            let (mut client, mut server) = duplex(128);225            client.write_all(frame).await.unwrap();226            assert!(read_command(&mut server).await.is_err());227        }228    }229230    #[tokio::test]231    async fn serves_commands_across_concurrent_connections() {232        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();233        let address = listener.local_addr().unwrap();234        let server = tokio::spawn(run(listener));235        let mut clients = Vec::new();236237        for index in 0..24_u8 {238            clients.push(tokio::spawn(async move {239                let mut stream = tokio::net::TcpStream::connect(address).await.unwrap();240                let key = format!("key-{index}");241                let value = format!("value-{index}");242                write_command(&mut stream, &[b"SET", key.as_bytes(), value.as_bytes()]).await;243                assert_eq!(read_response(&mut stream).await, b"+OK\r\n");244                write_command(&mut stream, &[b"GET", key.as_bytes()]).await;245                assert_eq!(read_response(&mut stream).await, bulk(value.as_bytes()));246                write_command(&mut stream, &[b"DEL", key.as_bytes()]).await;247                assert_eq!(read_response(&mut stream).await, b":1\r\n");248            }));249        }250251        for client in clients {252            client.await.unwrap();253        }254        server.abort();255    }256257    #[tokio::test]258    async fn handles_ping_missing_keys_and_command_errors() {259        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();260        let address = listener.local_addr().unwrap();261        let server = tokio::spawn(run(listener));262        let mut stream = tokio::net::TcpStream::connect(address).await.unwrap();263264        write_command(&mut stream, &[b"PING"]).await;265        assert_eq!(read_response(&mut stream).await, b"+PONG\r\n");266        write_command(&mut stream, &[b"PING", b"hello"]).await;267        assert_eq!(read_response(&mut stream).await, b"$5\r\nhello\r\n");268        write_command(&mut stream, &[b"GET", b"missing"]).await;269        assert_eq!(read_response(&mut stream).await, b"$-1\r\n");270        write_command(&mut stream, &[b"NOPE"]).await;271        assert_eq!(272            read_response(&mut stream).await,273            b"-ERR unknown command\r\n"274        );275        server.abort();276    }277278    async fn write_command(stream: &mut tokio::net::TcpStream, arguments: &[&[u8]]) {279        let mut frame = format!("*{}\r\n", arguments.len()).into_bytes();280        for argument in arguments {281            frame.extend_from_slice(format!("${}\r\n", argument.len()).as_bytes());282            frame.extend_from_slice(argument);283            frame.extend_from_slice(b"\r\n");284        }285        stream.write_all(&frame).await.unwrap();286    }287288    async fn read_response(stream: &mut tokio::net::TcpStream) -> Vec<u8> {289        let mut line = Vec::new();290        loop {291            let mut byte = [0_u8; 1];292            stream.read_exact(&mut byte).await.unwrap();293            line.push(byte[0]);294            if line.ends_with(b"\r\n") {295                break;296            }297        }298        if line.first() == Some(&b'$') {299            let length = std::str::from_utf8(&line[1..line.len() - 2])300                .unwrap()301                .parse::<isize>()302                .unwrap();303            if length >= 0 {304                let mut value = vec![0; usize::try_from(length).unwrap() + 2];305                stream.read_exact(&mut value).await.unwrap();306                line.extend(value);307            }308        }309        line310    }311312    fn bulk(value: &[u8]) -> Vec<u8> {313        let mut response = format!("${}\r\n", value.len()).into_bytes();314        response.extend_from_slice(value);315        response.extend_from_slice(b"\r\n");316        response317    }318}