mirror of
https://github.com/Kyren223/eko.git
synced 2026-07-14 08:00:25 +00:00
123 lines
3.5 KiB
Go
123 lines
3.5 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/kyren223/eko/internal/data"
|
|
"github.com/kyren223/eko/internal/packet"
|
|
"github.com/kyren223/eko/pkg/assert"
|
|
"github.com/kyren223/eko/pkg/snowflake"
|
|
)
|
|
|
|
func handleConnection(conn net.Conn, wg *sync.WaitGroup) {
|
|
log.Println("accepted client:", conn.RemoteAddr().String())
|
|
defer log.Println("disconnected client:", conn.RemoteAddr().String())
|
|
defer conn.Close()
|
|
defer wg.Done()
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
out, outErr := packet.RunFramer(ctx, conn)
|
|
|
|
outer:
|
|
for {
|
|
select {
|
|
case packet, ok := <-out:
|
|
if !ok {
|
|
break outer
|
|
}
|
|
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 if err != nil {
|
|
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
|
|
}
|
|
}
|
|
}
|
|
|
|
func handlePacket(pkt packet.Packet) (packet.Packet, error) {
|
|
var response packet.TypedMessage
|
|
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 + "\""}
|
|
case packet.TypeSendMessage:
|
|
var request packet.SendMessageMessage
|
|
if err := pkt.DecodePayload(&request); err != nil {
|
|
return packet.Packet{}, fmt.Errorf("decode error: %v", err)
|
|
}
|
|
|
|
content := strings.TrimSpace(request.Content)
|
|
if content == "" {
|
|
response = &packet.ErrorMessage{Error: "content must not be blank"}
|
|
break
|
|
}
|
|
|
|
message := data.Message{
|
|
Id: node.Generate(),
|
|
SenderId: node.Generate(),
|
|
FrequencyId: node.Generate(),
|
|
NetworkId: node.Generate(),
|
|
Contents: content,
|
|
}
|
|
messages = append(messages, message)
|
|
|
|
response = &packet.EkoMessage{Message: "Eko OK"}
|
|
case packet.TypeGetMessages:
|
|
var request packet.GetMessagesMessage
|
|
if err := pkt.DecodePayload(&request); err != nil {
|
|
return packet.Packet{}, fmt.Errorf("decode error: %v", err)
|
|
}
|
|
|
|
response = &packet.MessagesMessage{Messages: messages}
|
|
default:
|
|
return packet.Packet{}, errors.New("TODO: not implemented yet")
|
|
}
|
|
|
|
assert.NotNil(response, "response must always be set")
|
|
encoder, err := packet.NewMsgPackEncoder(response)
|
|
if err != nil {
|
|
return packet.Packet{}, fmt.Errorf("encode error: %v", err)
|
|
}
|
|
return packet.NewPacket(encoder), nil
|
|
}
|
|
|
|
var (
|
|
node = snowflake.NewNode(1)
|
|
messages []data.Message
|
|
)
|