feat: communication using custom packet protocol

1 files changed, 65 insertions, 13 deletions

diff --git a/internal/server/handler.go b/internal/server/handler.go
index 83d3e6e..61ecbae 100644
--- a/internal/server/handler.go
+++ b/internal/server/handler.go
@@ -1,10 +1,16 @@
 package server
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"log"
 	"net"
 	"sync"
+	"time"
+
+	"github.com/kyren223/eko/internal/packet"
+	"github.com/kyren223/eko/pkg/assert"
 )
 
 func handleConnection(conn net.Conn, wg *sync.WaitGroup) {
@@ -13,20 +19,66 @@ func handleConnection(conn net.Conn, wg *sync.WaitGroup) {
 	defer conn.Close()
 	defer wg.Done()
 
-	buffer := make([]byte, 1024)
-	bytesRead, err := conn.Read(buffer)
-	if err != nil {
-		log.Println("failed reading request:", err)
-		return
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+	out, outErr := packet.RunFramer(ctx, conn)
+	log.Printf("client %v: running framer\n", conn.RemoteAddr().String())
+
+outer:
+	for {
+		select {
+		case packet := <-out:
+			log.Printf("client %v: request packet: %v\n", conn.RemoteAddr().String(), packet)
+			responsePacket, err := handlePacket(packet)
+			log.Printf("client %v: response packet: %v\n", conn.RemoteAddr().String(), responsePacket)
+			if err != nil {
+				log.Printf("client %v: error processing request: %v\n", conn.RemoteAddr().String(), err)
+				break outer
+			}
+			err = responsePacket.Into(conn)
+			if err != nil {
+				log.Printf("client %v: error writing packet: %v\n", conn.RemoteAddr().String(), err)
+				break outer
+			}
+
+		case err := <-outErr:
+			if err == packet.PacketUnsupportedEncoding {
+				err := unsupportedEncodingErrorPacket.Into(conn)
+				log.Printf("client %v: error writing unsupported encoding packet: %v\n", conn.RemoteAddr().String(), err)
+			} else if err == packet.PacketUnsupportedType {
+				err := unsupportedTypeErrorPacket.Into(conn)
+				log.Printf("client %v: error writing unsupported type packet: %v\n", conn.RemoteAddr().String(), err)
+			} else {
+				log.Printf("client %v: internal error: %v\n", conn.RemoteAddr().String(), err)
+			}
+			break outer
+
+		case <-ctx.Done():
+			log.Printf("client %v: %v\n", conn.RemoteAddr().String(), ctx.Err())
+			break outer
+		}
 	}
-	request := string(buffer[:bytesRead])
-	log.Printf("Read %v bytes: %v\n", bytesRead, request)
+}
+
+func handlePacket(pkt packet.Packet) (packet.Packet, error) {
+	switch pkt.Type() {
+	case packet.TypeEko:
+		var request packet.EkoMessage
+		if err := pkt.DecodePayload(&request); err != nil {
+			return packet.Packet{}, fmt.Errorf("decode error: %v", err)
+		}
+
+		response := packet.EkoMessage{Message: "Eko \"" + request.Message + "\""}
+		encoder, err := packet.NewMsgPackEncoder(&response)
+		if err != nil {
+			return packet.Packet{}, fmt.Errorf("encode error: %v", err)
+		}
+		return packet.NewPacket(encoder), nil
 
-	response := []byte(fmt.Sprintf("Eko \"%v\"", request))
-	bytesWritten, err := conn.Write(response)
-	if err != nil {
-		log.Println("failed writing response:", err)
-		return
+	case packet.TypeError:
+		return packet.Packet{}, errors.New("TODO: not implemented yet")
+	default:
+		assert.Unreachable("type should be checked for validity before handler, packet = %v", pkt.String())
+		return packet.Packet{}, nil
 	}
-	log.Printf("written %v bytes\n", bytesWritten)
 }