LINE1 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>>>>;14151617181920pub 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}