gotta swap to tcp conns

src/adapt.go

@@ -0,0 +1,104 @@
+package src
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"hash/crc32"
+	"io"
+	"log"
+	"net"
+	"strconv"
+)
+
+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)
+			log.Printf("%q", raw)
+			if err != nil {
+				if err == io.EOF {
+					return true, nil
+				}
+				return false, err
+			}
+
+			if len(message) > 0 {
+				hashKey := message[max(0, len(message)-1)].(string)
+				hash := int(crc32.ChecksumIEEE([]byte(hashKey)))
+				forward := config.forwards[hash%len(config.forwards)]
+				result := forward.Do(ctx, message...)
+				_ = forward
+			}
+
+			return false, nil
+		}(); err != nil {
+			return err
+		} else if done {
+			return nil
+		}
+	}
+
+	return io.EOF
+}
+
+func readMessage(reader *bufio.Reader) ([]byte, []any, error) {
+	w := bytes.NewBuffer(nil)
+	firstLine, _, err := reader.ReadLine()
+	w.Write(firstLine)
+	if err != nil {
+		return w.Bytes(), nil, err
+	}
+	firstLine = bytes.TrimSuffix(firstLine, []byte("\r\n"))
+	if len(firstLine) == 0 {
+		return w.Bytes(), nil, nil
+	}
+
+	switch firstLine[0] {
+	case '+': // simple string, like +OK
+		return w.Bytes(), []any{string(firstLine[1:])}, nil
+	case '-': // simple error, like -message
+		return w.Bytes(), nil, fmt.Errorf("error: %s", firstLine[1:])
+	case ':': // number, like /[+-][0-9]+/
+		firstLine = bytes.TrimPrefix(firstLine[1:], []byte("+"))
+		n, err := strconv.Atoi(string(firstLine[1:]))
+		return w.Bytes(), []any{n}, err
+	case '$': // long string, like $-1 for nil, like $LEN\r\nSTRING\r\n
+		if firstLine[1] == '-' {
+			return w.Bytes(), []any{nil}, nil
+		}
+		nextLine, _, err := reader.ReadLine()
+		w.Write(nextLine)
+		nextLine = bytes.TrimSuffix(nextLine, []byte("\r\n"))
+		return w.Bytes(), []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 w.Bytes(), nil, err
+		} else if n == -1 {
+			return w.Bytes(), nil, nil
+		}
+		var result []any
+		for i := 0; i < n; i++ {
+			moreBytes, more, err := readMessage(reader)
+			w.Write(moreBytes)
+			if err != nil {
+				return w.Bytes(), nil, err
+			}
+			result = append(result, more...)
+		}
+		return w.Bytes(), result, nil
+	case '_': // nil
+		return w.Bytes(), nil, nil
+	case '#': // boolean, like #t or #f
+		return w.Bytes(), []any{firstLine[1] == 't'}, nil
+	case ',': // double
+		log.Fatal("not impl")
+	}
+
+	log.Fatalf("not impl: %q", firstLine)
+	return w.Bytes(), nil, nil
+}

src/config.go

@@ -0,0 +1,64 @@
+package src
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"slices"
+	"strings"
+
+	valkey "github.com/redis/go-redis/v9"
+)
+
+type Config struct {
+	Listen   string `json:"LISTEN"`
+	Forwards string `json:"FORWARDS"`
+	forwards []*valkey.Client
+}
+
+func NewConfig(ctx context.Context) (Config, error) {
+	config := Config{
+		Listen:   ":10000",
+		Forwards: "",
+	}
+	b, _ := json.Marshal(config)
+	var m map[string]any
+	if err := json.Unmarshal(b, &m); err != nil {
+		return config, err
+	}
+	for k := range m {
+		if v := os.Getenv(k); v != "" {
+			m[k] = v
+		}
+	}
+	b2, _ := json.Marshal(m)
+	if err := json.Unmarshal(b2, &config); err != nil {
+		return config, err
+	}
+
+	forwards := strings.Split(config.Forwards, ",")
+	forwards = slices.DeleteFunc(forwards, func(s string) bool { return s == "" })
+	config.forwards = make([]*valkey.Client, len(forwards))
+	for i := range forwards {
+		opt, err := valkey.ParseURL(forwards[i])
+		if err != nil {
+			config.Close()
+			return config, err
+		}
+		config.forwards[i] = valkey.NewClient(opt)
+		if err != nil {
+			config.Close()
+			return config, err
+		}
+	}
+
+	return config, nil
+}
+
+func (c Config) Close() {
+	for i := range c.forwards {
+		if c.forwards[i] != nil {
+			c.forwards[i].Close()
+		}
+	}
+}

src/listen.go

@@ -0,0 +1,53 @@
+package src
+
+import (
+	"context"
+	"log"
+	"net"
+	"sync"
+)
+
+func listen(ctx context.Context, config Config) error {
+	wg := &sync.WaitGroup{}
+	defer wg.Wait()
+
+	listener, err := net.Listen("tcp", config.Listen)
+	if err != nil {
+		return err
+	}
+	defer listener.Close()
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		<-ctx.Done()
+		listener.Close()
+	}()
+
+	for ctx.Err() == nil {
+		conn, err := listener.Accept()
+		if err != nil {
+			log.Println("error accepting:", err)
+		} else {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				handle(ctx, config, conn)
+			}()
+		}
+	}
+
+	return ctx.Err()
+}
+
+func handle(ctx context.Context, config Config, conn net.Conn) {
+	if err := _handle(ctx, config, conn); err != nil {
+		log.Println("error handling:", err)
+	}
+}
+
+func _handle(ctx context.Context, config Config, conn net.Conn) error {
+	defer conn.Close()
+
+	return adapt(ctx, config, conn)
+}

src/main.go

@@ -0,0 +1,19 @@
+package src
+
+import (
+	"context"
+)
+
+func Main(ctx context.Context) error {
+	config, err := NewConfig(ctx)
+	if err != nil {
+		return err
+	}
+	defer config.Close()
+
+	if err := listen(ctx, config); err != nil && ctx.Err() == nil {
+		return err
+	}
+
+	return nil
+}