surely tiny reads explain slowness on command docs

src/adapt.go

@@ -5,7 +5,6 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"hash/crc32"
 	"io"
 	"log"
 	"net"
@@ -18,33 +17,39 @@ func adapt(ctx context.Context, config Config, conn net.Conn) error {
 	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 true, err
 			}
+			log.Printf("routing: %q (%+v)", raw, message)
 
-			if len(message) > 0 {
+			if len(message) > 0 && message[0].(string) == "COMMAND" {
-				hashKey := message[max(0, len(message)-1)].(string)
+				fmt.Fprintf(conn, "*0\r\n")
-				hash := int(crc32.ChecksumIEEE([]byte(hashKey)))
+			} else if len(raw) > 0 && len(message) > 0 {
-				forward := config.forwards[hash%len(config.forwards)]
+				hashKey := message[0].(string)
-				forwardCon := forward.Get()
+				if len(message) > 1 {
-				if forwardCon == nil {
+					hashKey = message[1].(string)
-					return true, io.EOF
 				}
-				forwardConn := forwardCon.(net.Conn)
+				if err := config.WithConn(hashKey, func(forwardConn net.Conn) error {
-				if _, err := forwardConn.Write(raw); err != nil {
+					//log.Printf("forwarding %q", raw)
-					return true, err
+
-				}
+					written := 0
-				replyer := bufio.NewReader(forwardConn)
+					for written < len(raw) {
-				raw, _, err := readMessage(replyer)
+						more, err := forwardConn.Write(raw[written:])
 						if err != nil {
-					return true, err
+							return err
 						}
-				log.Printf("%q", raw)
+						written += more
-				if _, err := conn.Write(raw); err != nil {
+					}
+
+					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
 				}
 			}
@@ -62,58 +67,78 @@ func adapt(ctx context.Context, config Config, conn net.Conn) error {
 
 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) {
 	firstLine, _, err := reader.ReadLine()
-	w.Write(firstLine)
 	if err != nil {
-		return w.Bytes(), nil, err
+		return nil, err
 	}
 	firstLine = bytes.TrimSuffix(firstLine, []byte("\r\n"))
 	if len(firstLine) == 0 {
-		return w.Bytes(), nil, nil
+		return nil, nil
 	}
+	fmt.Fprintf(w, "%s\r\n", firstLine)
 
 	switch firstLine[0] {
 	case '+': // simple string, like +OK
-		return w.Bytes(), []any{string(firstLine[1:])}, nil
+		return []any{string(firstLine[1:])}, nil
 	case '-': // simple error, like -message
-		return w.Bytes(), nil, fmt.Errorf("error: %s", firstLine[1:])
+		return []any{string(firstLine)}, nil
 	case ':': // number, like /[+-][0-9]+/
 		firstLine = bytes.TrimPrefix(firstLine[1:], []byte("+"))
-		n, err := strconv.Atoi(string(firstLine[1:]))
+		n, err := strconv.Atoi(string(firstLine))
-		return w.Bytes(), []any{n}, err
+		if err != nil {
+			return nil, fmt.Errorf("num not a num: %q: %w", firstLine, err)
+		}
+		return []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
+			return []any{nil}, nil
 		}
-		nextLine, _, err := reader.ReadLine()
+		firstLine = bytes.TrimPrefix(firstLine[1:], []byte("+"))
-		w.Write(nextLine)
+		n, err := strconv.Atoi(string(firstLine))
-		nextLine = bytes.TrimSuffix(nextLine, []byte("\r\n"))
+		if err != nil {
-		return w.Bytes(), []any{string(nextLine)}, err
+			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)
+		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 w.Bytes(), nil, err
+			return nil, fmt.Errorf("arr not a num: %q: %w", firstLine, err)
 		} else if n == -1 {
-			return w.Bytes(), nil, nil
+			return nil, nil
 		}
 		var result []any
 		for i := 0; i < n; i++ {
-			moreBytes, more, err := readMessage(reader)
+			more, err := readMessageTo(w, reader)
-			w.Write(moreBytes)
 			if err != nil {
-				return w.Bytes(), nil, err
+				return nil, err
 			}
 			result = append(result, more...)
 		}
-		return w.Bytes(), result, nil
+		return result, nil
 	case '_': // nil
-		return w.Bytes(), nil, nil
+		return nil, nil
 	case '#': // boolean, like #t or #f
-		return w.Bytes(), []any{firstLine[1] == 't'}, nil
+		return []any{firstLine[1] == 't'}, nil
 	case ',': // double
 		log.Fatal("not impl")
 	}
 
 	log.Fatalf("not impl: %q", firstLine)
-	return w.Bytes(), nil, nil
+	return nil, nil
 }

src/config.go

@@ -1,9 +1,14 @@
 package src
 
 import (
+	"bufio"
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"hash/crc32"
+	"io"
+	"log"
 	"net"
 	"os"
 	"slices"
@@ -14,6 +19,7 @@ import (
 type Config struct {
 	Listen   string `json:"LISTEN"`
 	Forwards string `json:"FORWARDS"`
+	Hello    string `json:"HELLO_B64"`
 	forwards []*sync.Pool
 }
 
@@ -21,6 +27,7 @@ func NewConfig(ctx context.Context) (Config, error) {
 	config := Config{
 		Listen:   ":10000",
 		Forwards: "",
+		Hello:    base64.StdEncoding.EncodeToString([]byte("*1\r\n$4\r\nping\r\n")),
 	}
 	b, _ := json.Marshal(config)
 	var m map[string]any
@@ -37,6 +44,11 @@ func NewConfig(ctx context.Context) (Config, error) {
 		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 {
@@ -44,12 +56,30 @@ func NewConfig(ctx context.Context) (Config, error) {
 	}
 	config.forwards = make([]*sync.Pool, len(forwards))
 	for i := range forwards {
+		forward := forwards[i]
 		config.forwards[i] = &sync.Pool{
 			New: func() any {
-				v, err := (&net.Dialer{}).DialContext(ctx, "tcp", forwards[i])
+				if ctx.Err() != nil {
-				if 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
 			},
 		}
@@ -61,13 +91,40 @@ func NewConfig(ctx context.Context) (Config, error) {
 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 {
-					got.(net.Conn).Close()
+						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/listen.go

@@ -8,6 +8,8 @@ import (
 )
 
 func listen(ctx context.Context, config Config) error {
+	defer log.Println("/listen()")
+
 	wg := &sync.WaitGroup{}
 	defer wg.Wait()
 
@@ -15,8 +17,6 @@ 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,6 +31,7 @@ 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,9 +2,12 @@ package src
 
 import (
 	"context"
+	"log"
 )
 
 func Main(ctx context.Context) error {
+	defer log.Println("/Main()")
+
 	config, err := NewConfig(ctx)
 	if err != nil {
 		return err

src/testdata/redises.sh

@@ -0,0 +1,17 @@
+#! /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 
+