In-Memory DB 구현 9편 - 데이터 영속화하기

buf := make([]byte, 4)
binary.BigEndian.PutUint32(buf, 12345)
// buf = [0x00, 0x00, 0x30, 0x39]

[1 byte]  Type           0x00=String, 0x01=List
[4 bytes] KeyLength      uint32, Big Endian
[N bytes] KeyData        UTF-8 문자열

--- String인 경우 ---
[4 bytes] ValueLength    uint32, Big Endian
[N bytes] ValueData      UTF-8 문자열

--- List인 경우 ---
[4 bytes] ElementCount   uint32, Big Endian
  반복:
    [4 bytes] ElemLength   uint32, Big Endian
    [N bytes] ElemData     UTF-8 문자열

--- TTL ---
[1 byte]  HasExpiry      0x00=없음, 0x01=있음
(0x01인 경우)
  [8 bytes] ExpireAt     int64, Big Endian, Unix 밀리초

package persistence

var MagicBytes = [6]byte{'M', 'I', 'N', 'I', 'D', 'B'}

const (
	Version byte = 0x01

	TypeString byte = 0x00
	TypeList   byte = 0x01

	NoExpiry  byte = 0x00
	HasExpiry byte = 0x01

	EOF byte = 0xFF
)

package persistence

import (
	"bufio"
	"encoding/binary"
	"io"
	"time"
)

type Encoder struct {
	w *bufio.Writer
}

func NewEncoder(w io.Writer) *Encoder {
	return &Encoder{bufio.NewWriter(w)}
}

// 파일 헤더를 쓴다. Magic bytes "MINIDB" + Version 0x01 = 총 7바이트.
func (e *Encoder) WriteHeader() error {
	e.w.Write(MagicBytes[:])
	_, err := e.w.Write([]byte{Version})
	return err
}

// String 타입 엔트리를 쓴다.
// [Type 0x00] [Key] [Value] [TTL]
func (e *Encoder) WriteStringEntry(key, value string, expireAt *time.Time) error {
	if err := e.writeBytes([]byte{TypeString}); err != nil {
		return err
	}
	if err := e.writeString(key); err != nil {
		return err
	}
	if err := e.writeString(value); err != nil {
		return err
	}
	return e.writeExpiry(expireAt)
}

// List 타입 엔트리를 쓴다.
// [Type 0x01] [Key] [ElementCount] [Element1] [Element2] ... [TTL]
func (e *Encoder) WriteListEntry(key string, values []string, expireAt *time.Time) error {
	if err := e.writeBytes([]byte{TypeList}); err != nil {
		return err
	}
	if err := e.writeString(key); err != nil {
		return err
	}
	if err := e.writeUint32(uint32(len(values))); err != nil {
		return err
	}
	for _, v := range values {
		if err := e.writeString(v); err != nil {
			return err
		}
	}
	return e.writeExpiry(expireAt)
}

// EOF 마커를 쓴다. 파일의 끝을 명시적으로 표시
func (e *Encoder) WriteEOF() error {
	return e.writeBytes([]byte{EOF})
}

// 버퍼에 남아있는 데이터를 실제 Writer에 내보낸다.
// 이걸 호출하지 않으면 마지막 데이터가 파일에 기록되지 않는다
func (e *Encoder) Flush() error {
	return e.w.Flush()
}

func (e *Encoder) writeBytes(data []byte) error {
	_, err := e.w.Write(data)
	return err
}

// uint32 값을 Big Endian 4바이트로 변환해서 쓴다.
func (e *Encoder) writeUint32(n uint32) error {
	buf := make([]byte, 4)
	binary.BigEndian.PutUint32(buf, n)
	return e.writeBytes(buf)
}

// int64 값을 Big Endian 8바이트로 변환해서 쓴다.
func (e *Encoder) writeInt64(n int64) error {
	buf := make([]byte, 8)
	binary.BigEndian.PutUint64(buf, uint64(n))
	return e.writeBytes(buf)
}

// Length-Prefixed 문자열을 쓴다.
// [4바이트 길이] + [문자열 바이트] 형태
func (e *Encoder) writeString(s string) error {
	if err := e.writeUint32(uint32(len(s))); err != nil {
		return err
	}
	return e.writeBytes([]byte(s))
}

// TTL 정보를 쓴다
// expireAt이 nil이면 0x00 한 바이트만 쓴다 (만료 없음)
// nil이 아니면 0x01 + 8바이트 Unix 밀리초를 쓴다.
func (e *Encoder) writeExpiry(expireAt *time.Time) error {
	if expireAt == nil {
		return e.writeBytes([]byte{NoExpiry})
	}
	if err := e.writeBytes([]byte{HasExpiry}); err != nil {
		return err
	}
	return e.writeInt64(expireAt.UnixMilli())
}

func (s *Store) Save(path string) error {
	s.mu.RLock()
	defer s.mu.RUnlock()

	file, err := os.Create(path)
	if err != nil {
		return err
	}
	defer file.Close()

	encoder := persistence.NewEncoder(file)
	encoder.WriteHeader()

	for key, entry := range s.data {
		// 이미 만료된 키는 저장할 필요 없으니 건너뛴다.
		// isExpired()는 삭제(쓰기)를 하기 때문에 RLock 상태에서 호출 불가
		// 읽기 전용으로 만료 여부만 확인한다.
		if entry.ExpireAt != nil && entry.ExpireAt.Before(time.Now()) {
			continue
		}

		switch entry.Type {
		case TypeString:
			encoder.WriteStringEntry(key, entry.Str, entry.ExpireAt)

		case TypeList:
			values := entry.List.Range(0, entry.List.Length-1)
			encoder.WriteListEntry(key, values, entry.ExpireAt)

		}
	}

	encoder.WriteEOF()
	return encoder.Flush()
}

case "SAVE":
    err := s.store.Save("dump.rdb")
    if err != nil {
        writer.WriteError(err.Error())
    } else {
        writer.WriteSimpleString("OK")
    }

00000000: 4d49 4e49 4442 0101 0000 0004 666f 6f64  MINIDB......food
00000010: 0000 0001 0000 0005 7069 7a7a 6100 ff    ........pizza..

4d 49 4e 49 44 42    <- "MINIDB" Magic Bytes
01                   <- Version 0x01

01                   <- TypeList (0x01)
00 00 00 04          <- Key 길이 = 4
66 6f 6f 64          <- "food"
00 00 00 01          <- Element Count = 1
00 00 00 05          <- Element 길이 = 5
70 69 7a 7a 61       <- "pizza"
00                   <- NoExpiry (TTL 없음)

ff                   <- EOF

func TestWriteStringEntry(t *testing.T) {
	// given
	var buf bytes.Buffer
	enc := NewEncoder(&buf)

	// when: key="hi", value="go", TTL 없음
	err := enc.WriteStringEntry("hi", "go", nil)
	enc.Flush()

	// then
	if err != nil {
		t.Fatalf("에러 발생: %v", err)
	}
	data := buf.Bytes()

	// 총 길이: Type(1) + KeyLen(4) + Key(2) + ValLen(4) + Val(2) + NoExpiry(1) = 14
	if len(data) != 14 {
		t.Fatalf("총 길이: %d, expected: 14", len(data))
	}

	// Type: 0x00
	if data[0] != TypeString {
		t.Fatalf("Type: 0x%02x, expected: 0x00", data[0])
	}

	// Key length: 2
	keyLen := binary.BigEndian.Uint32(data[1:5])
	if keyLen != 2 {
		t.Fatalf("Key length: %d, expected: 2", keyLen)
	}

	// Key: "hi"
	if string(data[5:7]) != "hi" {
		t.Fatalf("Key: %s, expected: hi", string(data[5:7]))
	}

	// Value length: 2
	valLen := binary.BigEndian.Uint32(data[7:11])
	if valLen != 2 {
		t.Fatalf("Value length: %d, expected: 2", valLen)
	}

	// Value: "go"
	if string(data[11:13]) != "go" {
		t.Fatalf("Value: %s, expected: go", string(data[11:13]))
	}

	// No expiry: 0x00
	if data[13] != NoExpiry {
		t.Fatalf("Expiry: 0x%02x, expected: 0x00", data[13])
	}
}

func TestSave_SkipExpiredKeys(t *testing.T) {
	// given: 만료된 키 1개 + 유효한 키 1개
	store := New()
	store.Set("expired", "old")
	store.Set("valid", "new")
	store.Expire("expired", 1)
	time.Sleep(2 * time.Second)

	path := filepath.Join(t.TempDir(), "skip.rdb")

	// when
	err := store.Save(path)

	// then: 만료 키 제외, "valid" 키만 저장
	// Header(7) + String("valid"=5,"new"=3: 1+4+5+4+3+1=18) + EOF(1) = 26
	if err != nil {
		t.Fatalf("에러 발생: %v", err)
	}
	data, _ := os.ReadFile(path)
	if len(data) != 26 {
		t.Fatalf("파일 크기: %d, expected: 26 (만료 키 제외)", len(data))
	}
}

func TestEncodeFullFile(t *testing.T) {
	// given
	var buf bytes.Buffer
	enc := NewEncoder(&buf)
	expireAt := time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC)

	// when: Header + String 엔트리 + List 엔트리(TTL 포함) + EOF
	enc.WriteHeader()
	enc.WriteStringEntry("name", "go", nil)
	enc.WriteListEntry("list", []string{"a", "b"}, &expireAt)
	enc.WriteEOF()
	enc.Flush()

	// then
	data := buf.Bytes()

	// "MINIDB"로 시작
	if string(data[:6]) != "MINIDB" {
		t.Fatalf("Magic bytes: %s", string(data[:6]))
	}

	// 0xFF로 끝남
	if data[len(data)-1] != EOF {
		t.Fatalf("마지막 바이트: 0x%02x, expected: 0xFF", data[len(data)-1])
	}

	// Header(7) + String(16) + List(32) + EOF(1) = 56
	if len(data) != 56 {
		t.Fatalf("총 길이: %d, expected: 56", len(data))
	}
}