very dumb adapter from redis GET, PUT, DEL to SELECT, INSERT ON CONFLICT UPDATE, DELETE

src/adapt.go

@@ -15,64 +15,80 @@ func adapt(ctx context.Context, config Config, conn net.Conn) error {
 	reader := bufio.NewReader(conn)
 
 	for ctx.Err() == nil {
-		if done, err := func() (bool, error) {
-			raw, message, err := readMessage(reader)
-			if err != nil {
-				if err == io.EOF {
-					return true, nil
-				}
-				return true, err
+		message, err := readMessage(reader)
+		if err != nil {
+			if err == io.EOF {
+				return nil
 			}
-			log.Printf("routing: %q (%+v)", raw, message)
-
-			if len(message) > 0 && message[0].(string) == "COMMAND" {
-				fmt.Fprintf(conn, "*0\r\n")
-			} else if len(raw) > 0 && len(message) > 0 {
-				hashKey := message[0].(string)
-				if len(message) > 1 {
-					hashKey = message[1].(string)
-				}
-				if err := config.WithConn(hashKey, func(forwardConn net.Conn) error {
-					//log.Printf("forwarding %q", raw)
-
-					written := 0
-					for written < len(raw) {
-						more, err := forwardConn.Write(raw[written:])
-						if err != nil {
-							return err
-						}
-						written += more
-					}
-
-					replyer := bufio.NewReader(forwardConn)
-					//log.Printf("reading reply to %q", raw)
-					_, err = readMessageTo(conn, replyer)
-					//log.Printf("read reply %q", raw)
-					return err
-				}); err != nil {
-					return true, err
-				}
-			}
-
-			return false, nil
-		}(); err != nil {
 			return err
-		} else if done {
-			return nil
 		}
+
+		if len(message) > 0 {
+			var reply string
+			switch message[0] {
+			case "hello":
+				reply = "*0\r\n"
+			case "client":
+				reply = "+OK\r\n"
+			case "ping":
+				reply = "+PONG\r\n"
+			case "set":
+				k := message[1].(string)
+				v := message[2]
+				reply = "+OK\r\n"
+				switch v2 := v.(type) {
+				case []byte:
+					if err := config.db.Put(ctx, 1, k, string(v2)); err != nil {
+						reply = "-" + err.Error() + "\r\n"
+					}
+				case string:
+					if err := config.db.Put(ctx, 1, k, v2); err != nil {
+						reply = "-" + err.Error() + "\r\n"
+					}
+				default:
+					log.Fatalf("not impl: set %T", v)
+				}
+			case "del":
+				k := message[1].(string)
+				reply = "+OK\r\n"
+				if err := config.db.Del(ctx, 1, k); err != nil {
+					reply = "-" + err.Error() + "\r\n"
+				}
+			case "get":
+				v, err := Select[any](ctx, 1, fmt.Sprint(message[1]))
+				if err != nil {
+					reply = "-" + err.Error()
+				} else if v == nil || *v == nil {
+					reply = "_\r\n" // RESP3 null
+				} else {
+					switch v2 := (*v).(type) {
+					case []byte:
+						reply = fmt.Sprintf("+%s\r\n", v2)
+					case string:
+						reply = fmt.Sprintf("+%s\r\n", v2)
+					default:
+						log.Fatalf("not impl: get type %T", v2)
+						return nil
+					}
+				}
+			default:
+				log.Fatalf("unhandled: %+v", message)
+			}
+			log.Printf("replying: %q", reply)
+			if _, err := fmt.Fprintf(conn, reply); err != nil {
+				return err
+			}
+		}
+
+		log.Println()
 	}
 
 	return io.EOF
 }
 
-func readMessage(reader *bufio.Reader) ([]byte, []any, error) {
-	w := bytes.NewBuffer(nil)
-	arr, err := readMessageTo(w, reader)
-	return w.Bytes(), arr, err
-}
-
-func readMessageTo(w io.Writer, reader *bufio.Reader) ([]any, error) {
+func readMessage(reader *bufio.Reader) ([]any, error) {
 	firstLine, _, err := reader.ReadLine()
+	log.Printf("%q", firstLine)
 	if err != nil {
 		return nil, err
 	}
@@ -80,51 +96,34 @@ func readMessageTo(w io.Writer, reader *bufio.Reader) ([]any, error) {
 	if len(firstLine) == 0 {
 		return nil, nil
 	}
-	fmt.Fprintf(w, "%s\r\n", firstLine)
 
 	switch firstLine[0] {
 	case '+': // simple string, like +OK
 		return []any{string(firstLine[1:])}, nil
 	case '-': // simple error, like -message
-		return []any{string(firstLine)}, nil
+		return nil, fmt.Errorf("error: %s", firstLine[1:])
 	case ':': // number, like /[+-][0-9]+/
 		firstLine = bytes.TrimPrefix(firstLine[1:], []byte("+"))
-		n, err := strconv.Atoi(string(firstLine))
-		if err != nil {
-			return nil, fmt.Errorf("num not a num: %q: %w", firstLine, err)
-		}
+		n, err := strconv.Atoi(string(firstLine[1:]))
 		return []any{n}, err
 	case '$': // long string, like $-1 for nil, like $LEN\r\nSTRING\r\n
 		if firstLine[1] == '-' {
 			return []any{nil}, nil
 		}
-		firstLine = bytes.TrimPrefix(firstLine[1:], []byte("+"))
-		n, err := strconv.Atoi(string(firstLine))
-		if err != nil {
-			return nil, fmt.Errorf("num not a num: %q: %w", firstLine, err)
-		}
-		//log.Printf("reading %v+2 bytes for bulk string", n)
-		nextLine := make([]byte, n+2)
-		nAt := 0
-		for nAt < n+2 {
-			nMore, err := reader.Read(nextLine[nAt:])
-			if err != nil {
-				return nil, fmt.Errorf("couldnt read %v more/%v bytes for long string: %w", n+2-nAt, n+2, err)
-			}
-			nAt += nMore
-		}
-		fmt.Fprintf(w, "%s", nextLine)
+		nextLine, _, err := reader.ReadLine()
+		log.Printf("%q", nextLine)
+		nextLine = bytes.TrimSuffix(nextLine, []byte("\r\n"))
 		return []any{string(nextLine)}, err
 	case '*': // array, like *-1 for nil, like *4 for [1,2,3,4]
 		n, err := strconv.Atoi(string(firstLine[1:]))
 		if err != nil {
-			return nil, fmt.Errorf("arr not a num: %q: %w", firstLine, err)
+			return nil, err
 		} else if n == -1 {
 			return nil, nil
 		}
 		var result []any
 		for i := 0; i < n; i++ {
-			more, err := readMessageTo(w, reader)
+			more, err := readMessage(reader)
 			if err != nil {
 				return nil, err
 			}

src/config.go

@@ -1,33 +1,38 @@
 package src
 
 import (
-	"bufio"
 	"context"
-	"encoding/base64"
 	"encoding/json"
-	"fmt"
-	"hash/crc32"
-	"io"
-	"log"
-	"net"
 	"os"
-	"slices"
-	"strings"
-	"sync"
 )
 
 type Config struct {
-	Listen   string `json:"LISTEN"`
-	Forwards string `json:"FORWARDS"`
-	Hello    string `json:"HELLO_B64"`
-	forwards []*sync.Pool
+	Listen           string `json:"LISTEN"`
+	ConnectionDriver string `json:"CONNECTION_DRIVER"`
+	ConnectionString string `json:"CONNECTION_STRING"`
+	db               DB
 }
 
 func NewConfig(ctx context.Context) (Config, error) {
+	config, err := newConfig()
+	if err != nil {
+		return config, err
+	}
+
+	db, err := NewDB(ctx, config.ConnectionDriver, config.ConnectionString)
+	if err != nil {
+		return config, err
+	}
+	config.db = db
+
+	return config, nil
+}
+
+func newConfig() (Config, error) {
 	config := Config{
-		Listen:   ":10000",
-		Forwards: "",
-		Hello:    base64.StdEncoding.EncodeToString([]byte("*1\r\n$4\r\nping\r\n")),
+		Listen:           ":10000",
+		ConnectionDriver: "sqlite",
+		ConnectionString: "/tmp/red-apter.db",
 	}
 	b, _ := json.Marshal(config)
 	var m map[string]any
@@ -43,88 +48,5 @@ func NewConfig(ctx context.Context) (Config, error) {
 	if err := json.Unmarshal(b2, &config); err != nil {
 		return config, err
 	}
-
-	hello, err := base64.StdEncoding.DecodeString(config.Hello)
-	if err != nil {
-		return config, err
-	}
-
-	forwards := strings.Split(config.Forwards, ",")
-	forwards = slices.DeleteFunc(forwards, func(s string) bool { return s == "" })
-	if len(forwards) == 0 {
-		return config, fmt.Errorf("at least one $FORWARD required")
-	}
-	config.forwards = make([]*sync.Pool, len(forwards))
-	for i := range forwards {
-		forward := forwards[i]
-		config.forwards[i] = &sync.Pool{
-			New: func() any {
-				if ctx.Err() != nil {
-					return nil
-				}
-				log.Printf("dialing %q with %q", forward, hello)
-				v, err := (&net.Dialer{}).DialContext(ctx, "tcp", forward)
-				if err != nil {
-					log.Printf("! failed dial %q: %v", forward, err)
-					return nil
-				}
-				if _, err := v.Write([]byte(hello)); err != nil {
-					log.Printf("! failed write hello %q: %v", forward, err)
-					v.Close()
-					return nil
-				}
-				if raw, _, err := readMessage(bufio.NewReader(v)); err != nil {
-					log.Printf("! failed read hello %q: %v", forward, err)
-					v.Close()
-					return nil
-				} else {
-					log.Printf("dial reply: %q", raw)
-				}
-				return v
-			},
-		}
-	}
-
 	return config, nil
 }
-
-func (c Config) Close() {
-	for i := range c.forwards {
-		if c.forwards[i] != nil {
-			i := i
-			go func() {
-				c.forwards[i].New = nil
-				for {
-					got := c.forwards[i].Get()
-					if got != nil {
-						go got.(net.Conn).Close()
-					}
-				}
-			}()
-		}
-	}
-}
-
-func (c Config) WithConn(hashKey string, foo func(net.Conn) error) error {
-	hash := int(crc32.ChecksumIEEE([]byte(hashKey)))
-	hashIdx := hash % len(c.forwards)
-	forward := c.forwards[hashIdx]
-
-	log.Printf("acquire conn %v", hashIdx)
-	forwardCon := forward.Get()
-	if forwardCon == nil {
-		log.Printf("got a nil conn to %v", hashIdx)
-		return io.EOF
-	}
-	forwardConn := forwardCon.(net.Conn)
-
-	if err := foo(forwardConn); err != nil {
-		log.Printf("errored with conn %v: %v", hashIdx, err)
-		forwardConn.Close()
-		return err
-	}
-
-	log.Printf("release conn %v", hashIdx)
-	forward.Put(forwardConn)
-	return nil
-}

src/db.go

@@ -0,0 +1,114 @@
+package src
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+
+	_ "github.com/lib/pq"
+	_ "modernc.org/sqlite"
+)
+
+type DB struct {
+	*sql.DB
+}
+
+var global DB
+
+func NewDB(ctx context.Context, driver, conn string) (DB, error) {
+	sql, err := sql.Open(driver, conn)
+	if err != nil {
+		return DB{}, err
+	}
+	db := DB{sql}
+
+	if err := db.setup(ctx); err != nil {
+		db.Close()
+		return db, err
+	}
+
+	global = db
+	return db, nil
+}
+
+func (db DB) setup(ctx context.Context) error {
+	if err := db.PingContext(ctx); err != nil {
+		return err
+	}
+	if _, err := db.ExecContext(ctx, `
+		CREATE TABLE IF NOT EXISTS data (
+			database INTEGER
+			, key TEXT
+			, value TEXT
+			, PRIMARY KEY (database, key)
+		)
+	`); err != nil {
+		return err
+	}
+	return nil
+}
+
+func Select[V any](ctx context.Context, database int, k string) (*V, error) {
+	var v V
+	err := global.Get(ctx, database, k, &v)
+	if err != nil {
+		if err != sql.ErrNoRows {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &v, nil
+}
+
+func (db DB) Get(ctx context.Context, database int, k string, vPtr any) error {
+	if err := db.get(ctx, database, k, vPtr); err != nil {
+		if err != sql.ErrNoRows {
+			return err
+		}
+	}
+	return nil
+}
+
+func (db DB) get(ctx context.Context, database int, k string, vPtr any) error {
+	row := db.QueryRowContext(ctx, `
+		SELECT value
+		FROM data
+		WHERE database=$1 AND key=$2
+	`, database, k)
+	if err := row.Err(); err != nil {
+		return err
+	}
+
+	var v string
+	if err := row.Scan(&v); err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal([]byte(v), vPtr); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db DB) Put(ctx context.Context, database int, k string, v any) error {
+	b, _ := json.Marshal(v)
+	_, err := db.ExecContext(ctx, `
+		INSERT INTO data (database, key, value)
+		VALUES ($1, $2, $3)
+
+		ON CONFLICT DO UPDATE
+
+		SET value = $3
+		WHERE database = $1 AND key = $2
+	`, database, k, string(b))
+	return err
+}
+
+func (db DB) Del(ctx context.Context, database int, k string) error {
+	_, err := db.ExecContext(ctx, `
+		DELETE FROM data
+		WHERE database=$1 AND key=$2
+	`, database, k)
+	return err
+}

src/db_test.go

@@ -0,0 +1,58 @@
+package src_test
+
+import (
+	"context"
+	"path"
+	"red-apter/src"
+	"testing"
+	"time"
+)
+
+func TestDBSqlite(t *testing.T) {
+	ctx, can := context.WithTimeout(context.Background(), time.Minute)
+	defer can()
+
+	db, err := src.NewDB(ctx, "sqlite", path.Join(t.TempDir(), "db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { db.Close() })
+
+	v := -1
+	if err := db.Get(ctx, 5, "k", &v); err != nil {
+		t.Error("failed get 404:", err)
+	} else if v != -1 {
+		t.Error("got 404:", v)
+	}
+
+	if err := db.Put(ctx, 5, "k", 6); err != nil {
+		t.Error("failed insert:", err)
+	} else if err := db.Put(ctx, 5, "k", 7); err != nil {
+		t.Error("failed update:", err)
+	}
+
+	if err := db.Get(ctx, 5, "k", &v); err != nil {
+		t.Error("failed get:", err)
+	} else if v != 7 {
+		t.Errorf("wrong get: (%T) %v but wanted 7", v, v)
+	}
+
+	if v, err := src.Select[int](ctx, 5, "k"); err != nil {
+		t.Error("failed select[int]:", err)
+	} else if v == nil || *v != 7 {
+		t.Errorf("wrong get: (%T) %v but wanted 7", v, v)
+	}
+
+	if err := db.Del(ctx, 5, "k"); err != nil {
+		t.Error("failed del:", err)
+	} else if err := db.Del(ctx, 5, "k"); err != nil {
+		t.Error("failed del 404:", err)
+	}
+
+	v = -1
+	if err := db.Get(ctx, 5, "k", &v); err != nil {
+		t.Error("failed get 410:", err)
+	} else if v != -1 {
+		t.Error("wrong get 410:", v)
+	}
+}

src/listen.go

@@ -8,8 +8,6 @@ import (
 )
 
 func listen(ctx context.Context, config Config) error {
-	defer log.Println("/listen()")
-
 	wg := &sync.WaitGroup{}
 	defer wg.Wait()
 
@@ -17,6 +15,8 @@ func listen(ctx context.Context, config Config) error {
 	if err != nil {
 		return err
 	}
+	defer listener.Close()
+
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
@@ -31,7 +31,6 @@ func listen(ctx context.Context, config Config) error {
 		} else {
 			wg.Add(1)
 			go func() {
-				defer log.Println("/handle()")
 				defer wg.Done()
 				handle(ctx, config, conn)
 			}()

src/main.go

@@ -2,17 +2,14 @@ package src
 
 import (
 	"context"
-	"log"
 )
 
 func Main(ctx context.Context) error {
-	defer log.Println("/Main()")
-
 	config, err := NewConfig(ctx)
 	if err != nil {
 		return err
 	}
-	defer config.Close()
+	defer config.db.Close()
 
 	if err := listen(ctx, config); err != nil && ctx.Err() == nil {
 		return err

src/testdata/redises.sh

@@ -1,17 +0,0 @@
-#! /usr/bin/bash
-
-d=$(mktemp -d)
-mkdir -p $d/1
-mkdir -p $d/2
-valkey-server --dir $d/1 --port 60113 --logfile $d/1.log &
-bg=${!}
-cleanup() {
-   kill $bg
-}
-trap cleanup EXIT
-(
-   sleep 5
-   echo FORWARDS=127.0.0.1:60113,127.0.0.1:60114
-) &
-valkey-server --dir $d/2 --port 60114 --logfile $d/2.log 
-