Server Event Optimizations (#116)
This commit is contained in:
Matthew Penner
GitHub
170
events/events.go
170
events/events.go
@@ -1,32 +1,79 @@
|
||||
package events
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/gammazero/workerpool"
|
||||
)
|
||||
|
||||
type Listener chan Event
|
||||
|
||||
// Event represents an Event sent over a Bus.
|
||||
type Event struct {
|
||||
Data string
|
||||
Topic string
|
||||
Data interface{}
|
||||
}
|
||||
|
||||
type EventBus struct {
|
||||
mu sync.RWMutex
|
||||
pools map[string]*CallbackPool
|
||||
// Bus represents an Event Bus.
|
||||
type Bus struct {
|
||||
listenersMx sync.Mutex
|
||||
listeners map[string][]Listener
|
||||
}
|
||||
|
||||
func New() *EventBus {
|
||||
return &EventBus{
|
||||
pools: make(map[string]*CallbackPool),
|
||||
// NewBus returns a new empty Event Bus.
|
||||
func NewBus() *Bus {
|
||||
return &Bus{
|
||||
listeners: make(map[string][]Listener),
|
||||
}
|
||||
}
|
||||
|
||||
// Publish data to a given topic.
|
||||
func (e *EventBus) Publish(topic string, data string) {
|
||||
t := topic
|
||||
// Off unregisters a listener from the specified topics on the Bus.
|
||||
func (b *Bus) Off(listener Listener, topics ...string) {
|
||||
b.listenersMx.Lock()
|
||||
defer b.listenersMx.Unlock()
|
||||
|
||||
for _, topic := range topics {
|
||||
b.off(topic, listener)
|
||||
}
|
||||
}
|
||||
|
||||
func (b *Bus) off(topic string, listener Listener) bool {
|
||||
listeners, ok := b.listeners[topic]
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
for i, l := range listeners {
|
||||
if l != listener {
|
||||
continue
|
||||
}
|
||||
|
||||
listeners = append(listeners[:i], listeners[i+1:]...)
|
||||
b.listeners[topic] = listeners
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// On registers a listener to the specified topics on the Bus.
|
||||
func (b *Bus) On(listener Listener, topics ...string) {
|
||||
b.listenersMx.Lock()
|
||||
defer b.listenersMx.Unlock()
|
||||
|
||||
for _, topic := range topics {
|
||||
b.on(topic, listener)
|
||||
}
|
||||
}
|
||||
|
||||
func (b *Bus) on(topic string, listener Listener) {
|
||||
listeners, ok := b.listeners[topic]
|
||||
if !ok {
|
||||
b.listeners[topic] = []Listener{listener}
|
||||
} else {
|
||||
b.listeners[topic] = append(listeners, listener)
|
||||
}
|
||||
}
|
||||
|
||||
// Publish publishes a message to the Bus.
|
||||
func (b *Bus) Publish(topic string, data interface{}) {
|
||||
// Some of our topics for the socket support passing a more specific namespace,
|
||||
// such as "backup completed:1234" to indicate which specific backup was completed.
|
||||
//
|
||||
@@ -36,87 +83,44 @@ func (e *EventBus) Publish(topic string, data string) {
|
||||
parts := strings.SplitN(topic, ":", 2)
|
||||
|
||||
if len(parts) == 2 {
|
||||
t = parts[0]
|
||||
topic = parts[0]
|
||||
}
|
||||
}
|
||||
|
||||
e.mu.RLock()
|
||||
defer e.mu.RUnlock()
|
||||
b.listenersMx.Lock()
|
||||
defer b.listenersMx.Unlock()
|
||||
|
||||
// Acquire a read lock and loop over all the channels registered for the topic. This
|
||||
// avoids a panic crash if the process tries to unregister the channel while this routine
|
||||
// is running.
|
||||
if cp, ok := e.pools[t]; ok {
|
||||
for _, callback := range cp.callbacks {
|
||||
c := *callback
|
||||
evt := Event{Data: data, Topic: topic}
|
||||
// Using the workerpool with one worker allows us to execute events in a FIFO manner. Running
|
||||
// this using goroutines would cause things such as console output to just output in random order
|
||||
// if more than one event is fired at the same time.
|
||||
//
|
||||
// However, the pool submission does not block the execution of this function itself, allowing
|
||||
// us to call publish without blocking any of the other pathways.
|
||||
//
|
||||
// @see https://github.com/pterodactyl/panel/issues/2303
|
||||
cp.pool.Submit(func() {
|
||||
c(evt)
|
||||
})
|
||||
}
|
||||
listeners, ok := b.listeners[topic]
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
// PublishJson publishes a JSON message to a given topic.
|
||||
func (e *EventBus) PublishJson(topic string, data interface{}) error {
|
||||
b, err := json.Marshal(data)
|
||||
if err != nil {
|
||||
return err
|
||||
if len(listeners) < 1 {
|
||||
return
|
||||
}
|
||||
|
||||
e.Publish(topic, string(b))
|
||||
|
||||
return nil
|
||||
var wg sync.WaitGroup
|
||||
event := Event{Topic: topic, Data: data}
|
||||
for _, listener := range listeners {
|
||||
l := listener
|
||||
wg.Add(1)
|
||||
go func(l Listener, event Event) {
|
||||
defer wg.Done()
|
||||
l <- event
|
||||
}(l, event)
|
||||
}
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
// On adds a callback function that will be executed each time one of the events using the topic
|
||||
// name is called.
|
||||
func (e *EventBus) On(topic string, callback *func(Event)) {
|
||||
e.mu.Lock()
|
||||
defer e.mu.Unlock()
|
||||
// Destroy destroys the Event Bus by unregistering and closing all listeners.
|
||||
func (b *Bus) Destroy() {
|
||||
b.listenersMx.Lock()
|
||||
defer b.listenersMx.Unlock()
|
||||
|
||||
// Check if this topic has been registered at least once for the event listener, and if
|
||||
// not create an empty struct for the topic.
|
||||
if _, exists := e.pools[topic]; !exists {
|
||||
e.pools[topic] = &CallbackPool{
|
||||
callbacks: make([]*func(Event), 0),
|
||||
pool: workerpool.New(1),
|
||||
for _, listeners := range b.listeners {
|
||||
for _, listener := range listeners {
|
||||
close(listener)
|
||||
}
|
||||
}
|
||||
|
||||
// If this callback is not already registered as an event listener, go ahead and append
|
||||
// it to the array of callbacks for this topic.
|
||||
e.pools[topic].Add(callback)
|
||||
}
|
||||
|
||||
// Off removes an event listener from the bus.
|
||||
func (e *EventBus) Off(topic string, callback *func(Event)) {
|
||||
e.mu.Lock()
|
||||
defer e.mu.Unlock()
|
||||
|
||||
if cp, ok := e.pools[topic]; ok {
|
||||
cp.Remove(callback)
|
||||
}
|
||||
}
|
||||
|
||||
// Destroy removes all the event listeners that have been registered for any topic. Also stops the worker
|
||||
// pool to close that routine.
|
||||
func (e *EventBus) Destroy() {
|
||||
e.mu.Lock()
|
||||
defer e.mu.Unlock()
|
||||
|
||||
// Stop every pool that exists for a given callback topic.
|
||||
for _, cp := range e.pools {
|
||||
cp.pool.Stop()
|
||||
}
|
||||
|
||||
e.pools = make(map[string]*CallbackPool)
|
||||
b.listeners = make(map[string][]Listener)
|
||||
}
|
||||
|
||||
180
events/events_test.go
Normal file
180
events/events_test.go
Normal file
@@ -0,0 +1,180 @@
|
||||
package events
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
. "github.com/franela/goblin"
|
||||
)
|
||||
|
||||
func TestNewBus(t *testing.T) {
|
||||
g := Goblin(t)
|
||||
bus := NewBus()
|
||||
|
||||
g.Describe("NewBus", func() {
|
||||
g.It("is not nil", func() {
|
||||
g.Assert(bus).IsNotNil("Bus expected to not be nil")
|
||||
g.Assert(bus.listeners).IsNotNil("Bus#listeners expected to not be nil")
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
func TestBus_Off(t *testing.T) {
|
||||
g := Goblin(t)
|
||||
|
||||
const topic = "test"
|
||||
|
||||
g.Describe("Off", func() {
|
||||
g.It("unregisters listener", func() {
|
||||
bus := NewBus()
|
||||
|
||||
g.Assert(bus.listeners[topic]).IsNotNil()
|
||||
g.Assert(len(bus.listeners[topic])).IsZero()
|
||||
listener := make(chan Event)
|
||||
bus.On(listener, topic)
|
||||
g.Assert(len(bus.listeners[topic])).Equal(1, "Listener was not registered")
|
||||
|
||||
bus.Off(listener, topic)
|
||||
g.Assert(len(bus.listeners[topic])).Equal(0, "Topic still has one or more listeners")
|
||||
|
||||
close(listener)
|
||||
})
|
||||
|
||||
g.It("unregisters correct listener", func() {
|
||||
bus := NewBus()
|
||||
|
||||
listener := make(chan Event)
|
||||
listener2 := make(chan Event)
|
||||
listener3 := make(chan Event)
|
||||
bus.On(listener, topic)
|
||||
bus.On(listener2, topic)
|
||||
bus.On(listener3, topic)
|
||||
g.Assert(len(bus.listeners[topic])).Equal(3, "Listeners were not registered")
|
||||
|
||||
bus.Off(listener, topic)
|
||||
bus.Off(listener3, topic)
|
||||
g.Assert(len(bus.listeners[topic])).Equal(1, "Expected 1 listener to remain")
|
||||
|
||||
if bus.listeners[topic][0] != listener2 {
|
||||
// A normal Assert does not properly compare channels.
|
||||
g.Fail("wrong listener unregistered")
|
||||
}
|
||||
|
||||
// Cleanup
|
||||
bus.Off(listener2, topic)
|
||||
close(listener)
|
||||
close(listener2)
|
||||
close(listener3)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
func TestBus_On(t *testing.T) {
|
||||
g := Goblin(t)
|
||||
|
||||
const topic = "test"
|
||||
|
||||
g.Describe("On", func() {
|
||||
g.It("registers listener", func() {
|
||||
bus := NewBus()
|
||||
|
||||
g.Assert(bus.listeners[topic]).IsNotNil()
|
||||
g.Assert(len(bus.listeners[topic])).IsZero()
|
||||
listener := make(chan Event)
|
||||
bus.On(listener, topic)
|
||||
g.Assert(len(bus.listeners[topic])).Equal(1, "Listener was not registered")
|
||||
|
||||
if bus.listeners[topic][0] != listener {
|
||||
// A normal Assert does not properly compare channels.
|
||||
g.Fail("wrong listener registered")
|
||||
}
|
||||
|
||||
// Cleanup
|
||||
bus.Off(listener, topic)
|
||||
close(listener)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
func TestBus_Publish(t *testing.T) {
|
||||
g := Goblin(t)
|
||||
|
||||
const topic = "test"
|
||||
const message = "this is a test message!"
|
||||
|
||||
g.Describe("Publish", func() {
|
||||
g.It("publishes message", func() {
|
||||
bus := NewBus()
|
||||
|
||||
g.Assert(bus.listeners[topic]).IsNotNil()
|
||||
g.Assert(len(bus.listeners[topic])).IsZero()
|
||||
listener := make(chan Event)
|
||||
bus.On(listener, topic)
|
||||
g.Assert(len(bus.listeners[topic])).Equal(1, "Listener was not registered")
|
||||
|
||||
done := make(chan struct{}, 1)
|
||||
go func() {
|
||||
select {
|
||||
case m := <-listener:
|
||||
g.Assert(m.Topic).Equal(topic)
|
||||
g.Assert(m.Data).Equal(message)
|
||||
case <-time.After(1 * time.Second):
|
||||
g.Fail("listener did not receive message in time")
|
||||
}
|
||||
done <- struct{}{}
|
||||
}()
|
||||
bus.Publish(topic, message)
|
||||
<-done
|
||||
|
||||
// Cleanup
|
||||
close(listener)
|
||||
bus.Off(listener, topic)
|
||||
})
|
||||
|
||||
g.It("publishes message to all listeners", func() {
|
||||
bus := NewBus()
|
||||
|
||||
g.Assert(bus.listeners[topic]).IsNotNil()
|
||||
g.Assert(len(bus.listeners[topic])).IsZero()
|
||||
listener := make(chan Event)
|
||||
listener2 := make(chan Event)
|
||||
listener3 := make(chan Event)
|
||||
bus.On(listener, topic)
|
||||
bus.On(listener2, topic)
|
||||
bus.On(listener3, topic)
|
||||
g.Assert(len(bus.listeners[topic])).Equal(3, "Listener was not registered")
|
||||
|
||||
done := make(chan struct{}, 1)
|
||||
go func() {
|
||||
for i := 0; i < 3; i++ {
|
||||
select {
|
||||
case m := <-listener:
|
||||
g.Assert(m.Topic).Equal(topic)
|
||||
g.Assert(m.Data).Equal(message)
|
||||
case m := <-listener2:
|
||||
g.Assert(m.Topic).Equal(topic)
|
||||
g.Assert(m.Data).Equal(message)
|
||||
case m := <-listener3:
|
||||
g.Assert(m.Topic).Equal(topic)
|
||||
g.Assert(m.Data).Equal(message)
|
||||
case <-time.After(1 * time.Second):
|
||||
g.Fail("all listeners did not receive the message in time")
|
||||
i = 3
|
||||
}
|
||||
}
|
||||
|
||||
done <- struct{}{}
|
||||
}()
|
||||
bus.Publish(topic, message)
|
||||
<-done
|
||||
|
||||
// Cleanup
|
||||
bus.Off(listener, topic)
|
||||
bus.Off(listener2, topic)
|
||||
bus.Off(listener3, topic)
|
||||
close(listener)
|
||||
close(listener2)
|
||||
close(listener3)
|
||||
})
|
||||
})
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
package events
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
|
||||
"github.com/gammazero/workerpool"
|
||||
)
|
||||
|
||||
type CallbackPool struct {
|
||||
callbacks []*func(Event)
|
||||
pool *workerpool.WorkerPool
|
||||
}
|
||||
|
||||
// Pushes a new callback into the array of listeners for the pool.
|
||||
func (cp *CallbackPool) Add(callback *func(Event)) {
|
||||
if cp.index(reflect.ValueOf(callback)) < 0 {
|
||||
cp.callbacks = append(cp.callbacks, callback)
|
||||
}
|
||||
}
|
||||
|
||||
// Removes a callback from the array of registered callbacks if it exists.
|
||||
func (cp *CallbackPool) Remove(callback *func(Event)) {
|
||||
i := cp.index(reflect.ValueOf(callback))
|
||||
|
||||
// If i < 0 it means there was no index found for the given callback, meaning it was
|
||||
// never registered or was already unregistered from the listeners. Also double check
|
||||
// that we didn't somehow escape the length of the topic callback (not sure how that
|
||||
// would happen, but lets avoid a panic condition).
|
||||
if i < 0 || i >= len(cp.callbacks) {
|
||||
return
|
||||
}
|
||||
|
||||
// We can assume that the topic still exists at this point since we acquire an exclusive
|
||||
// lock on the process, and the "e.index" function cannot return a value >= 0 if there is
|
||||
// no topic already existing.
|
||||
cp.callbacks = append(cp.callbacks[:i], cp.callbacks[i+1:]...)
|
||||
}
|
||||
|
||||
// Finds the index of a given callback in the topic by comparing all of the registered callback
|
||||
// pointers to the passed function. This function does not aquire a lock as it should only be called
|
||||
// within the confines of a function that has already acquired a lock for the duration of the lookup.
|
||||
func (cp *CallbackPool) index(v reflect.Value) int {
|
||||
for i, handler := range cp.callbacks {
|
||||
if reflect.ValueOf(handler).Pointer() == v.Pointer() {
|
||||
return i
|
||||
}
|
||||
}
|
||||
|
||||
return -1
|
||||
}
|
||||
Reference in New Issue
Block a user