110 lines
2.3 KiB
Go
110 lines
2.3 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type Message struct {
|
|
ID int
|
|
Data []string
|
|
}
|
|
|
|
func ParseMsg(msg string) (*Message, error) {
|
|
parts := strings.Split(msg, ",")
|
|
msgIdStr := parts[0]
|
|
if !strings.HasPrefix(msgIdStr, "M") {
|
|
return nil, fmt.Errorf("message must start with 'M' prefix")
|
|
}
|
|
msgIdStr = strings.TrimPrefix(msgIdStr, "M")
|
|
msgId, err := strconv.Atoi(msgIdStr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
msgData := make([]string, len(parts)-1)
|
|
for i, data := range parts[1:] {
|
|
msgData[i] = strings.TrimSpace(data)
|
|
}
|
|
message := &Message{
|
|
ID: msgId,
|
|
Data: msgData,
|
|
}
|
|
return message, nil
|
|
}
|
|
|
|
func main() {
|
|
// Initialize JSON logger
|
|
logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
|
|
slog.SetDefault(logger)
|
|
|
|
addr := "0.0.0.0:8080"
|
|
slog.Info("Starting TCP server", "address", addr)
|
|
|
|
//Resolve address
|
|
addr_, err := net.ResolveTCPAddr("tcp", addr)
|
|
if err != nil {
|
|
slog.Error("Error resolving address", "error", err)
|
|
return
|
|
}
|
|
|
|
//Listen for incoming connections
|
|
listener, err := net.ListenTCP("tcp", addr_)
|
|
if err != nil {
|
|
slog.Error("Error starting server", "error", err)
|
|
return
|
|
}
|
|
defer listener.Close()
|
|
|
|
for {
|
|
//Accept incoming connection
|
|
conn, err := listener.AcceptTCP()
|
|
if err != nil {
|
|
slog.Error("Error accepting connection", "error", err)
|
|
continue
|
|
}
|
|
go handleConnection(conn)
|
|
}
|
|
}
|
|
|
|
func handleConnection(conn *net.TCPConn) {
|
|
defer conn.Close()
|
|
slog.Info("New connection", "remote_addr", conn.RemoteAddr().String())
|
|
|
|
buffer := make([]byte, 1024)
|
|
for {
|
|
//Read up to 1024 bytes
|
|
n, err := conn.Read(buffer)
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
slog.Info("Connection closed by client", "remote_addr", conn.RemoteAddr().String())
|
|
} else {
|
|
slog.Error("Error reading from connection", "error", err)
|
|
}
|
|
return
|
|
}
|
|
if n == 0 {
|
|
return
|
|
}
|
|
msgStr := string(buffer[:n])
|
|
slog.Info("Received message", "message", msgStr, "bytes", n)
|
|
msg, err := ParseMsg(msgStr)
|
|
if err != nil {
|
|
slog.Error("Error parsing message", "error", err)
|
|
return
|
|
}
|
|
slog.Info("Parsed message", "message", msg)
|
|
|
|
//Echo message back
|
|
// _, err = conn.Write(buffer[:n])
|
|
_, err = conn.Write([]byte("1"))
|
|
if err != nil {
|
|
slog.Error("Error writing to connection", "error", err)
|
|
return
|
|
}
|
|
}
|
|
}
|