snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/pkg/eventbus/eventbus.go

@@ -0,0 +1,167 @@
+package eventbus
+
+import (
+	"context"
+	"sort"
+	"sync"
+	"unsafe"
+)
+
+type (
+	Event interface {
+		// ResourceType from resource that fired the event
+		ResourceType() string
+
+		// EventType returns type of event fired
+		EventType() string
+
+		// Match tests if given constraints match
+		// event's internal values
+		Match(ConstraintMatcher) bool
+	}
+
+	eventbus struct {
+		// waitgroup for dispatch
+		wg *sync.WaitGroup
+
+		// Read & write locking
+		// prevent event handling during handler (un)registration
+		l *sync.RWMutex
+
+		// list of registered handlers
+		handlers map[uintptr]*handler
+	}
+)
+
+var (
+	// Global eventbus
+	gEventBus *eventbus
+)
+
+func init() {
+	gEventBus = New()
+}
+
+// Service returns global event bus service
+func Service() *eventbus {
+	return gEventBus
+}
+
+func Set(eb *eventbus) {
+	gEventBus = eb
+}
+
+func New() *eventbus {
+	return &eventbus{
+		wg:       &sync.WaitGroup{},
+		l:        &sync.RWMutex{},
+		handlers: make(map[uintptr]*handler),
+	}
+}
+
+// WaitFor is synchronous event dispatcher
+//
+// It waits for each handler and fails on first error
+func (b *eventbus) WaitFor(ctx context.Context, ev Event) (err error) {
+	b.l.RLock()
+	defer b.l.RUnlock()
+
+	for _, t := range b.find(ev) {
+		err = func(ctx context.Context, t *handler) error {
+			b.wg.Add(1)
+			defer b.wg.Done()
+			return t.Handle(ctx, ev)
+
+		}(ctx, t)
+
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+// Dispatch runs events asynchronously
+func (b *eventbus) Dispatch(ctx context.Context, ev Event) {
+	b.l.RLock()
+	defer b.l.RUnlock()
+	for _, t := range b.find(ev) {
+		b.wg.Add(1)
+		go func(ctx context.Context, t *handler) {
+			defer b.wg.Done()
+			_ = t.Handle(ctx, ev)
+		}(ctx, t)
+	}
+}
+
+// Waits for all dispatched events
+//
+// Should only be used for testing
+func (b *eventbus) wait() {
+	b.wg.Wait()
+}
+
+// Finds all registered handlers compatible with given event
+//
+// It returns sorted handlers
+//
+// There is still room for improvement (performance wise) by indexing
+// resources and events of each handler.
+func (b *eventbus) find(ev Event) (tt HandlerSet) {
+	if ev == nil {
+		return
+	}
+
+	for _, t := range b.handlers {
+
+		if !t.Match(ev) {
+			continue
+		}
+
+		tt = append(tt, t)
+	}
+
+	sort.Sort(tt)
+
+	return
+}
+
+// Register creates a new handler with given handler, resource, event with other options and constraints
+//
+// It returns a handler identifier that can be used to remove (unregister) handler later
+func (b *eventbus) Register(h HandlerFn, ops ...HandlerRegOp) uintptr {
+	b.l.Lock()
+	defer b.l.Unlock()
+
+	var (
+		handlers = NewHandler(h, ops...)
+		ptr      = uintptr(unsafe.Pointer(handlers))
+	)
+
+	b.handlers[ptr] = handlers
+	return ptr
+}
+
+// Unregister removes one or more registered handlers
+func (b *eventbus) Unregister(ptrs ...uintptr) {
+	b.l.Lock()
+	defer b.l.Unlock()
+
+	for _, ptr := range ptrs {
+		delete(b.handlers, ptr)
+	}
+}
+
+// UnregisterByResource removes one or more registered handlers that match the given resource
+func (b *eventbus) UnregisterByResource(r string) {
+	b.l.Lock()
+	defer b.l.Unlock()
+	for p, h := range b.handlers {
+		if h.resourceTypes[r] {
+			delete(b.handlers, p)
+			continue
+		}
+
+	}
+}