Implement pub/sub message hub as a base for #44

msghub/hub.go

@@ -0,0 +1,116 @@
+package msghub
+
+import (
+	"container/ring"
+	"context"
+	"sync"
+	"time"
+)
+
+// Message contains the basic header data for a message
+type Message struct {
+	Mailbox string
+	ID      string
+	From    string
+	To      []string
+	Subject string
+	Date    time.Time
+	Size    int64
+}
+
+// Listener receives the contents of the log, followed by new messages
+type Listener interface {
+	Receive(msg Message) error
+}
+
+// Hub relays messages on to its listeners
+type Hub struct {
+	// log stores history, points next spot to write.  First non-nil entry is oldest Message
+	log   *ring.Ring
+	logMx sync.RWMutex
+
+	// listeners interested in new messages
+	listeners   map[Listener]struct{}
+	listenersMx sync.RWMutex
+
+	// broadcast receives new messages
+	broadcast chan Message
+}
+
+// New constructs a new Hub which will cache logSize messages in memory for playback to future
+// listeners.  A goroutine is created to handle incoming messages; it will run until the provided
+// context is canceled.
+func New(ctx context.Context, logSize int) *Hub {
+	h := &Hub{
+		log:       ring.New(logSize),
+		listeners: make(map[Listener]struct{}),
+		broadcast: make(chan Message, 100),
+	}
+
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				// Shutdown
+				close(h.broadcast)
+				h.broadcast = nil
+				return
+			case msg := <-h.broadcast:
+				// Log message
+				h.logMx.Lock()
+				h.log.Value = msg
+				h.log = h.log.Next()
+				h.logMx.Unlock()
+				// Deliver message to listeners
+				h.deliver(msg)
+			}
+		}
+	}()
+
+	return h
+}
+
+// Broadcast queues a message for processing by the hub.  The message will be placed into the
+// in-memory log and relayed to all registered listeners.
+func (h *Hub) Broadcast(msg Message) {
+	if h.broadcast != nil {
+		h.broadcast <- msg
+	}
+}
+
+// AddListener registers a listener to receive broadcasted messages.
+func (h *Hub) AddListener(l Listener) {
+	// Playback log
+	h.logMx.RLock()
+	h.log.Do(func(v interface{}) {
+		if v != nil {
+			l.Receive(v.(Message))
+		}
+	})
+	h.logMx.RUnlock()
+
+	// Add to listeners
+	h.listenersMx.Lock()
+	h.listeners[l] = struct{}{}
+	h.listenersMx.Unlock()
+}
+
+// RemoveListener deletes a listener registration, it will cease to receive messages.
+func (h *Hub) RemoveListener(l Listener) {
+	h.listenersMx.Lock()
+	defer h.listenersMx.Unlock()
+	if _, ok := h.listeners[l]; ok {
+		delete(h.listeners, l)
+	}
+}
+
+// deliver message to all listeners, removing listeners if they return an error
+func (h *Hub) deliver(msg Message) {
+	h.listenersMx.RLock()
+	defer h.listenersMx.RUnlock()
+	for l := range h.listeners {
+		if err := l.Receive(msg); err != nil {
+			h.RemoveListener(l)
+		}
+	}
+}