add simple ws logger

wsServer.go

@@ -2,113 +2,41 @@ package main
 
 import (
 	"context"
-	"errors"
 	"log"
 	"net/http"
-	"sync"
 	"time"
 
 	"github.com/coder/websocket"
 	"github.com/coder/websocket/wsjson"
 )
 
-type wsServer struct {
-	OnOpen    func(c *Client)
-	OnClose   func(c *Client, err error)
-	OnMessage func(c *Client, msg map[string]any)
-}
-
-var (
-	mu sync.Mutex
-)
-
-func (s *wsServer) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
-	conn, err := websocket.Accept(responseWriter, request, &websocket.AcceptOptions{
-		InsecureSkipVerify: true,
-	})
+func ServeConnection(responseWriter http.ResponseWriter, request *http.Request) {
+	connection, err := websocket.Accept(responseWriter, request, nil)
 	if err != nil {
-		log.Println("accept error:", err)
+		log.Printf("websocket accept error: %v", err)
 		return
 	}
-	defer conn.CloseNow()
 
-	client := &Client{conn: conn}
-
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
 	defer cancel()
 
-	if s.OnOpen != nil {
-		s.OnOpen(client)
-	}
-
-	var readErr error
 	for {
-		var msg map[string]any
-		if readErr = wsjson.Read(ctx, conn, &msg); readErr != nil {
-			break
+		var clientMessage any
+		err := wsjson.Read(ctx, connection, &clientMessage)
+		if err != nil {
+			log.Printf("read error: %clientMessage", err)
+			return
 		}
-		if s.OnMessage != nil {
-			s.OnMessage(client, msg)
+		log.Printf("received: %clientMessage", clientMessage)
+
+		// process and optionally respond
+		err = wsjson.Write(ctx, connection, map[string]string{"status": "ok"})
+		if err != nil {
+			log.Printf("write error: %clientMessage", err)
+			return
 		}
 	}
-
-	cancel() // cancel before OnClose so any in-flight queries are canceled first
-
-	if s.OnClose != nil {
-		s.OnClose(client, readErr)
-	}
-
-	conn.Close(websocket.StatusNormalClosure, "done")
 }
 
-func sendAndCloseIfFails(conn *websocket.Conn, message *map[string]any) {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	if err := wsjson.Write(ctx, conn, message); err != nil {
-		conn.Close(websocket.StatusGoingAway, "Write error")
-	}
-}
-func sendToGroup(id uint64, excludedUserId uint64, message *map[string]any) error {
-	if _, ok := Groups[id]; !ok {
-		return errors.New("Group Not Found")
-	}
-
-	for client := range ConnectedClients[id] {
-		if client.User.Id != excludedUserId {
-			sendAndCloseIfFails(client.conn, message)
-		}
-	}
-	return nil
-}
-
-func handleUnauthenticatedMessage(client *Client, msg map[string]any) {
-	token, ok := msg["token"].(string)
-	if !ok {
-		client.conn.Close(websocket.StatusGoingAway, "invalid token")
-		return
-	}
-
-	user, err := GetUserFromToken(token)
-	if err != nil {
-		client.conn.Close(websocket.StatusPolicyViolation, "invalid token")
-		return
-	}
-	groupIds, err := GetUserMemberGroupIds(context.Background(), user.Id)
-	if err != nil {
-		client.conn.Close(websocket.StatusInternalError, "internal error")
-		return
-	}
-	user.MemberGroupsId = groupIds
-	client.User = &user
-	m := map[string]any{
-		"authAs": user.Name,
-	}
-	sendAndCloseIfFails(client.conn, &m)
-	AddOrUpdateConnectedClientToCache(&mu, client)
-	log.Println("New User authenticated as: " + user.Name)
-}
-
-func handleAuthenticatedMessage(client *Client, msg map[string]any) {
-	m := map[string]any{"temporary": "unauthorized"}
-	sendAndCloseIfFails(client.conn, &m)
-}
+func handleUnauthenticatedMessage() {}
+func handleAuthenticatedMessage()   {}