Event dispatcher

dispatcher.go

package events

import (
	"sync"
	"context"
)

type Dispatcher struct {
	mutex     *sync.RWMutex
	listeners map[string][]Listener
}

func NewDispatcher() *Dispatcher {
	return &Dispatcher{
		listeners: make(map[string][]Listener),
		mutex:     new(sync.RWMutex),
	}
}

func (this *Dispatcher) AddListener(on string, listener Listener)  {
	this.mutex.Lock()
	defer this.mutex.Unlock()

	this.listeners[on] = append(this.listeners[on], listener)
}

func (this *Dispatcher) Dispatch(ctx context.Context, event Event) error {
	listeners, ok := this.listeners[event.GetKey()]
	if !ok {
		return nil
	}

	var wg sync.WaitGroup
	wg.Add(len(listeners))

	errChannel := make(chan error, 1)
	done := make(chan bool, 1)

	for _, listener := range listeners {
		go func() {
			defer wg.Done()

			if err := listener.Execute(ctx, event); err != nil {
				errChannel <- err
			}
		}()
	}

	go func() {
		wg.Wait()
		close(done)
	}()

	select {
		case <-done:
		case err := <-errChannel:
			return err
	}

	return nil
}

event.go

package events

type Event interface {
	GetKey()  string
}

listener.go

package events

import (
	"context"
)

type Listener interface {
	Execute(ctx context.Context, event Event) error
}