added basic ws commands

api/main.go

@@ -10,7 +10,7 @@ import (
 
 func InitApiServer(conf *util.Config, dbConn *db.DBConn, twitchConn *ttv.TwitchConn) (*ApiServer, error) {
 	engine := gin.Default()
-	wsServer, err := ws.InitWSServer(dbConn, twitchConn)
+	wsServer, err := ws.InitWSServer(conf, dbConn, twitchConn)
 	if err != nil {
 		return nil, err
 	}

api/ws/main.go

@@ -1,24 +1,35 @@
 package ws
 
 import (
+	"errors"
+	"fmt"
 	"log"
+	"net"
 	"net/http"
+	"strings"
 
 	"github.com/gobwas/ws"
 	"github.com/gobwas/ws/wsutil"
 	"zomo.dev/largehadroncollider/db"
 	"zomo.dev/largehadroncollider/ttv"
+	"zomo.dev/largehadroncollider/util"
 )
 
-func InitWSServer(dbConn *db.DBConn, twitchConn *ttv.TwitchConn) (*WSServer, error) {
-	return &WSServer{}, nil
+func InitWSServer(conf *util.Config, dbConn *db.DBConn, twitchConn *ttv.TwitchConn) (*WSServer, error) {
+	return &WSServer{conf, dbConn, twitchConn}, nil
 }
 
 type WSServer struct {
+	conf *util.Config
+	db *db.DBConn
+	twitch *ttv.TwitchConn
 }
 
 type WSConn struct {
+	conf *util.Config
+	c net.Conn
 	events []string
+	authrorized bool
 }
 
 func (wsServer *WSServer) Handle(w http.ResponseWriter, r *http.Request) error {
@@ -27,42 +38,91 @@ func (wsServer *WSServer) Handle(w http.ResponseWriter, r *http.Request) error {
 		return err
 	}
 
-	authrorization := ""
-
-	go func() {
-		defer conn.Close()
-
-		for {
-			msg, _, err := wsutil.ReadClientData(conn)
-			if err != nil {
-				// TODO handle error better, print more conn info
-				log.Printf("Error reading data from ws connection %v", err)
-				continue
-			}
-
-			cmd, err := parseCommand(string(msg))
-			if err != nil {
-				log.Printf("Error parsing command data from ws connection %v", err)
-				continue
-			}
-
-			log.Printf("%+v", cmd)
-
-			if authrorization == "" {
-				// TODO authorize connection
-				continue
-			}
-
-			// TODO run with cmd
-
-			// TODO errors will be responded to the client
-			// if the response errors, log and exit the loop
-		}
-	}()
+	wsconn := &WSConn{}
+	go wsconn.handleThread(wsServer.conf, conn)
 
 	return nil
 }
 
-func runCommand(cmd *Command) {
+func (conn *WSConn) handleThread(conf *util.Config, c net.Conn) {
+	conn.conf = conf
+	conn.c = c
+	defer c.Close()
 
+	for {
+		msg, _, err := wsutil.ReadClientData(conn.c)
+		if err != nil {
+			// TODO handle error better, print more conn info
+			log.Printf("Error reading data from ws connection %v", err)
+			continue
+		}
+
+		cmd, err := parseCommand(string(msg))
+		if err != nil {
+			log.Printf("Error parsing command data from ws connection %v", err)
+			continue
+		}
+
+		log.Printf("%+v", cmd)
+
+		err = conn.runCommand(cmd)
+
+		if err != nil {
+			_, err := fmt.Fprintf(conn.c, "error running command: %s: %v", cmd.Command, err)
+			if err != nil {
+				// TODO better print
+				log.Printf("ERROR: unable to send error to client: %v", err)
+				log.Printf("ERROR: client details: %+v", conn)
+				log.Printf("ERROR: command details: %+v", cmd)
+				return
+			}
+		}
+	}
+}
+
+func (conn *WSConn) runCommand(cmd *Command) error {
+	switch strings.ToLower(cmd.Command) {
+	case "ping":
+		return conn.runCommandPing(cmd.Args)
+	case "authorization":
+		return conn.runCommandAuthorization(cmd.Args)
+	
+	case "events-add":
+		return conn.runCommandEventsAdd(cmd.Args)
+
+	default:
+		return fmt.Errorf("invalid command: %s", cmd.Command)
+	}
+}
+
+func (conn *WSConn) runCommandPing(_ []string) error {
+	_, err := fmt.Fprint(conn.c, "pong")
+	return err
+}
+
+func (conn *WSConn) runCommandAuthorization(args []string) error {
+	if conn.authrorized {
+		return errors.New("connection already authorized")
+	}
+	if len(args) < 1 {
+		return errors.New("no authorization key given")
+	}
+
+	key := args[0]
+	if key != conn.conf.WSAuthorization {
+		return errors.New("invalid authorization key")
+	}
+
+	conn.authrorized = true
+	return nil
+}
+
+func (conn *WSConn) runCommandEventsAdd(args []string) error {
+	if !conn.authrorized {
+		return errors.New("unauthorized")
+	}
+
+	// TODO subscribe
+
+	return nil
 }