120 lines
2.9 KiB
Go
120 lines
2.9 KiB
Go
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 true, 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)]
|
|
forwardCon := forward.Get()
|
|
if forwardCon == nil {
|
|
return true, io.EOF
|
|
}
|
|
forwardConn := forwardCon.(net.Conn)
|
|
if _, err := forwardConn.Write(raw); err != nil {
|
|
return true, err
|
|
}
|
|
replyer := bufio.NewReader(forwardConn)
|
|
raw, _, err := readMessage(replyer)
|
|
if err != nil {
|
|
return true, err
|
|
}
|
|
log.Printf("%q", raw)
|
|
if _, err := conn.Write(raw); err != nil {
|
|
return true, err
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|