major refactor.

internal/session/manager.go

@@ -9,26 +9,26 @@ import (
 	"demodesk/neko/internal/utils"
 )
 
-func New(remote types.RemoteManager) *SessionManager {
-	return &SessionManager{
+func New(capture types.CaptureManager) *SessionManagerCtx {
+	return &SessionManagerCtx{
 		logger:  log.With().Str("module", "session").Logger(),
 		host:    nil,
-		remote:  remote,
-		members: make(map[string]*Session),
+		capture: capture,
+		members: make(map[string]*SessionCtx),
 		emmiter: events.New(),
 	}
 }
 
-type SessionManager struct {
+type SessionManagerCtx struct {
 	logger  zerolog.Logger
 	host    types.Session
-	remote  types.RemoteManager
-	members map[string]*Session
+	capture types.CaptureManager
+	members map[string]*SessionCtx
 	emmiter events.EventEmmiter
 }
 
-func (manager *SessionManager) New(id string, admin bool, socket types.WebSocket) types.Session {
-	session := &Session{
+func (manager *SessionManagerCtx) New(id string, admin bool, socket types.WebSocket) types.Session {
+	session := &SessionCtx{
 		id:        id,
 		admin:     admin,
 		manager:   manager,
@@ -40,80 +40,31 @@ func (manager *SessionManager) New(id string, admin bool, socket types.WebSocket
 	manager.members[id] = session
 	manager.emmiter.Emit("created", session)
 
-	if !manager.remote.Streaming() && len(manager.members) > 0 {
-		manager.remote.StartStream()
+	if !manager.capture.Streaming() && len(manager.members) > 0 {
+		manager.capture.StartStream()
 	}
 
 	return session
 }
 
-func (manager *SessionManager) HasHost() bool {
-	return manager.host != nil
-}
-
-func (manager *SessionManager) SetHost(host types.Session) {
-	manager.host = host
-	manager.emmiter.Emit("host", host)
-}
-
-func (manager *SessionManager) GetHost() types.Session {
-	return manager.host
-}
-
-func (manager *SessionManager) ClearHost() {
-	host := manager.host
-	manager.host = nil
-	manager.emmiter.Emit("host_cleared", host)
-}
-
-func (manager *SessionManager) Has(id string) bool {
-	_, ok := manager.members[id]
-	return ok
-}
-
-func (manager *SessionManager) Get(id string) (types.Session, bool) {
+func (manager *SessionManagerCtx) Get(id string) (types.Session, bool) {
 	session, ok := manager.members[id]
 	return session, ok
 }
 
-func (manager *SessionManager) Admins() []*types.Member {
-	members := []*types.Member{}
-	for _, session := range manager.members {
-		if !session.connected || !session.admin {
-			continue
-		}
-
-		member := session.Member()
-		if member != nil {
-			members = append(members, member)
-		}
-	}
-	return members
+func (manager *SessionManagerCtx) Has(id string) bool {
+	_, ok := manager.members[id]
+	return ok
 }
 
-func (manager *SessionManager) Members() []*types.Member {
-	members := []*types.Member{}
-	for _, session := range manager.members {
-		if !session.connected {
-			continue
-		}
-
-		member := session.Member()
-		if member != nil {
-			members = append(members, member)
-		}
-	}
-	return members
-}
-
-func (manager *SessionManager) Destroy(id string) error {
+func (manager *SessionManagerCtx) Destroy(id string) error {
 	session, ok := manager.members[id]
 	if ok {
 		delete(manager.members, id)
 		err := session.destroy()
 
-		if !manager.remote.Streaming() && len(manager.members) <= 0 {
-			manager.remote.StopStream()
+		if !manager.capture.Streaming() && len(manager.members) <= 0 {
+			manager.capture.StopStream()
 		}
 
 		manager.emmiter.Emit("destroy", id)
@@ -123,7 +74,58 @@ func (manager *SessionManager) Destroy(id string) error {
 	return nil
 }
 
-func (manager *SessionManager) Broadcast(v interface{}, exclude interface{}) error {
+// ---
+// host
+// ---
+func (manager *SessionManagerCtx) HasHost() bool {
+	return manager.host != nil
+}
+
+func (manager *SessionManagerCtx) SetHost(host types.Session) {
+	manager.host = host
+	manager.emmiter.Emit("host", host)
+}
+
+func (manager *SessionManagerCtx) GetHost() types.Session {
+	return manager.host
+}
+
+func (manager *SessionManagerCtx) ClearHost() {
+	host := manager.host
+	manager.host = nil
+	manager.emmiter.Emit("host_cleared", host)
+}
+
+// ---
+// members list
+// ---
+func (manager *SessionManagerCtx) Admins() []types.Session {
+	var sessions []types.Session
+	for _, session := range manager.members {
+		if !session.connected || !session.admin {
+			continue
+		}
+
+		sessions = append(sessions, session)
+	}
+
+	return sessions
+}
+
+func (manager *SessionManagerCtx) Members() []types.Session {
+	var sessions []types.Session
+	for _, session := range manager.members {
+		if !session.connected {
+			continue
+		}
+
+		sessions = append(sessions, session)
+	}
+
+	return sessions
+}
+
+func (manager *SessionManagerCtx) Broadcast(v interface{}, exclude interface{}) error {
 	for id, session := range manager.members {
 		if !session.connected {
 			continue
@@ -142,32 +144,35 @@ func (manager *SessionManager) Broadcast(v interface{}, exclude interface{}) err
 	return nil
 }
 
-func (manager *SessionManager) OnHost(listener func(session types.Session)) {
+// ---
+// events
+// ---
+func (manager *SessionManagerCtx) OnHost(listener func(session types.Session)) {
 	manager.emmiter.On("host", func(payload ...interface{}) {
-		listener(payload[0].(*Session))
+		listener(payload[0].(*SessionCtx))
 	})
 }
 
-func (manager *SessionManager) OnHostCleared(listener func(session types.Session)) {
+func (manager *SessionManagerCtx) OnHostCleared(listener func(session types.Session)) {
 	manager.emmiter.On("host_cleared", func(payload ...interface{}) {
-		listener(payload[0].(*Session))
+		listener(payload[0].(*SessionCtx))
 	})
 }
 
-func (manager *SessionManager) OnDestroy(listener func(id string)) {
+func (manager *SessionManagerCtx) OnDestroy(listener func(id string)) {
 	manager.emmiter.On("destroy", func(payload ...interface{}) {
 		listener(payload[0].(string))
 	})
 }
 
-func (manager *SessionManager) OnCreated(listener func(session types.Session)) {
+func (manager *SessionManagerCtx) OnCreated(listener func(session types.Session)) {
 	manager.emmiter.On("created", func(payload ...interface{}) {
-		listener(payload[0].(*Session))
+		listener(payload[0].(*SessionCtx))
 	})
 }
 
-func (manager *SessionManager) OnConnected(listener func(session types.Session)) {
+func (manager *SessionManagerCtx) OnConnected(listener func(session types.Session)) {
 	manager.emmiter.On("connected", func(payload ...interface{}) {
-		listener(payload[0].(*Session))
+		listener(payload[0].(*SessionCtx))
 	})
 }

internal/session/session.go

@@ -8,43 +8,43 @@ import (
 	"demodesk/neko/internal/types/message"
 )
 
-type Session struct {
+type SessionCtx struct {
 	logger    zerolog.Logger
 	id        string
 	name      string
 	admin     bool
 	muted     bool
 	connected bool
-	manager   *SessionManager
+	manager   *SessionManagerCtx
 	socket    types.WebSocket
 	peer      types.Peer
 }
 
-func (session *Session) ID() string {
+func (session *SessionCtx) ID() string {
 	return session.id
 }
 
-func (session *Session) Name() string {
+func (session *SessionCtx) Name() string {
 	return session.name
 }
 
-func (session *Session) Admin() bool {
+func (session *SessionCtx) Admin() bool {
 	return session.admin
 }
 
-func (session *Session) Muted() bool {
+func (session *SessionCtx) Muted() bool {
 	return session.muted
 }
 
-func (session *Session) IsHost() bool {
+func (session *SessionCtx) IsHost() bool {
 	return session.manager.host != nil && session.manager.host.ID() == session.ID()
 }
 
-func (session *Session) Connected() bool {
+func (session *SessionCtx) Connected() bool {
 	return session.connected
 }
 
-func (session *Session) Address() string {
+func (session *SessionCtx) Address() string {
 	if session.socket == nil {
 		return ""
 	}
@@ -52,41 +52,33 @@ func (session *Session) Address() string {
 	return session.socket.Address()
 }
 
-func (session *Session) Member() *types.Member {
-	return &types.Member{
-		ID:    session.id,
-		Name:  session.name,
-		Admin: session.admin,
-		Muted: session.muted,
-	}
-}
-
-func (session *Session) SetMuted(muted bool) {
+func (session *SessionCtx) SetMuted(muted bool) {
 	session.muted = muted
 }
 
-func (session *Session) SetName(name string) {
+func (session *SessionCtx) SetName(name string) {
 	session.name = name
 }
 
-func (session *Session) SetSocket(socket types.WebSocket) {
+func (session *SessionCtx) SetSocket(socket types.WebSocket) {
 	session.socket = socket
 }
 
-func (session *Session) SetPeer(peer types.Peer) {
+func (session *SessionCtx) SetPeer(peer types.Peer) {
 	session.peer = peer
 }
 
-func (session *Session) SetConnected() {
+func (session *SessionCtx) SetConnected() {
 	session.connected = true
 	session.manager.emmiter.Emit("connected", session)
 }
 
-func (session *Session) Disconnect(reason string) error {
+func (session *SessionCtx) Disconnect(reason string) error {
 	if session.socket == nil {
 		return nil
 	}
 
+	// TODO: Refcator
 	if err := session.socket.Send(&message.Disconnect{
 		Event:   event.SYSTEM_DISCONNECT,
 		Message: reason,
@@ -97,7 +89,7 @@ func (session *Session) Disconnect(reason string) error {
 	return session.manager.Destroy(session.id)
 }
 
-func (session *Session) Send(v interface{}) error {
+func (session *SessionCtx) Send(v interface{}) error {
 	if session.socket == nil {
 		return nil
 	}
@@ -105,7 +97,7 @@ func (session *Session) Send(v interface{}) error {
 	return session.socket.Send(v)
 }
 
-func (session *Session) SignalAnswer(sdp string) error {
+func (session *SessionCtx) SignalAnswer(sdp string) error {
 	if session.peer == nil {
 		return nil
 	}
@@ -113,7 +105,7 @@ func (session *Session) SignalAnswer(sdp string) error {
 	return session.peer.SignalAnswer(sdp)
 }
 
-func (session *Session) destroy() error {
+func (session *SessionCtx) destroy() error {
 	if session.socket != nil {
 		if err := session.socket.Destroy(); err != nil {
 			return err