Build Your Own Redis - From Scratch

1. Install Go from go.dev/dl. Check it with go version.
2. Make the folder: mkdir -p teaching/code/from-scratch/redis. Save each of the 7 files below at the path shown above it, including any subfolders.
3. Inside that folder, run go mod init lesson once. Go needs a module name to build.
4. Run the commands in the block above from the folder where you ran mkdir.

package main

// v01 — the socket that answers.
//
// Goal: prove a client can connect and get an answer. No protocol yet.
//
//   Run:   go run ./01-socket
//   Poke:  nc localhost 6379   -> type PING, enter -> +PONG
//   Wall:  redis-cli -p 6379 ping   -> (error) ERR, because redis-cli sends
//          *1\r\n$4\r\nPING\r\n  (RESP), not the raw bytes "PING". -> v02.
//
// Go notes: net.Listen opens the socket; err is a value, not an exception.
// `defer conn.Close()` runs on return — Go's cleanup idiom.

import (
	"bufio"
	"fmt"
	"net"
	"strings"
)

func main() {
	ln, err := net.Listen("tcp", "127.0.0.1:6379")
	if err != nil {
		panic(err)
	}
	fmt.Println("listening on :6379  (Ctrl-C to stop)")
	for {
		conn, err := ln.Accept() // blocks until a client knocks
		if err != nil {
			continue
		}
		handle(conn) // v01: ONE client at a time, on purpose (see v04)
	}
}

func handle(conn net.Conn) {
	defer conn.Close()
	r := bufio.NewReader(conn)
	for {
		line, err := r.ReadString('\n') // we PRETEND one line == one command
		if err != nil {
			return
		}
		if strings.ToUpper(strings.TrimSpace(line)) == "PING" {
			conn.Write([]byte("+PONG\r\n"))
		} else {
			conn.Write([]byte("-ERR unknown command\r\n"))
		}
	}
}

package main

// v02 — RESP, the wire protocol. Now redis-cli itself can talk to us.
//
// A client command is ALWAYS an array of bulk strings:
//   *2\r\n $4\r\nECHO\r\n $5\r\nhello\r\n   ==   ["ECHO", "hello"]
// The first byte names the type:  * array   $ bulk string.
// Replies:  + simple   - error   : integer   $ bulk   $-1 nil.
//
//   Run:   go run ./02-resp
//   Now:   redis-cli -p 6379 ping        -> PONG
//          redis-cli -p 6379 echo hello  -> "hello"
//
// The point: length prefixes solve framing. `$4` says "the next 4 bytes are
// the value" — no guessing where a command ends. That's why RESP beats a
// line protocol.

import (
	"bufio"
	"fmt"
	"net"
	"strconv"
	"strings"
)

func main() {
	ln, _ := net.Listen("tcp", "127.0.0.1:6379")
	fmt.Println("listening on :6379")
	for {
		conn, err := ln.Accept()
		if err != nil {
			continue
		}
		handle(conn)
	}
}

func handle(conn net.Conn) {
	defer conn.Close()
	r := bufio.NewReader(conn)
	for {
		args, err := readCommand(r) // <- framing lives here now
		if err != nil {
			return
		}
		if len(args) == 0 {
			continue
		}
		switch strings.ToUpper(args[0]) {
		case "PING":
			conn.Write([]byte("+PONG\r\n"))
		case "ECHO":
			writeBulk(conn, args[1])
		default:
			conn.Write([]byte("-ERR unknown command '" + args[0] + "'\r\n"))
		}
	}
}

// readCommand parses one request:  *N\r\n  then N bulk strings.
func readCommand(r *bufio.Reader) ([]string, error) {
	line, err := r.ReadString('\n')
	if err != nil {
		return nil, err
	}
	line = strings.TrimRight(line, "\r\n")
	if len(line) == 0 || line[0] != '*' {
		return nil, fmt.Errorf("expected array, got %q", line)
	}
	n, _ := strconv.Atoi(line[1:])
	args := make([]string, n)
	for i := 0; i < n; i++ {
		hdr, err := r.ReadString('\n') // $<len>
		if err != nil {
			return nil, err
		}
		hdr = strings.TrimRight(hdr, "\r\n")
		length, _ := strconv.Atoi(hdr[1:])
		buf := make([]byte, length+2) // value + trailing \r\n
		if _, err := readFull(r, buf); err != nil {
			return nil, err
		}
		args[i] = string(buf[:length])
	}
	return args, nil
}

func readFull(r *bufio.Reader, buf []byte) (int, error) {
	got := 0
	for got < len(buf) {
		n, err := r.Read(buf[got:])
		got += n
		if err != nil {
			return got, err
		}
	}
	return got, nil
}

func writeBulk(conn net.Conn, s string) {
	fmt.Fprintf(conn, "$%d\r\n%s\r\n", len(s), s)
}

package main

// v03 — the map. SET / GET / DEL. Now it's a real key-value server.
//
//   Run:   go run ./03-store
//          redis-cli -p 6379 set name garv   -> OK
//          redis-cli -p 6379 get name        -> "garv"
//          redis-cli -p 6379 del name        -> (integer) 1
//
// The store IS just a Go map. That's the whole "database". Everything hard
// about Redis is what surrounds this map, not the map itself.
//
// Note: NO lock here — v03 still serves one connection at a time (handle is
// called synchronously). The moment we add `go handle(conn)` in v04, this
// map becomes a data race and needs a mutex. Hold that thought.

import (
	"bufio"
	"fmt"
	"net"
	"strconv"
	"strings"
)

var store = map[string]string{} // <- the entire database

func main() {
	ln, _ := net.Listen("tcp", "127.0.0.1:6379")
	fmt.Println("listening on :6379")
	for {
		conn, err := ln.Accept()
		if err != nil {
			continue
		}
		handle(conn)
	}
}

func handle(conn net.Conn) {
	defer conn.Close()
	r := bufio.NewReader(conn)
	for {
		args, err := readCommand(r)
		if err != nil {
			return
		}
		if len(args) == 0 {
			continue
		}
		switch strings.ToUpper(args[0]) {
		case "PING":
			conn.Write([]byte("+PONG\r\n"))
		case "ECHO":
			writeBulk(conn, args[1])
		case "SET":
			store[args[1]] = args[2]
			conn.Write([]byte("+OK\r\n"))
		case "GET":
			if v, ok := store[args[1]]; ok {
				writeBulk(conn, v)
			} else {
				conn.Write([]byte("$-1\r\n")) // nil
			}
		case "DEL":
			n := 0
			for _, k := range args[1:] {
				if _, ok := store[k]; ok {
					delete(store, k)
					n++
				}
			}
			fmt.Fprintf(conn, ":%d\r\n", n)
		default:
			conn.Write([]byte("-ERR unknown command '" + args[0] + "'\r\n"))
		}
	}
}

func readCommand(r *bufio.Reader) ([]string, error) {
	line, err := r.ReadString('\n')
	if err != nil {
		return nil, err
	}
	line = strings.TrimRight(line, "\r\n")
	if len(line) == 0 || line[0] != '*' {
		return nil, fmt.Errorf("bad array %q", line)
	}
	n, _ := strconv.Atoi(line[1:])
	args := make([]string, n)
	for i := 0; i < n; i++ {
		hdr, err := r.ReadString('\n')
		if err != nil {
			return nil, err
		}
		length, _ := strconv.Atoi(strings.TrimRight(hdr, "\r\n")[1:])
		buf := make([]byte, length+2)
		if _, err := readFull(r, buf); err != nil {
			return nil, err
		}
		args[i] = string(buf[:length])
	}
	return args, nil
}

func readFull(r *bufio.Reader, buf []byte) (int, error) {
	got := 0
	for got < len(buf) {
		n, err := r.Read(buf[got:])
		got += n
		if err != nil {
			return got, err
		}
	}
	return got, nil
}

func writeBulk(conn net.Conn, s string) { fmt.Fprintf(conn, "$%d\r\n%s\r\n", len(s), s) }

package main

// v04 — one thread, many clients.
//
// v03 served ONE client at a time: while Alice's connection is open, Bob
// waits. Add one word — `go handle(conn)` — and every client runs at once.
//
// But now two goroutines touch `store` at the same time => a data race
// (run with `go run -race ./04-eventloop` and watch it scream). We add a
// sync.RWMutex: many readers OR one writer.
//
// THE REVEAL: goroutines are NOT one-OS-thread-each. Go's runtime multiplexes
// thousands of goroutines onto a handful of OS threads using an epoll/kqueue
// "netpoller" — the exact reactor pattern real Redis writes BY HAND in C.
//   - Real Redis: single thread + explicit epoll, so NO lock is ever needed.
//   - Our Go:     many goroutines + hidden epoll, so we PAY with a mutex.
// Same machine underneath; two philosophies about who holds the lock.
//
//   Run:   go run ./04-eventloop      (open several redis-cli at once)
//   Race:  go run -race ./04-eventloop

import (
	"bufio"
	"fmt"
	"net"
	"strconv"
	"strings"
	"sync"
)

var (
	mu    sync.RWMutex
	store = map[string]string{}
)

func main() {
	ln, _ := net.Listen("tcp", "127.0.0.1:6379")
	fmt.Println("listening on :6379  (concurrent)")
	for {
		conn, err := ln.Accept()
		if err != nil {
			continue
		}
		go handle(conn) // <- the one word that changes everything
	}
}

func handle(conn net.Conn) {
	defer conn.Close()
	r := bufio.NewReader(conn)
	for {
		args, err := readCommand(r)
		if err != nil {
			return
		}
		if len(args) == 0 {
			continue
		}
		switch strings.ToUpper(args[0]) {
		case "PING":
			conn.Write([]byte("+PONG\r\n"))
		case "SET":
			mu.Lock() // one writer
			store[args[1]] = args[2]
			mu.Unlock()
			conn.Write([]byte("+OK\r\n"))
		case "GET":
			mu.RLock() // many readers
			v, ok := store[args[1]]
			mu.RUnlock()
			if ok {
				writeBulk(conn, v)
			} else {
				conn.Write([]byte("$-1\r\n"))
			}
		case "DEL":
			mu.Lock()
			n := 0
			for _, k := range args[1:] {
				if _, ok := store[k]; ok {
					delete(store, k)
					n++
				}
			}
			mu.Unlock()
			fmt.Fprintf(conn, ":%d\r\n", n)
		default:
			conn.Write([]byte("-ERR unknown command '" + args[0] + "'\r\n"))
		}
	}
}

func readCommand(r *bufio.Reader) ([]string, error) {
	line, err := r.ReadString('\n')
	if err != nil {
		return nil, err
	}
	line = strings.TrimRight(line, "\r\n")
	if len(line) == 0 || line[0] != '*' {
		return nil, fmt.Errorf("bad array %q", line)
	}
	n, _ := strconv.Atoi(line[1:])
	args := make([]string, n)
	for i := 0; i < n; i++ {
		hdr, err := r.ReadString('\n')
		if err != nil {
			return nil, err
		}
		length, _ := strconv.Atoi(strings.TrimRight(hdr, "\r\n")[1:])
		buf := make([]byte, length+2)
		if _, err := readFull(r, buf); err != nil {
			return nil, err
		}
		args[i] = string(buf[:length])
	}
	return args, nil
}

func readFull(r *bufio.Reader, buf []byte) (int, error) {
	got := 0
	for got < len(buf) {
		n, err := r.Read(buf[got:])
		got += n
		if err != nil {
			return got, err
		}
	}
	return got, nil
}

func writeBulk(conn net.Conn, s string) { fmt.Fprintf(conn, "$%d\r\n%s\r\n", len(s), s) }

package main

// v05 — keys that die. TTL, and two ways to reap expired keys.
//
//   Run:   go run ./05-expiry
//          redis-cli -p 6379 set session abc EX 5
//          redis-cli -p 6379 ttl session      -> (integer) 5, 4, 3...
//          (wait 5s)  redis-cli -p 6379 get session   -> (nil)
//
// Two reapers, exactly like real Redis:
//   LAZY   — on GET, if the key is past its expiry, delete it then. Cheap,
//            but a key nobody reads never gets cleaned up (memory leak).
//   ACTIVE — a background loop every 100ms samples ~20 keys that HAVE a TTL,
//            deletes the dead ones. If >25% were dead, it loops again right
//            away (the set is "hot" with expiries). Probabilistic, not a scan.
//
// Why sampling and not "check every key every second"? A million keys * 10/s
// = 10M checks/s of mostly-alive keys. Sampling keeps expiry ~O(dead keys),
// not O(all keys). You trade a little staleness for a huge CPU win.

import (
	"bufio"
	"fmt"
	"net"
	"strconv"
	"strings"
	"sync"
	"time"
)

type entry struct {
	val      string
	expireAt time.Time // zero value = never expires
}

var (
	mu    sync.RWMutex
	store = map[string]entry{}
)

func main() {
	ln, _ := net.Listen("tcp", "127.0.0.1:6379")
	fmt.Println("listening on :6379  (with expiry)")
	go activeExpiryLoop() // the background reaper
	for {
		conn, err := ln.Accept()
		if err != nil {
			continue
		}
		go handle(conn)
	}
}

// getLive is the LAZY reaper: expired-on-read keys die here.
func getLive(key string) (string, bool) {
	mu.RLock()
	e, ok := store[key]
	mu.RUnlock()
	if !ok {
		return "", false
	}
	if !e.expireAt.IsZero() && time.Now().After(e.expireAt) {
		mu.Lock()
		delete(store, key)
		mu.Unlock()
		return "", false
	}
	return e.val, true
}

// activeExpiryLoop is Redis's adaptive sampler.
func activeExpiryLoop() {
	for {
		time.Sleep(100 * time.Millisecond)
		for {
			dead := sweepSample(20)
			if dead < 5 { // <25% of 20 -> this batch is mostly alive, rest
				break
			}
		}
	}
}

func sweepSample(n int) int {
	mu.Lock()
	defer mu.Unlock()
	now := time.Now()
	checked, dead := 0, 0
	for k, e := range store { // Go randomizes map order -> a free random sample
		if checked >= n {
			break
		}
		if e.expireAt.IsZero() {
			continue // only sample keys that HAVE a TTL
		}
		checked++
		if now.After(e.expireAt) {
			delete(store, k)
			dead++
		}
	}
	return dead
}

func handle(conn net.Conn) {
	defer conn.Close()
	r := bufio.NewReader(conn)
	for {
		args, err := readCommand(r)
		if err != nil {
			return
		}
		if len(args) == 0 {
			continue
		}
		switch strings.ToUpper(args[0]) {
		case "PING":
			conn.Write([]byte("+PONG\r\n"))
		case "SET":
			e := entry{val: args[2]}
			if len(args) >= 5 { // SET key val EX secs | PX ms
				n, _ := strconv.Atoi(args[4])
				switch strings.ToUpper(args[3]) {
				case "EX":
					e.expireAt = time.Now().Add(time.Duration(n) * time.Second)
				case "PX":
					e.expireAt = time.Now().Add(time.Duration(n) * time.Millisecond)
				}
			}
			mu.Lock()
			store[args[1]] = e
			mu.Unlock()
			conn.Write([]byte("+OK\r\n"))
		case "GET":
			if v, ok := getLive(args[1]); ok {
				writeBulk(conn, v)
			} else {
				conn.Write([]byte("$-1\r\n"))
			}
		case "TTL":
			mu.RLock()
			e, ok := store[args[1]]
			mu.RUnlock()
			switch {
			case !ok:
				conn.Write([]byte(":-2\r\n")) // no such key
			case e.expireAt.IsZero():
				conn.Write([]byte(":-1\r\n")) // exists, no TTL
			default:
				fmt.Fprintf(conn, ":%d\r\n", int(time.Until(e.expireAt).Seconds()))
			}
		default:
			conn.Write([]byte("-ERR unknown command '" + args[0] + "'\r\n"))
		}
	}
}

func readCommand(r *bufio.Reader) ([]string, error) {
	line, err := r.ReadString('\n')
	if err != nil {
		return nil, err
	}
	line = strings.TrimRight(line, "\r\n")
	if len(line) == 0 || line[0] != '*' {
		return nil, fmt.Errorf("bad array %q", line)
	}
	n, _ := strconv.Atoi(line[1:])
	args := make([]string, n)
	for i := 0; i < n; i++ {
		hdr, err := r.ReadString('\n')
		if err != nil {
			return nil, err
		}
		length, _ := strconv.Atoi(strings.TrimRight(hdr, "\r\n")[1:])
		buf := make([]byte, length+2)
		if _, err := readFull(r, buf); err != nil {
			return nil, err
		}
		args[i] = string(buf[:length])
	}
	return args, nil
}

func readFull(r *bufio.Reader, buf []byte) (int, error) {
	got := 0
	for got < len(buf) {
		n, err := r.Read(buf[got:])
		got += n
		if err != nil {
			return got, err
		}
	}
	return got, nil
}

func writeBulk(conn net.Conn, s string) { fmt.Fprintf(conn, "$%d\r\n%s\r\n", len(s), s) }

package main

// v06 — eviction. Memory is finite; when it fills, WHICH key dies?
//
//   Run:   go run ./06-eviction
//          for i in $(seq 1 20); do redis-cli -p 6379 set k$i v$i; done
//          redis-cli -p 6379 dbsize   -> stays capped at maxKeys
//
// Real Redis caps BYTES (maxmemory). Here we cap KEY COUNT (maxKeys) to keep
// the idea visible — same algorithm, simpler yardstick.
// ponytail: key-count cap stands in for maxmemory; swap in a byte counter if
// you want true faithfulness.
//
// THE TRICK: real Redis does NOT keep a perfectly-ordered LRU list (that costs
// a pointer-shuffle on every access). It APPROXIMATES: sample K random keys,
// evict the least-recently-used of the sample. K=5 gets you within a few % of
// true LRU for ~free. Each entry carries a logical "access clock" instead of a
// real timestamp (real Redis uses a 24-bit clock in the object header).

import (
	"bufio"
	"fmt"
	"net"
	"strconv"
	"strings"
	"sync"
)

type entry struct {
	val       string
	lastClock uint64 // logical access time; bigger = more recent
}

var (
	mu      sync.Mutex
	store   = map[string]entry{}
	clock   uint64
	maxKeys = 8 // small so you can SEE eviction happen
)

const sampleK = 5

func main() {
	ln, _ := net.Listen("tcp", "127.0.0.1:6379")
	fmt.Printf("listening on :6379  (maxKeys=%d, allkeys-lru by sampling)\n", maxKeys)
	for {
		conn, err := ln.Accept()
		if err != nil {
			continue
		}
		go handle(conn)
	}
}

func touch(e entry) entry { // stamp an access
	clock++
	e.lastClock = clock
	return e
}

// evictOne: sample K keys, drop the least-recently-used. This IS approximated LRU.
func evictOne() {
	var victim string
	var oldest uint64 = ^uint64(0)
	n := 0
	for k, e := range store { // random map order = our random sample
		if e.lastClock < oldest {
			oldest, victim = e.lastClock, k
		}
		n++
		if n >= sampleK {
			break
		}
	}
	if victim != "" {
		delete(store, victim)
		fmt.Println("evicted (LRU):", victim)
	}
}

func handle(conn net.Conn) {
	defer conn.Close()
	r := bufio.NewReader(conn)
	for {
		args, err := readCommand(r)
		if err != nil {
			return
		}
		if len(args) == 0 {
			continue
		}
		switch strings.ToUpper(args[0]) {
		case "PING":
			conn.Write([]byte("+PONG\r\n"))
		case "SET":
			mu.Lock()
			if _, exists := store[args[1]]; !exists {
				for len(store) >= maxKeys { // make room BEFORE inserting
					evictOne()
				}
			}
			store[args[1]] = touch(entry{val: args[2]})
			mu.Unlock()
			conn.Write([]byte("+OK\r\n"))
		case "GET":
			mu.Lock()
			e, ok := store[args[1]]
			if ok {
				store[args[1]] = touch(e) // a read counts as recent use
			}
			mu.Unlock()
			if ok {
				writeBulk(conn, e.val)
			} else {
				conn.Write([]byte("$-1\r\n"))
			}
		case "DBSIZE":
			mu.Lock()
			n := len(store)
			mu.Unlock()
			fmt.Fprintf(conn, ":%d\r\n", n)
		default:
			conn.Write([]byte("-ERR unknown command '" + args[0] + "'\r\n"))
		}
	}
}

func readCommand(r *bufio.Reader) ([]string, error) {
	line, err := r.ReadString('\n')
	if err != nil {
		return nil, err
	}
	line = strings.TrimRight(line, "\r\n")
	if len(line) == 0 || line[0] != '*' {
		return nil, fmt.Errorf("bad array %q", line)
	}
	n, _ := strconv.Atoi(line[1:])
	args := make([]string, n)
	for i := 0; i < n; i++ {
		hdr, err := r.ReadString('\n')
		if err != nil {
			return nil, err
		}
		length, _ := strconv.Atoi(strings.TrimRight(hdr, "\r\n")[1:])
		buf := make([]byte, length+2)
		if _, err := readFull(r, buf); err != nil {
			return nil, err
		}
		args[i] = string(buf[:length])
	}
	return args, nil
}

func readFull(r *bufio.Reader, buf []byte) (int, error) {
	got := 0
	for got < len(buf) {
		n, err := r.Read(buf[got:])
		got += n
		if err != nil {
			return got, err
		}
	}
	return got, nil
}

func writeBulk(conn net.Conn, s string) { fmt.Fprintf(conn, "$%d\r\n%s\r\n", len(s), s) }

package main

// v07 — surviving a crash. RAM is gone the instant the power blinks.
//
//   Run:   go run ./07-persistence
//          redis-cli -p 6379 set name garv
//          redis-cli -p 6379 save          -> writes dump.rdb
//          Ctrl-C, then run again           -> "name" is still there.
//
// TWO durability strategies, exactly like real Redis:
//   AOF (Append-Only File): log EVERY write command to disk as it happens.
//       Recovery = replay the log. Durable to the last fsync, but the file
//       grows forever (until a rewrite compacts it). Slower writes.
//   RDB (snapshot): dump the whole dataset to one file, point-in-time.
//       Real Redis fork()s a child and copy-on-write lets the parent keep
//       serving while the child writes the snapshot. Fast, compact, but you
//       lose everything since the last snapshot.
//
// The fork+COW trick is the clever bit: the child sees a frozen copy of memory
// for free (the OS only copies a page when the parent writes it), so a snapshot
// of a 10GB dataset costs almost no extra RAM and never blocks reads.
//
// Boot order (real Redis too): load RDB first (the baseline), THEN replay the
// AOF (the writes since that snapshot). Here we do both.

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"strconv"
	"strings"
	"sync"
)

var (
	mu    sync.Mutex
	store = map[string]string{}
	aof   *os.File
)

const rdbPath = "dump.rdb"
const aofPath = "appendonly.aof"

func main() {
	loadRDB()   // baseline snapshot
	replayAOF() // writes since the snapshot
	var err error
	aof, err = os.OpenFile(aofPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
	if err != nil {
		panic(err)
	}
	ln, _ := net.Listen("tcp", "127.0.0.1:6379")
	fmt.Printf("listening on :6379  (loaded %d keys)\n", len(store))
	for {
		conn, err := ln.Accept()
		if err != nil {
			continue
		}
		go handle(conn)
	}
}

// appendAOF logs a write command in RESP so replay reuses the same parser.
func appendAOF(args []string) {
	fmt.Fprintf(aof, "*%d\r\n", len(args))
	for _, a := range args {
		fmt.Fprintf(aof, "$%d\r\n%s\r\n", len(a), a)
	}
	aof.Sync() // fsync policy "always" — durable, slowest. everysec = looser.
}

func replayAOF() {
	f, err := os.Open(aofPath)
	if err != nil {
		return // no AOF yet
	}
	defer f.Close()
	r := bufio.NewReader(f)
	for {
		args, err := readCommand(r)
		if err != nil {
			break
		}
		apply(args) // rebuild state, but do NOT re-log it
	}
}

// apply mutates the store. Caller decides whether to also log/persist.
func apply(args []string) {
	switch strings.ToUpper(args[0]) {
	case "SET":
		store[args[1]] = args[2]
	case "DEL":
		for _, k := range args[1:] {
			delete(store, k)
		}
	}
}

func saveRDB() error {
	tmp := rdbPath + ".tmp"
	f, err := os.Create(tmp)
	if err != nil {
		return err
	}
	w := bufio.NewWriter(f)
	mu.Lock()
	for k, v := range store { // length-prefixed so values can hold anything
		fmt.Fprintf(w, "%d,%d,%s%s", len(k), len(v), k, v)
	}
	mu.Unlock()
	w.Flush()
	f.Close()
	return os.Rename(tmp, rdbPath) // atomic swap: a crash never leaves a torn file
}

func loadRDB() {
	data, err := os.ReadFile(rdbPath)
	if err != nil {
		return
	}
	s := string(data)
	for len(s) > 0 {
		c1 := strings.IndexByte(s, ',')
		c2 := strings.IndexByte(s[c1+1:], ',') + c1 + 1
		klen, _ := strconv.Atoi(s[:c1])
		vlen, _ := strconv.Atoi(s[c1+1 : c2])
		body := s[c2+1:]
		store[body[:klen]] = body[klen : klen+vlen]
		s = body[klen+vlen:]
	}
}

func handle(conn net.Conn) {
	defer conn.Close()
	r := bufio.NewReader(conn)
	for {
		args, err := readCommand(r)
		if err != nil {
			return
		}
		if len(args) == 0 {
			continue
		}
		switch strings.ToUpper(args[0]) {
		case "PING":
			conn.Write([]byte("+PONG\r\n"))
		case "SET":
			mu.Lock()
			store[args[1]] = args[2]
			mu.Unlock()
			appendAOF(args) // durability: log before we ack
			conn.Write([]byte("+OK\r\n"))
		case "GET":
			mu.Lock()
			v, ok := store[args[1]]
			mu.Unlock()
			if ok {
				writeBulk(conn, v)
			} else {
				conn.Write([]byte("$-1\r\n"))
			}
		case "DEL":
			mu.Lock()
			n := 0
			for _, k := range args[1:] {
				if _, ok := store[k]; ok {
					delete(store, k)
					n++
				}
			}
			mu.Unlock()
			appendAOF(args)
			fmt.Fprintf(conn, ":%d\r\n", n)
		case "SAVE":
			if err := saveRDB(); err != nil {
				conn.Write([]byte("-ERR save failed\r\n"))
			} else {
				conn.Write([]byte("+OK\r\n"))
			}
		default:
			conn.Write([]byte("-ERR unknown command '" + args[0] + "'\r\n"))
		}
	}
}

func readCommand(r *bufio.Reader) ([]string, error) {
	line, err := r.ReadString('\n')
	if err != nil {
		return nil, err
	}
	line = strings.TrimRight(line, "\r\n")
	if len(line) == 0 || line[0] != '*' {
		return nil, fmt.Errorf("bad array %q", line)
	}
	n, _ := strconv.Atoi(line[1:])
	args := make([]string, n)
	for i := 0; i < n; i++ {
		hdr, err := r.ReadString('\n')
		if err != nil {
			return nil, err
		}
		length, _ := strconv.Atoi(strings.TrimRight(hdr, "\r\n")[1:])
		buf := make([]byte, length+2)
		if _, err := readFull(r, buf); err != nil {
			return nil, err
		}
		args[i] = string(buf[:length])
	}
	return args, nil
}

func readFull(r *bufio.Reader, buf []byte) (int, error) {
	got := 0
	for got < len(buf) {
		n, err := r.Read(buf[got:])
		got += n
		if err != nil {
			return got, err
		}
	}
	return got, nil
}

func writeBulk(conn net.Conn, s string) { fmt.Fprintf(conn, "$%d\r\n%s\r\n", len(s), s) }