progress on server refactor

server/internal/websocket/admin.go

@@ -0,0 +1,189 @@
+package websocket
+
+import (
+	"n.eko.moe/neko/internal/event"
+	"n.eko.moe/neko/internal/message"
+	"n.eko.moe/neko/internal/session"
+)
+
+func (h *MessageHandler) adminLock(id string, session *session.Session) error {
+	if !session.Admin || !h.locked {
+		return nil
+	}
+
+	h.locked = true
+
+	if err := h.sessions.Brodcast(
+		message.Admin{
+			Event: event.ADMIN_LOCK,
+			ID:    id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.ADMIN_LOCK)
+		return err
+	}
+
+	return nil
+}
+
+func (h *MessageHandler) adminUnlock(id string, session *session.Session) error {
+	if !session.Admin || !h.locked {
+		return nil
+	}
+
+	h.locked = false
+
+	if err := h.sessions.Brodcast(
+		message.Admin{
+			Event: event.ADMIN_UNLOCK,
+			ID:    id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.ADMIN_UNLOCK)
+		return err
+	}
+
+	return nil
+}
+
+func (h *MessageHandler) adminControl(id string, session *session.Session) error {
+	if !session.Admin {
+		return nil
+	}
+
+	h.sessions.SetHost(id)
+
+	if err := h.sessions.Brodcast(
+		message.Admin{
+			Event: event.ADMIN_FORCE_CONTROL,
+			ID:    id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.ADMIN_FORCE_CONTROL)
+		return err
+	}
+
+	return nil
+}
+
+func (h *MessageHandler) adminRelease(id string, session *session.Session) error {
+	if !session.Admin {
+		return nil
+	}
+
+	h.sessions.ClearHost()
+
+	if err := h.sessions.Brodcast(
+		message.Admin{
+			Event: event.ADMIN_FORCE_RELEASE,
+			ID:    id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.ADMIN_FORCE_RELEASE)
+		return err
+	}
+
+	return nil
+}
+
+func (h *MessageHandler) adminBan(id string, session *session.Session, payload *message.Admin) error {
+	if !session.Admin {
+		return nil
+	}
+
+	session, ok := h.sessions.Get(id)
+	if !ok {
+		return nil
+	}
+
+	address := session.RemoteAddr()
+	if address == nil {
+		return nil
+	}
+
+	h.banned[*address] = true
+
+	if err := session.Kick(message.Disconnect{
+		Event:   event.SYSTEM_DISCONNECT,
+		Message: "You have been banned",
+	}); err != nil {
+		return err
+	}
+
+	if err := h.sessions.Brodcast(
+		message.AdminSubject{
+			Event:   event.ADMIN_BAN,
+			Subject: payload.ID,
+			ID:      id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.ADMIN_BAN)
+		return err
+	}
+
+	return nil
+}
+
+func (h *MessageHandler) adminKick(id string, session *session.Session, payload *message.Admin) error {
+	if !session.Admin {
+		return nil
+	}
+
+	if err := h.sessions.Kick(payload.ID, message.Disconnect{
+		Event:   event.SYSTEM_DISCONNECT,
+		Message: "You have been banned",
+	}); err != nil {
+		return err
+	}
+
+	if err := h.sessions.Brodcast(
+		message.AdminSubject{
+			Event:   event.ADMIN_KICK,
+			Subject: payload.ID,
+			ID:      id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.ADMIN_KICK)
+		return err
+	}
+
+	return nil
+}
+
+func (h *MessageHandler) adminMute(id string, session *session.Session, payload *message.Admin) error {
+	if !session.Admin {
+		return nil
+	}
+
+	if err := h.sessions.Mute(payload.ID); err != nil {
+		return err
+	}
+
+	if err := h.sessions.Brodcast(
+		message.AdminSubject{
+			Event:   event.ADMIN_MUTE,
+			Subject: payload.ID,
+			ID:      id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.ADMIN_UNMUTE)
+		return err
+	}
+
+	return nil
+}
+
+func (h *MessageHandler) adminUnmute(id string, session *session.Session, payload *message.Admin) error {
+	if !session.Admin {
+		return nil
+	}
+
+	if err := h.sessions.Unmute(payload.ID); err != nil {
+		return err
+	}
+
+	if err := h.sessions.Brodcast(
+		message.AdminSubject{
+			Event:   event.ADMIN_UNMUTE,
+			Subject: payload.ID,
+			ID:      id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.ADMIN_UNMUTE)
+		return err
+	}
+
+	return nil
+}

server/internal/websocket/chat.go

@@ -0,0 +1,33 @@
+package websocket
+
+import (
+	"n.eko.moe/neko/internal/event"
+	"n.eko.moe/neko/internal/message"
+	"n.eko.moe/neko/internal/session"
+)
+
+func (h *MessageHandler) chat(id string, session *session.Session, payload *message.ChatRecieve) error {
+	if err := h.sessions.Brodcast(
+		message.ChatSend{
+			Event:   event.CHAT_MESSAGE,
+			Content: payload.Content,
+			ID:      id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.CONTROL_RELEASE)
+		return err
+	}
+	return nil
+}
+
+func (h *MessageHandler) chatEmoji(id string, session *session.Session, payload *message.EmojiRecieve) error {
+	if err := h.sessions.Brodcast(
+		message.EmojiSend{
+			Event: event.CHAT_MESSAGE,
+			Emoji: payload.Emoji,
+			ID:    id,
+		}, nil); err != nil {
+		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.CONTROL_RELEASE)
+		return err
+	}
+	return nil
+}

server/internal/websocket/control.go

@@ -20,8 +20,8 @@ func (h *MessageHandler) controlRelease(id string, session *session.Session) err
 	// tell everyone
 	if err := h.sessions.Brodcast(
 		message.Control{
-			Message: message.Message{Event: event.CONTROL_RELEASE},
-			ID:      id,
+			Event: event.CONTROL_RELEASE,
+			ID:    id,
 		}, nil); err != nil {
 		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.CONTROL_RELEASE)
 		return err
@@ -41,8 +41,8 @@ func (h *MessageHandler) controlRequest(id string, session *session.Session) err
 		// let everyone know
 		if err := h.sessions.Brodcast(
 			message.Control{
-				Message: message.Message{Event: event.CONTROL_LOCKED},
-				ID:      id,
+				Event: event.CONTROL_LOCKED,
+				ID:    id,
 			}, nil); err != nil {
 			h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.CONTROL_LOCKED)
 			return err
@@ -57,8 +57,8 @@ func (h *MessageHandler) controlRequest(id string, session *session.Session) err
 
 		// tell session there is a host
 		if err := session.Send(message.Control{
-			Message: message.Message{Event: event.CONTROL_REQUEST},
-			ID:      host.ID,
+			Event: event.CONTROL_REQUEST,
+			ID:    host.ID,
 		}); err != nil {
 			h.logger.Warn().Err(err).Str("id", id).Msgf("sending event %s has failed", event.CONTROL_REQUEST)
 			return err
@@ -66,8 +66,8 @@ func (h *MessageHandler) controlRequest(id string, session *session.Session) err
 
 		// tell host session wants to be host
 		if err := host.Send(message.Control{
-			Message: message.Message{Event: event.CONTROL_REQUESTING},
-			ID:      id,
+			Event: event.CONTROL_REQUESTING,
+			ID:    id,
 		}); err != nil {
 			h.logger.Warn().Err(err).Str("id", host.ID).Msgf("sending event %s has failed", event.CONTROL_REQUESTING)
 			return err

server/internal/websocket/handler.go

@@ -10,6 +10,8 @@ import (
 	"github.com/rs/zerolog/log"
 
 	"n.eko.moe/neko/internal/config"
+	"n.eko.moe/neko/internal/event"
+	"n.eko.moe/neko/internal/message"
 	"n.eko.moe/neko/internal/session"
 	"n.eko.moe/neko/internal/utils"
 	"n.eko.moe/neko/internal/webrtc"
@@ -31,6 +33,8 @@ func New(sessions *session.SessionManager, webrtc *webrtc.WebRTCManager, conf *c
 			logger:   logger.With().Str("subsystem", "handler").Logger(),
 			sessions: sessions,
 			webrtc:   webrtc,
+			banned:   make(map[string]bool),
+			locked:   false,
 		},
 	}
 }
@@ -106,12 +110,41 @@ func (ws *WebSocketHandler) Upgrade(w http.ResponseWriter, r *http.Request) erro
 	id, admin, err := ws.authenticate(r)
 	if err != nil {
 		ws.logger.Warn().Err(err).Msg("authenticatetion failed")
+
+		if err = socket.WriteJSON(message.Disconnect{
+			Event:   event.SYSTEM_DISCONNECT,
+			Message: "invalid password",
+		}); err != nil {
+			ws.logger.Error().Err(err).Msg("failed to send disconnect")
+		}
+
 		if err = socket.Close(); err != nil {
 			return err
 		}
 		return nil
 	}
 
+	ok, reason, err := ws.handler.SocketConnected(id, socket)
+	if err != nil {
+		ws.logger.Error().Err(err).Msg("connection failed")
+		return err
+	}
+
+	if !ok {
+		if err = socket.WriteJSON(message.Disconnect{
+			Event:   event.SYSTEM_DISCONNECT,
+			Message: reason,
+		}); err != nil {
+			ws.logger.Error().Err(err).Msg("failed to send disconnect")
+		}
+
+		if err = socket.Close(); err != nil {
+			return err
+		}
+
+		return nil
+	}
+
 	ws.sessions.New(id, admin, socket)
 
 	ws.logger.
@@ -128,14 +161,6 @@ func (ws *WebSocketHandler) Upgrade(w http.ResponseWriter, r *http.Request) erro
 			Msg("session ended")
 	}()
 
-	if err = ws.handler.SocketConnected(id, socket); err != nil {
-		ws.logger.Error().Err(err).Msg("connection failed")
-		if err = socket.Close(); err != nil {
-			return err
-		}
-		return nil
-	}
-
 	ws.handle(socket, id)
 	return nil
 }

server/internal/websocket/identity.go

@@ -9,6 +9,5 @@ func (h *MessageHandler) identityDetails(id string, session *session.Session, pa
 	if _, err := h.sessions.SetName(id, payload.Username); err != nil {
 		return err
 	}
-
 	return nil
 }

server/internal/websocket/messages.go

@@ -18,10 +18,20 @@ type MessageHandler struct {
 	logger   zerolog.Logger
 	sessions *session.SessionManager
 	webrtc   *webrtc.WebRTCManager
+	banned   map[string]bool
+	locked   bool
 }
 
-func (h *MessageHandler) SocketConnected(id string, socket *websocket.Conn) error {
-	return nil
+func (h *MessageHandler) SocketConnected(id string, socket *websocket.Conn) (bool, string, error) {
+	ok, banned := h.banned[socket.RemoteAddr().String()]
+	if ok && banned {
+		return false, "you are banned", nil
+	}
+
+	if h.locked {
+		return false, "stream is currently locked", nil
+	}
+	return true, "", nil
 }
 
 func (h *MessageHandler) SocketDisconnected(id string) error {
@@ -40,22 +50,69 @@ func (h *MessageHandler) Message(id string, raw []byte) error {
 	}
 
 	switch header.Event {
+	// Signal Events
 	case event.SIGNAL_PROVIDE:
 		payload := message.Signal{}
 		return errors.Wrapf(
 			utils.Unmarshal(&payload, raw, func() error {
 				return h.webrtc.CreatePeer(id, payload.SDP)
 			}), "%s failed", header.Event)
+	// Identity Events
 	case event.IDENTITY_DETAILS:
 		payload := &message.IdentityDetails{}
 		return errors.Wrapf(
 			utils.Unmarshal(payload, raw, func() error {
 				return h.identityDetails(id, session, payload)
 			}), "%s failed", header.Event)
+	// Control Events
 	case event.CONTROL_RELEASE:
 		return errors.Wrapf(h.controlRelease(id, session), "%s failed", header.Event)
 	case event.CONTROL_REQUEST:
 		return errors.Wrapf(h.controlRequest(id, session), "%s failed", header.Event)
+	// Chat Events
+	case event.CHAT_MESSAGE:
+		payload := &message.ChatRecieve{}
+		return errors.Wrapf(
+			utils.Unmarshal(payload, raw, func() error {
+				return h.chat(id, session, payload)
+			}), "%s failed", header.Event)
+	case event.CHAT_EMOJI:
+		payload := &message.EmojiRecieve{}
+		return errors.Wrapf(
+			utils.Unmarshal(payload, raw, func() error {
+				return h.chatEmoji(id, session, payload)
+			}), "%s failed", header.Event)
+	// Admin Events
+	case event.ADMIN_LOCK:
+		return errors.Wrapf(h.adminLock(id, session), "%s failed", header.Event)
+	case event.ADMIN_FORCE_CONTROL:
+		return errors.Wrapf(h.adminControl(id, session), "%s failed", header.Event)
+	case event.ADMIN_FORCE_RELEASE:
+		return errors.Wrapf(h.adminRelease(id, session), "%s failed", header.Event)
+	case event.ADMIN_BAN:
+		payload := &message.Admin{}
+		return errors.Wrapf(
+			utils.Unmarshal(payload, raw, func() error {
+				return h.adminBan(id, session, payload)
+			}), "%s failed", header.Event)
+	case event.ADMIN_KICK:
+		payload := &message.Admin{}
+		return errors.Wrapf(
+			utils.Unmarshal(payload, raw, func() error {
+				return h.adminKick(id, session, payload)
+			}), "%s failed", header.Event)
+	case event.ADMIN_MUTE:
+		payload := &message.Admin{}
+		return errors.Wrapf(
+			utils.Unmarshal(payload, raw, func() error {
+				return h.adminMute(id, session, payload)
+			}), "%s failed", header.Event)
+	case event.ADMIN_UNMUTE:
+		payload := &message.Admin{}
+		return errors.Wrapf(
+			utils.Unmarshal(payload, raw, func() error {
+				return h.adminUnmute(id, session, payload)
+			}), "%s failed", header.Event)
 	default:
 		return errors.Errorf("unknown message event %s", header.Event)
 	}

server/internal/websocket/session.go

@@ -8,8 +8,8 @@ import (
 
 func (h *MessageHandler) SessionCreated(id string, session *session.Session) error {
 	if err := session.Send(message.Identity{
-		Message: message.Message{Event: event.IDENTITY_PROVIDE},
-		ID:      id,
+		Event: event.IDENTITY_PROVIDE,
+		ID:    id,
 	}); err != nil {
 		return err
 	}
@@ -19,8 +19,8 @@ func (h *MessageHandler) SessionCreated(id string, session *session.Session) err
 
 func (h *MessageHandler) SessionConnected(id string, session *session.Session) error {
 	// send list of members to session
-	if err := session.Send(message.Members{
-		Message:  message.Message{Event: event.MEMBER_LIST},
+	if err := session.Send(message.MembersList{
+		Event:    event.MEMBER_LIST,
 		Memebers: h.sessions.GetConnected(),
 	}); err != nil {
 		h.logger.Warn().Str("id", id).Err(err).Msgf("sending event %s has failed", event.MEMBER_LIST)
@@ -31,8 +31,8 @@ func (h *MessageHandler) SessionConnected(id string, session *session.Session) e
 	host, ok := h.sessions.GetHost()
 	if ok {
 		if err := session.Send(message.Control{
-			Message: message.Message{Event: event.CONTROL_LOCKED},
-			ID:      host.ID,
+			Event: event.CONTROL_LOCKED,
+			ID:    host.ID,
 		}); err != nil {
 			h.logger.Warn().Str("id", id).Err(err).Msgf("sending event %s has failed", event.CONTROL_LOCKED)
 			return err
@@ -42,7 +42,7 @@ func (h *MessageHandler) SessionConnected(id string, session *session.Session) e
 	// let everyone know there is a new session
 	if err := h.sessions.Brodcast(
 		message.Member{
-			Message: message.Message{Event: event.MEMBER_CONNECTED},
+			Event:   event.MEMBER_CONNECTED,
 			Session: session,
 		}, nil); err != nil {
 		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.CONTROL_RELEASE)
@@ -57,8 +57,8 @@ func (h *MessageHandler) SessionDestroyed(id string) error {
 	if h.sessions.IsHost(id) {
 		h.sessions.ClearHost()
 		if err := h.sessions.Brodcast(message.Control{
-			Message: message.Message{Event: event.CONTROL_RELEASE},
-			ID:      id,
+			Event: event.CONTROL_RELEASE,
+			ID:    id,
 		}, nil); err != nil {
 			h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.CONTROL_RELEASE)
 		}
@@ -67,8 +67,8 @@ func (h *MessageHandler) SessionDestroyed(id string) error {
 	// let everyone know session disconnected
 	if err := h.sessions.Brodcast(
 		message.MemberDisconnected{
-			Message: message.Message{Event: event.MEMBER_DISCONNECTED},
-			ID:      id,
+			Event: event.MEMBER_DISCONNECTED,
+			ID:    id,
 		}, nil); err != nil {
 		h.logger.Warn().Err(err).Msgf("brodcasting event %s has failed", event.MEMBER_DISCONNECTED)
 		return err