Event refactor

event/event.go

@@ -2,15 +2,24 @@ package event
 
 type EventType string
 
+func (e EventType) String() string {
+	return string(e)
+}
+
 const INSTANCE_VIEWPORT_RESIZE EventType = "instance viewport resize"
 const INSTANCE_DELETE EventType = "instance delete"
 const INSTANCE_NEW EventType = "instance new"
+const INSTANCE_STATS EventType = "instance stats"
+const INSTANCE_TERMINAL_OUT EventType = "instance terminal out"
 const SESSION_END EventType = "session end"
 const SESSION_READY EventType = "session ready"
+const SESSION_BUILDER_OUT EventType = "session builder out"
 
-type Handler func(args ...interface{})
+type Handler func(sessionId string, args ...interface{})
+type AnyHandler func(eventType EventType, sessionId string, args ...interface{})
 
 type EventApi interface {
-	Emit(name EventType, args ...interface{})
+	Emit(name EventType, sessionId string, args ...interface{})
 	On(name EventType, handler Handler)
+	OnAny(handler AnyHandler)
 }

event/local_broker.go

@@ -5,11 +5,12 @@ import "sync"
 type localBroker struct {
 	sync.Mutex
 
-	handlers map[EventType][]Handler
+	handlers    map[EventType][]Handler
+	anyHandlers []AnyHandler
 }
 
 func NewLocalBroker() *localBroker {
-	return &localBroker{handlers: map[EventType][]Handler{}}
+	return &localBroker{handlers: map[EventType][]Handler{}, anyHandlers: []AnyHandler{}}
 }
 
 func (b *localBroker) On(name EventType, handler Handler) {
@@ -22,13 +23,25 @@ func (b *localBroker) On(name EventType, handler Handler) {
 	b.handlers[name] = append(b.handlers[name], handler)
 }
 
-func (b *localBroker) Emit(name EventType, args ...interface{}) {
+func (b *localBroker) OnAny(handler AnyHandler) {
 	b.Lock()
 	defer b.Unlock()
 
-	if b.handlers[name] != nil {
-		for _, handler := range b.handlers[name] {
-			handler(args...)
-		}
-	}
+	b.anyHandlers = append(b.anyHandlers, handler)
+}
+
+func (b *localBroker) Emit(name EventType, sessionId string, args ...interface{}) {
+	go func() {
+		b.Lock()
+		defer b.Unlock()
+
+		for _, handler := range b.anyHandlers {
+			handler(name, sessionId, args...)
+		}
+		if b.handlers[name] != nil {
+			for _, handler := range b.handlers[name] {
+				handler(sessionId, args...)
+			}
+		}
+	}()
 }

event/local_broker_test.go

@@ -7,25 +7,54 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestLocalBroker(t *testing.T) {
+func TestLocalBroker_On(t *testing.T) {
 	broker := NewLocalBroker()
 
 	called := 0
+	receivedSessionId := ""
 	receivedArgs := []interface{}{}
 
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 
-	broker.On(INSTANCE_NEW, func(args ...interface{}) {
+	broker.On(INSTANCE_NEW, func(sessionId string, args ...interface{}) {
 		called++
+		receivedSessionId = sessionId
 		receivedArgs = args
 		wg.Done()
 	})
-	broker.Emit(SESSION_READY)
-	broker.Emit(INSTANCE_NEW, "foo", "bar")
+	broker.Emit(SESSION_READY, "1")
+	broker.Emit(INSTANCE_NEW, "2", "foo", "bar")
 
 	wg.Wait()
 
 	assert.Equal(t, 1, called)
+	assert.Equal(t, "2", receivedSessionId)
 	assert.Equal(t, []interface{}{"foo", "bar"}, receivedArgs)
 }
+
+func TestLocalBroker_OnAny(t *testing.T) {
+	broker := NewLocalBroker()
+
+	var receivedEvent EventType
+	receivedSessionId := ""
+	receivedArgs := []interface{}{}
+
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+
+	broker.OnAny(func(eventType EventType, sessionId string, args ...interface{}) {
+		receivedSessionId = sessionId
+		receivedArgs = args
+		receivedEvent = eventType
+		wg.Done()
+	})
+	broker.Emit(SESSION_READY, "1")
+
+	wg.Wait()
+
+	var expectedArgs []interface{}
+	assert.Equal(t, SESSION_READY, receivedEvent)
+	assert.Equal(t, "1", receivedSessionId)
+	assert.Equal(t, expectedArgs, receivedArgs)
+}