gut inbound and queue. promote outbound to honeybee.

config.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"

config_pool_test.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"git.wisehodl.dev/jay/go-honeybee/transport"

errors.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import "errors"
 import "fmt"

helper_test.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"

inbound/config.go

@@ -1,246 +0,0 @@
-package inbound
-
-import (
-	"context"
-	"git.wisehodl.dev/jay/go-honeybee/transport"
-	"log/slog"
-	"time"
-)
-
-// Pool Config
-
-type WorkerFactory func(
-	ctx context.Context,
-	id string,
-	conn *transport.Connection,
-	config *WorkerConfig,
-	logger *slog.Logger,
-) (Worker, error)
-
-type PoolConfig struct {
-	InboxBufferSize  int
-	EventsBufferSize int
-	LoggingEnabled   bool
-	LogLevel         *slog.Level
-	ConnectionConfig *transport.ConnectionConfig
-	WorkerConfig     *WorkerConfig
-	WorkerFactory    WorkerFactory
-}
-
-type PoolOption func(*PoolConfig) error
-
-func NewPoolConfig(options ...PoolOption) (*PoolConfig, error) {
-	conf := GetDefaultPoolConfig()
-	if err := applyPoolOptions(conf, options...); err != nil {
-		return nil, err
-	}
-	if err := ValidatePoolConfig(conf); err != nil {
-		return nil, err
-	}
-	return conf, nil
-}
-
-func GetDefaultPoolConfig() *PoolConfig {
-	return &PoolConfig{
-		InboxBufferSize:  256,
-		EventsBufferSize: 10,
-		LoggingEnabled:   true,
-		LogLevel:         nil,
-		ConnectionConfig: nil,
-		WorkerConfig:     nil,
-		WorkerFactory:    nil,
-	}
-}
-
-func applyPoolOptions(config *PoolConfig, options ...PoolOption) error {
-	for _, option := range options {
-		if err := option(config); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func ValidatePoolConfig(config *PoolConfig) error {
-	if config.ConnectionConfig != nil {
-		if err := transport.ValidateConnectionConfig(config.ConnectionConfig); err != nil {
-			return err
-		}
-	}
-	if config.WorkerConfig != nil {
-		if err := ValidateWorkerConfig(config.WorkerConfig); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func validateBufferSize(value int) error {
-	if value < 1 {
-		return InvalidBufferSize
-	}
-	return nil
-}
-
-func WithInboxBufferSize(value int) PoolOption {
-	return func(c *PoolConfig) error {
-		if err := validateBufferSize(value); err != nil {
-			return err
-		}
-		c.InboxBufferSize = value
-		return nil
-	}
-}
-
-func WithEventsBufferSize(value int) PoolOption {
-	return func(c *PoolConfig) error {
-		if err := validateBufferSize(value); err != nil {
-			return err
-		}
-		c.EventsBufferSize = value
-		return nil
-	}
-}
-
-func WithPoolLoggingEnabled(value bool) PoolOption {
-	return func(c *PoolConfig) error {
-		c.LoggingEnabled = value
-		return nil
-	}
-}
-
-func WithPoolLogLevel(level slog.Level) PoolOption {
-	return func(c *PoolConfig) error {
-		l := level
-		c.LogLevel = &l
-		return nil
-	}
-}
-
-func WithConnectionConfig(cc *transport.ConnectionConfig) PoolOption {
-	return func(c *PoolConfig) error {
-		if err := transport.ValidateConnectionConfig(cc); err != nil {
-			return err
-		}
-		c.ConnectionConfig = cc
-		return nil
-	}
-}
-
-func WithWorkerConfig(wc *WorkerConfig) PoolOption {
-	return func(c *PoolConfig) error {
-		if err := ValidateWorkerConfig(wc); err != nil {
-			return err
-		}
-		c.WorkerConfig = wc
-		return nil
-	}
-}
-
-func WithWorkerFactory(wf WorkerFactory) PoolOption {
-	return func(c *PoolConfig) error {
-		c.WorkerFactory = wf
-		return nil
-	}
-}
-
-// Worker Config
-
-type WorkerConfig struct {
-	MaxQueueSize      int
-	InactivityTimeout time.Duration
-	LoggingEnabled    bool
-	LogLevel          *slog.Level
-}
-
-type WorkerOption func(*WorkerConfig) error
-
-func NewWorkerConfig(options ...WorkerOption) (*WorkerConfig, error) {
-	conf := GetDefaultWorkerConfig()
-	if err := applyWorkerOptions(conf, options...); err != nil {
-		return nil, err
-	}
-	if err := ValidateWorkerConfig(conf); err != nil {
-		return nil, err
-	}
-	return conf, nil
-}
-
-func GetDefaultWorkerConfig() *WorkerConfig {
-	return &WorkerConfig{
-		MaxQueueSize:      0, // queue can grow indefinitely by default
-		InactivityTimeout: 0, // eviction disabled by default
-		LoggingEnabled:    true,
-		LogLevel:          nil,
-	}
-}
-
-func applyWorkerOptions(config *WorkerConfig, options ...WorkerOption) error {
-	for _, option := range options {
-		if err := option(config); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func ValidateWorkerConfig(config *WorkerConfig) error {
-	if err := validateMaxQueueSize(config.MaxQueueSize); err != nil {
-		return err
-	}
-	if err := validateInactivityTimeout(config.InactivityTimeout); err != nil {
-		return err
-	}
-	return nil
-}
-
-func validateMaxQueueSize(value int) error {
-	if value < 0 {
-		return InvalidMaxQueueSize
-	}
-	return nil
-}
-
-func validateInactivityTimeout(value time.Duration) error {
-	if value < 0 {
-		return InvalidInactivityTimeout
-	}
-	return nil
-}
-
-// When MaxQueueSize is zero, queue limits are disabled.
-func WithMaxQueueSize(value int) WorkerOption {
-	return func(c *WorkerConfig) error {
-		if err := validateMaxQueueSize(value); err != nil {
-			return err
-		}
-		c.MaxQueueSize = value
-		return nil
-	}
-}
-
-// When InactivityTimeout is zero, the watchdog is disabled.
-func WithInactivityTimeout(value time.Duration) WorkerOption {
-	return func(c *WorkerConfig) error {
-		if err := validateInactivityTimeout(value); err != nil {
-			return err
-		}
-		c.InactivityTimeout = value
-		return nil
-	}
-}
-
-func WithWorkerLoggingEnabled(value bool) WorkerOption {
-	return func(c *WorkerConfig) error {
-		c.LoggingEnabled = value
-		return nil
-	}
-}
-
-func WithWorkerLogLevel(level slog.Level) WorkerOption {
-	return func(c *WorkerConfig) error {
-		l := level
-		c.LogLevel = &l
-		return nil
-	}
-}

inbound/config_test.go

@@ -1,207 +0,0 @@
-// responderpool/config_test.go
-package inbound
-
-import (
-	"git.wisehodl.dev/jay/go-honeybee/transport"
-	"github.com/stretchr/testify/assert"
-	"testing"
-	"time"
-)
-
-func TestNewWorkerConfig(t *testing.T) {
-	conf, err := NewWorkerConfig()
-	assert.NoError(t, err)
-	assert.Equal(t, GetDefaultWorkerConfig(), conf)
-}
-
-func TestDefaultWorkerConfig(t *testing.T) {
-	conf := GetDefaultWorkerConfig()
-	assert.Equal(t, &WorkerConfig{
-		MaxQueueSize:      0,
-		InactivityTimeout: 0,
-		LoggingEnabled:    true,
-		LogLevel:          nil,
-	}, conf)
-}
-
-func TestValidateWorkerConfig(t *testing.T) {
-	cases := []struct {
-		name    string
-		conf    WorkerConfig
-		wantErr error
-	}{
-		{
-			name: "valid defaults",
-			conf: *GetDefaultWorkerConfig(),
-		},
-		{
-			name: "zero inactivity timeout disabled",
-			conf: WorkerConfig{InactivityTimeout: 0},
-		},
-		{
-			name: "positive inactivity timeout",
-			conf: WorkerConfig{InactivityTimeout: 30 * time.Second},
-		},
-		{
-			name:    "negative max queue size",
-			conf:    WorkerConfig{MaxQueueSize: -1},
-			wantErr: InvalidMaxQueueSize,
-		},
-		{
-			name:    "negative inactivity timeout",
-			conf:    WorkerConfig{InactivityTimeout: -1 * time.Second},
-			wantErr: InvalidInactivityTimeout,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			err := ValidateWorkerConfig(&tc.conf)
-			if tc.wantErr != nil {
-				assert.ErrorIs(t, err, tc.wantErr)
-				return
-			}
-			assert.NoError(t, err)
-		})
-	}
-}
-
-func TestWithMaxQueueSize(t *testing.T) {
-	conf := &WorkerConfig{}
-
-	err := applyWorkerOptions(conf, WithMaxQueueSize(10))
-	assert.NoError(t, err)
-	assert.Equal(t, 10, conf.MaxQueueSize)
-
-	err = applyWorkerOptions(conf, WithMaxQueueSize(0))
-	assert.NoError(t, err)
-
-	err = applyWorkerOptions(conf, WithMaxQueueSize(-1))
-	assert.ErrorIs(t, err, InvalidMaxQueueSize)
-}
-
-func TestWithInactivityTimeout(t *testing.T) {
-	conf := &WorkerConfig{}
-
-	err := applyWorkerOptions(conf, WithInactivityTimeout(30*time.Second))
-	assert.NoError(t, err)
-	assert.Equal(t, 30*time.Second, conf.InactivityTimeout)
-
-	err = applyWorkerOptions(conf, WithInactivityTimeout(0))
-	assert.NoError(t, err)
-
-	err = applyWorkerOptions(conf, WithInactivityTimeout(-1*time.Second))
-	assert.ErrorIs(t, err, InvalidInactivityTimeout)
-}
-
-func TestNewPoolConfig(t *testing.T) {
-	conf, err := NewPoolConfig()
-	assert.NoError(t, err)
-	assert.Equal(t, GetDefaultPoolConfig(), conf)
-}
-
-func TestDefaultPoolConfig(t *testing.T) {
-	conf := GetDefaultPoolConfig()
-	assert.Equal(t, &PoolConfig{
-		InboxBufferSize:  256,
-		EventsBufferSize: 10,
-		LoggingEnabled:   true,
-		LogLevel:         nil,
-		ConnectionConfig: nil,
-		WorkerConfig:     nil,
-		WorkerFactory:    nil,
-	}, conf)
-}
-
-func TestValidatePoolConfig(t *testing.T) {
-	cases := []struct {
-		name        string
-		conf        PoolConfig
-		wantErrText string
-	}{
-		{
-			name: "valid empty",
-			conf: PoolConfig{},
-		},
-		{
-			name: "valid defaults",
-			conf: *GetDefaultPoolConfig(),
-		},
-		{
-			name: "valid with configs",
-			conf: PoolConfig{
-				ConnectionConfig: &transport.ConnectionConfig{},
-				WorkerConfig:     &WorkerConfig{},
-			},
-		},
-		{
-			name: "invalid connection config",
-			conf: PoolConfig{
-				ConnectionConfig: &transport.ConnectionConfig{
-					Retry: &transport.RetryConfig{
-						InitialDelay: 10 * time.Second,
-						MaxDelay:     1 * time.Second,
-					},
-				},
-			},
-			wantErrText: "initial delay may not exceed maximum delay",
-		},
-		{
-			name: "invalid worker config",
-			conf: PoolConfig{
-				WorkerConfig: &WorkerConfig{MaxQueueSize: -1},
-			},
-			wantErrText: "maximum queue size cannot be negative",
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			err := ValidatePoolConfig(&tc.conf)
-			if tc.wantErrText != "" {
-				assert.ErrorContains(t, err, tc.wantErrText)
-				return
-			}
-			assert.NoError(t, err)
-		})
-	}
-}
-
-func TestWithBufferSizes(t *testing.T) {
-	conf := &PoolConfig{}
-
-	err := applyPoolOptions(conf,
-		WithInboxBufferSize(100),
-		WithEventsBufferSize(20),
-	)
-	assert.NoError(t, err)
-	assert.Equal(t, 100, conf.InboxBufferSize)
-	assert.Equal(t, 20, conf.EventsBufferSize)
-}
-
-func TestWithConnectionConfig(t *testing.T) {
-	conf := &PoolConfig{}
-
-	err := applyPoolOptions(conf, WithConnectionConfig(&transport.ConnectionConfig{}))
-	assert.NoError(t, err)
-	assert.NotNil(t, conf.ConnectionConfig)
-
-	err = applyPoolOptions(conf, WithConnectionConfig(&transport.ConnectionConfig{
-		Retry: &transport.RetryConfig{
-			InitialDelay: 10 * time.Second,
-			MaxDelay:     1 * time.Second,
-		},
-	}))
-	assert.Error(t, err)
-}
-
-func TestWithWorkerConfig(t *testing.T) {
-	conf := &PoolConfig{}
-
-	err := applyPoolOptions(conf, WithWorkerConfig(&WorkerConfig{InactivityTimeout: 30 * time.Second}))
-	assert.NoError(t, err)
-	assert.Equal(t, 30*time.Second, conf.WorkerConfig.InactivityTimeout)
-
-	err = applyPoolOptions(conf, WithWorkerConfig(&WorkerConfig{MaxQueueSize: -1}))
-	assert.Error(t, err)
-}

inbound/errors.go

@@ -1,17 +0,0 @@
-package inbound
-
-import "errors"
-
-var (
-	// Pool errors
-	PoolError        = errors.New("pool error")
-	ErrInvalidPoolID = errors.New("pool id cannot be empty")
-	ErrPoolClosed    = errors.New("pool is closed")
-	ErrPeerNotFound  = errors.New("peer not found")
-	ErrPeerExists    = errors.New("peer already exists")
-
-	// Config errors
-	InvalidMaxQueueSize      = errors.New("maximum queue size cannot be negative")
-	InvalidInactivityTimeout = errors.New("inactivity timeout cannot be negative")
-	InvalidBufferSize        = errors.New("buffer size must be greater than zero")
-)

inbound/helpers_test.go

@@ -1,24 +0,0 @@
-package inbound
-
-import (
-	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
-	"git.wisehodl.dev/jay/go-honeybee/transport"
-	"github.com/stretchr/testify/assert"
-	"testing"
-)
-
-func setupTestConnection(t *testing.T) (
-	conn *transport.Connection,
-	socket *honeybeetest.MockSocket,
-	incoming chan honeybeetest.MockIncomingData,
-	outgoing chan honeybeetest.MockOutgoingData,
-) {
-	t.Helper()
-
-	socket, incoming, outgoing = honeybeetest.SetupTestSocket(t)
-
-	var err error
-	conn, err = transport.NewConnectionFromSocket(socket, nil, nil)
-	assert.NoError(t, err)
-	return
-}

inbound/pool.go

@@ -1,423 +0,0 @@
-package inbound
-
-import (
-	"context"
-	"fmt"
-	"git.wisehodl.dev/jay/go-honeybee/logging"
-	"git.wisehodl.dev/jay/go-honeybee/transport"
-	"git.wisehodl.dev/jay/go-honeybee/types"
-	"log/slog"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-// Re-exported types for consumer convenience
-
-type Socket = types.Socket
-type InboxMessage = types.InboxMessage
-
-var NormalizeURL = transport.NormalizeURL
-
-// Types
-
-type PoolEventKind string
-
-const (
-	EventDisconnected  PoolEventKind = "disconnected"
-	EventDroppedClose  PoolEventKind = "dropped_close"
-	EventDroppedError  PoolEventKind = "dropped_error"
-	EventEvictedPolicy PoolEventKind = "evicted_policy"
-)
-
-var workerToPoolEvent = map[WorkerExitKind]PoolEventKind{
-	ExitDisconnected:    EventDisconnected,
-	ExitUnexpectedClose: EventDroppedClose,
-	ExitReadError:       EventDroppedError,
-	ExitPolicy:          EventEvictedPolicy,
-}
-
-type OnExitFunction func(kind WorkerExitKind)
-
-type PoolEvent struct {
-	ID   string
-	Kind PoolEventKind
-	At   time.Time
-}
-
-type PoolStats struct {
-	ChanInbox  int
-	ChanEvents int
-
-	TotalReceived uint64
-	TotalSent     uint64
-
-	PeerCount int
-	PeerStats []PeerStats
-}
-
-type PeerStats struct {
-	ID         string
-	Worker     WorkerStats
-	Connection transport.ConnectionStats
-}
-
-type PoolPlugin struct {
-	Inbox        chan<- types.InboxMessage
-	Events       chan<- PoolEvent
-	InboxCounter *atomic.Uint64
-	OnExit       OnExitFunction
-	Handler      slog.Handler
-}
-
-// Pool
-
-type Peer struct {
-	id     string
-	conn   *transport.Connection
-	worker Worker
-	done   chan struct{}
-}
-
-type Pool struct {
-	ctx    context.Context
-	cancel context.CancelFunc
-
-	id string
-
-	peers  map[string]*Peer
-	inbox  chan types.InboxMessage
-	events chan PoolEvent
-
-	inboxCounter  *atomic.Uint64
-	outgoingCount *atomic.Uint64
-
-	config  *PoolConfig
-	handler slog.Handler
-	logger  *slog.Logger
-
-	mu     sync.RWMutex
-	wg     sync.WaitGroup
-	closed bool
-}
-
-func NewPool(ctx context.Context, id string, config *PoolConfig, handler slog.Handler) (*Pool, error) {
-	if id == "" {
-		return nil, ErrInvalidPoolID
-	}
-
-	if config == nil {
-		config = GetDefaultPoolConfig()
-	}
-
-	// If a custom factory is supplied, config.WorkerConfig is not used.
-	// The factory function should be non-blocking or else Connect() may cause
-	// deadlocks.
-	if config.WorkerFactory == nil {
-		config.WorkerFactory = func(
-			ctx context.Context,
-			id string,
-			conn *transport.Connection,
-			config *WorkerConfig,
-			logger *slog.Logger,
-		) (Worker, error) {
-			return NewWorker(ctx, id, conn, config, logger)
-		}
-	}
-
-	if err := ValidatePoolConfig(config); err != nil {
-		return nil, err
-	}
-
-	pctx, cancel := context.WithCancel(ctx)
-
-	var logger *slog.Logger
-	if handler != nil && config.LoggingEnabled {
-		logger = logging.NewInboundPoolLogger(
-			logging.WrapOrDefault(config.LogLevel, handler), id)
-	}
-
-	return &Pool{
-		ctx:           pctx,
-		cancel:        cancel,
-		id:            id,
-		peers:         make(map[string]*Peer),
-		inbox:         make(chan types.InboxMessage, config.InboxBufferSize),
-		events:        make(chan PoolEvent, config.EventsBufferSize),
-		inboxCounter:  &atomic.Uint64{},
-		outgoingCount: &atomic.Uint64{},
-		config:        config,
-		handler:       handler,
-		logger:        logger,
-	}, nil
-}
-
-func (p *Pool) Peers() []string {
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-
-	ids := make([]string, 0, len(p.peers))
-	for id := range p.peers {
-		ids = append(ids, id)
-	}
-
-	return ids
-}
-
-func (p *Pool) Inbox() <-chan types.InboxMessage {
-	return p.inbox
-}
-
-func (p *Pool) Events() <-chan PoolEvent {
-	return p.events
-}
-
-func (p *Pool) Stats() PoolStats {
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-
-	count := len(p.peers)
-	peerStats := make([]PeerStats, 0, count)
-	for id, peer := range p.peers {
-		peerStats = append(peerStats, PeerStats{
-			ID:         id,
-			Worker:     peer.worker.Stats(),
-			Connection: peer.conn.Stats(),
-		})
-	}
-
-	return PoolStats{
-		ChanInbox:  len(p.inbox),
-		ChanEvents: len(p.events),
-
-		TotalReceived: p.inboxCounter.Load(),
-		TotalSent:     p.outgoingCount.Load(),
-
-		PeerCount: len(p.peers),
-		PeerStats: peerStats,
-	}
-}
-
-func (p *Pool) PeerStats(id string) (PeerStats, error) {
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-
-	peer, exists := p.peers[id]
-	if !exists {
-		return PeerStats{}, ErrPeerNotFound
-	}
-
-	return PeerStats{
-		ID:         id,
-		Worker:     peer.worker.Stats(),
-		Connection: peer.conn.Stats(),
-	}, nil
-}
-
-func (p *Pool) Close() {
-	if p.logger != nil {
-		p.logger.Debug("closing")
-	}
-
-	p.mu.Lock()
-	if p.closed {
-		p.mu.Unlock()
-		return
-	}
-
-	p.closed = true
-	p.cancel()
-
-	// close all connections
-	for _, peer := range p.peers {
-		peer.worker.Stop()
-		peer.conn.Close()
-	}
-
-	// remove all peers
-	p.peers = make(map[string]*Peer)
-
-	p.mu.Unlock()
-
-	go func() {
-		p.wg.Wait()
-		close(p.inbox)
-		close(p.events)
-
-		if p.logger != nil {
-			p.logger.Info("closed")
-		}
-	}()
-}
-
-func (p *Pool) Add(id string, socket types.Socket) error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	if p.closed {
-		return ErrPoolClosed
-	}
-
-	if _, exists := p.peers[id]; exists {
-		return ErrPeerExists
-	}
-
-	return p.addLocked(id, socket)
-}
-
-func (p *Pool) Replace(id string, socket types.Socket) error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	if p.closed {
-		return ErrPoolClosed
-	}
-
-	if peer, exists := p.peers[id]; exists {
-		p.removeLocked(peer)
-
-		if p.logger != nil {
-			p.logger.Info("removed peer", "peer", id)
-		}
-
-	} else {
-		return ErrPeerNotFound
-	}
-
-	return p.addLocked(id, socket)
-}
-
-func (p *Pool) Remove(id string) error {
-	if p.logger != nil {
-		p.logger.Debug("removing peer", "peer", id)
-	}
-
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	if p.closed {
-		return ErrPoolClosed
-	}
-
-	peer, exists := p.peers[id]
-	if !exists {
-		return ErrPeerNotFound
-	}
-
-	p.removeLocked(peer)
-
-	if p.logger != nil {
-		p.logger.Info("removed peer", "peer", id)
-	}
-
-	return nil
-}
-
-func (p *Pool) Send(id string, data []byte) error {
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-
-	if p.closed {
-		return ErrPoolClosed
-	}
-
-	peer, exists := p.peers[id]
-	if !exists {
-		return ErrPeerNotFound
-	}
-
-	err := peer.worker.Send(data)
-	if err != nil {
-		return err
-	}
-
-	p.outgoingCount.Add(1)
-	return nil
-}
-
-// addLocked constructs and registers a peer. Caller must hold p.mu write lock.
-func (p *Pool) addLocked(id string, socket types.Socket) error {
-	var logger *slog.Logger
-	if p.handler != nil && p.config.ConnectionConfig.LoggingEnabled {
-		logger = logging.NewConnectionLogger(
-			logging.WrapOrDefault(p.config.ConnectionConfig.LogLevel, p.handler), p.id, id)
-	}
-
-	conn, err := transport.NewConnectionFromSocket(
-		socket, p.config.ConnectionConfig, logger)
-	if err != nil {
-		return err
-	}
-
-	wctx, cancel := context.WithCancel(p.ctx)
-	if p.handler != nil && p.config.WorkerConfig.LoggingEnabled {
-		logger = logging.NewInboundWorkerLogger(
-			logging.WrapOrDefault(p.config.WorkerConfig.LogLevel, p.handler), p.id, id)
-	}
-
-	// The worker factory must be non-blocking to avoid deadlocks
-	worker, err := p.config.WorkerFactory(wctx, id, conn, p.config.WorkerConfig, logger)
-	if err != nil {
-		cancel()
-		conn.Close()
-		return fmt.Errorf("%w: %w", PoolError, err)
-	}
-
-	var once sync.Once
-	onExit := func(kind WorkerExitKind) {
-		once.Do(func() {
-			p.mu.Lock()
-			delete(p.peers, id)
-			p.mu.Unlock()
-
-			conn.Close()
-
-			select {
-			case p.events <- PoolEvent{ID: id, Kind: workerToPoolEvent[kind], At: time.Now()}:
-			case <-p.ctx.Done():
-				return
-			}
-		})
-	}
-
-	pool := PoolPlugin{
-		Inbox:        p.inbox,
-		Events:       p.events,
-		InboxCounter: p.inboxCounter,
-		OnExit:       onExit,
-		Handler:      p.handler,
-	}
-
-	peer := &Peer{
-		id:     id,
-		conn:   conn,
-		worker: worker,
-		done:   make(chan struct{}),
-	}
-
-	p.wg.Add(1)
-	go func() {
-		defer cancel()
-		defer close(peer.done)
-		worker.Start(pool)
-		p.wg.Done()
-	}()
-
-	p.peers[id] = peer
-
-	if p.logger != nil {
-		p.logger.Info("added peer", "peer", id)
-	}
-
-	return nil
-}
-
-// removeLocked closes and unregisters a peer. Caller must hold p.mu write lock.
-func (p *Pool) removeLocked(peer *Peer) {
-	delete(p.peers, peer.id)
-	peer.worker.Stop()
-	go func() {
-		<-peer.done
-		peer.conn.Close()
-	}()
-}

inbound/pool_test.go

@@ -1,400 +0,0 @@
-package inbound
-
-import (
-	"context"
-	"fmt"
-	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
-	"github.com/gorilla/websocket"
-	"github.com/stretchr/testify/assert"
-	"slices"
-	"testing"
-	"time"
-)
-
-// Helpers
-
-func setupPool(t *testing.T) *Pool {
-	t.Helper()
-	pool, err := NewPool(context.Background(), "pool-1", nil, nil)
-	assert.NoError(t, err)
-	return pool
-}
-
-func expectEvent(
-	t *testing.T,
-	events <-chan PoolEvent,
-	expectedURL string,
-	expectedKind PoolEventKind,
-) {
-	t.Helper()
-	honeybeetest.Eventually(t, func() bool {
-		select {
-		case e := <-events:
-			return e.ID == expectedURL && e.Kind == expectedKind && !e.At.IsZero()
-		default:
-			return false
-		}
-	}, fmt.Sprintf("expected event: URL=%q, Kind=%q", expectedURL, expectedKind))
-}
-
-// Tests
-
-func TestPoolID(t *testing.T) {
-	_, err := NewPool(context.Background(), "", nil, nil)
-	assert.ErrorIs(t, err, ErrInvalidPoolID)
-}
-
-func TestPoolAdd(t *testing.T) {
-	t.Run("successfully adds peer", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		err := pool.Add("peer-1", socket)
-		assert.NoError(t, err)
-	})
-
-	t.Run("peer appears in Peers after add", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		err := pool.Add("peer-1", socket)
-		assert.NoError(t, err)
-
-		assert.Contains(t, pool.Peers(), "peer-1")
-	})
-
-	t.Run("duplicate id returns ErrPeerExists", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket1, _, _ := honeybeetest.SetupTestSocket(t)
-		socket2, _, _ := honeybeetest.SetupTestSocket(t)
-
-		err := pool.Add("peer-1", socket1)
-		assert.NoError(t, err)
-
-		err = pool.Add("peer-1", socket2)
-		assert.ErrorIs(t, err, ErrPeerExists)
-	})
-
-	t.Run("closed pool returns ErrPoolClosed", func(t *testing.T) {
-		pool := setupPool(t)
-		pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		err := pool.Add("peer-1", socket)
-		assert.ErrorIs(t, err, ErrPoolClosed)
-	})
-}
-
-func TestPoolReplace(t *testing.T) {
-	t.Run("replaces existing peer", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket1, _, _ := honeybeetest.SetupTestSocket(t)
-		socket2, _, _ := honeybeetest.SetupTestSocket(t)
-
-		err := pool.Add("peer-1", socket1)
-		assert.NoError(t, err)
-
-		err = pool.Replace("peer-1", socket2)
-		assert.NoError(t, err)
-
-		assert.Contains(t, pool.Peers(), "peer-1")
-	})
-
-	t.Run("unknown id returns ErrPeerNotFound", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		err := pool.Replace("unknown", socket)
-		assert.ErrorIs(t, err, ErrPeerNotFound)
-	})
-
-	t.Run("closed pool returns ErrPoolClosed", func(t *testing.T) {
-		pool := setupPool(t)
-		pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		err := pool.Replace("peer-1", socket)
-		assert.ErrorIs(t, err, ErrPoolClosed)
-	})
-
-	t.Run("no event emitted for replaced peer", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket1, _, _ := honeybeetest.SetupTestSocket(t)
-		socket2, _, _ := honeybeetest.SetupTestSocket(t)
-
-		err := pool.Add("peer-1", socket1)
-		assert.NoError(t, err)
-
-		err = pool.Replace("peer-1", socket2)
-		assert.NoError(t, err)
-
-		honeybeetest.Never(t, func() bool {
-			select {
-			case <-pool.Events():
-				return true
-			default:
-				return false
-			}
-		}, "no event expected on replace")
-	})
-}
-
-func TestPoolRemove(t *testing.T) {
-	t.Run("removes known peer", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		err := pool.Add("peer-1", socket)
-		assert.NoError(t, err)
-
-		err = pool.Remove("peer-1")
-		assert.NoError(t, err)
-
-		assert.NotContains(t, pool.Peers(), "peer-1")
-	})
-
-	t.Run("unknown id returns ErrPeerNotFound", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		err := pool.Remove("unknown")
-		assert.ErrorIs(t, err, ErrPeerNotFound)
-	})
-
-	t.Run("closed pool returns ErrPoolClosed", func(t *testing.T) {
-		pool := setupPool(t)
-		pool.Close()
-
-		err := pool.Remove("peer-1")
-		assert.ErrorIs(t, err, ErrPoolClosed)
-	})
-
-	t.Run("no event emitted on remove", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		err := pool.Add("peer-1", socket)
-		assert.NoError(t, err)
-
-		err = pool.Remove("peer-1")
-		assert.NoError(t, err)
-
-		honeybeetest.Never(t, func() bool {
-			select {
-			case e := <-pool.Events():
-				fmt.Printf("got event: %v", e)
-				return true
-			default:
-				return false
-			}
-		}, "no event expected on remove")
-	})
-}
-
-func TestPoolSend(t *testing.T) {
-	t.Run("data reaches socket", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, _, outgoing := honeybeetest.SetupTestSocket(t)
-		err := pool.Add("peer-1", socket)
-		assert.NoError(t, err)
-
-		err = pool.Send("peer-1", []byte("hello"))
-		assert.NoError(t, err)
-
-		honeybeetest.ExpectWrite(t, outgoing, websocket.TextMessage, []byte("hello"))
-	})
-
-	t.Run("unknown id returns ErrPeerNotFound", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		err := pool.Send("unknown", []byte("hello"))
-		assert.ErrorIs(t, err, ErrPeerNotFound)
-	})
-
-	t.Run("closed pool returns ErrPoolClosed", func(t *testing.T) {
-		pool := setupPool(t)
-		pool.Close()
-
-		err := pool.Send("peer-1", []byte("hello"))
-		assert.ErrorIs(t, err, ErrPoolClosed)
-	})
-}
-
-func TestPoolClose(t *testing.T) {
-	t.Run("inbox and events channels close after pool close", func(t *testing.T) {
-		pool := setupPool(t)
-		pool.Close()
-
-		_, ok := <-pool.Inbox()
-		assert.False(t, ok)
-		_, ok = <-pool.Events()
-		assert.False(t, ok)
-	})
-
-	t.Run("add after close returns ErrPoolClosed", func(t *testing.T) {
-		pool := setupPool(t)
-		pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		err := pool.Add("peer-1", socket)
-		assert.ErrorIs(t, err, ErrPoolClosed)
-	})
-
-	t.Run("close is idempotent", func(t *testing.T) {
-		pool := setupPool(t)
-		pool.Close()
-		pool.Close()
-	})
-}
-
-func TestPoolPeers(t *testing.T) {
-	t.Run("reflects active peers after add", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket1, _, _ := honeybeetest.SetupTestSocket(t)
-		socket2, _, _ := honeybeetest.SetupTestSocket(t)
-
-		pool.Add("peer-1", socket1)
-		pool.Add("peer-2", socket2)
-
-		peers := pool.Peers()
-		assert.Contains(t, peers, "peer-1")
-		assert.Contains(t, peers, "peer-2")
-	})
-
-	t.Run("loses entry after remove", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		pool.Add("peer-1", socket)
-		pool.Remove("peer-1")
-
-		assert.NotContains(t, pool.Peers(), "peer-1")
-	})
-
-	t.Run("loses entry after peer self-disconnects", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, incoming, _ := honeybeetest.SetupTestSocket(t)
-		pool.Add("peer-1", socket)
-
-		close(incoming)
-
-		honeybeetest.Eventually(t, func() bool {
-			return !slices.Contains(pool.Peers(), "peer-1")
-		}, "expected peer to be removed after self-disconnect")
-	})
-}
-
-func TestPoolEvents(t *testing.T) {
-	t.Run("EventPeerDisconnected emitted on clean close", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, incoming, _ := honeybeetest.SetupTestSocket(t)
-		pool.Add("peer-1", socket)
-
-		incoming <- honeybeetest.MockIncomingData{
-			Err: &websocket.CloseError{Code: websocket.CloseNormalClosure},
-		}
-
-		expectEvent(t, pool.Events(), "peer-1", EventDisconnected)
-
-		honeybeetest.Eventually(t, func() bool {
-			return !slices.Contains(pool.Peers(), "peer-1")
-		}, "expected peer auto-removed")
-	})
-
-	t.Run("EventPeerDropped emitted on unexpected close", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, incoming, _ := honeybeetest.SetupTestSocket(t)
-		pool.Add("peer-1", socket)
-
-		incoming <- honeybeetest.MockIncomingData{
-			Err: &websocket.CloseError{Code: websocket.CloseProtocolError},
-		}
-
-		expectEvent(t, pool.Events(), "peer-1", EventDroppedClose)
-
-		honeybeetest.Eventually(t, func() bool {
-			return !slices.Contains(pool.Peers(), "peer-1")
-		}, "expected peer auto-removed")
-	})
-
-	t.Run("EventPeerEvicted emitted on watchdog timeout", func(t *testing.T) {
-		config, err := NewPoolConfig(
-			WithWorkerConfig(&WorkerConfig{InactivityTimeout: 20 * time.Millisecond}),
-		)
-		assert.NoError(t, err)
-
-		pool, err := NewPool(context.Background(), "pool-1", config, nil)
-		assert.NoError(t, err)
-		defer pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		pool.Add("peer-1", socket)
-
-		expectEvent(t, pool.Events(), "peer-1", EventEvictedPolicy)
-
-		honeybeetest.Eventually(t, func() bool {
-			return !slices.Contains(pool.Peers(), "peer-1")
-		}, "expected peer auto-removed")
-	})
-
-	t.Run("no event emitted on Remove", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		pool.Add("peer-1", socket)
-		pool.Remove("peer-1")
-
-		honeybeetest.Never(t, func() bool {
-			select {
-			case <-pool.Events():
-				return true
-			default:
-				return false
-			}
-		}, "no event expected on Remove")
-	})
-
-	t.Run("no event emitted on Replace of old peer", func(t *testing.T) {
-		pool := setupPool(t)
-		defer pool.Close()
-
-		socket1, _, _ := honeybeetest.SetupTestSocket(t)
-		socket2, _, _ := honeybeetest.SetupTestSocket(t)
-
-		pool.Add("peer-1", socket1)
-		pool.Replace("peer-1", socket2)
-
-		honeybeetest.Never(t, func() bool {
-			select {
-			case <-pool.Events():
-				return true
-			default:
-				return false
-			}
-		}, "no event expected on Replace")
-	})
-}

inbound/worker.go

@@ -1,340 +0,0 @@
-package inbound
-
-import (
-	"context"
-	"errors"
-	"git.wisehodl.dev/jay/go-honeybee/queue"
-	"git.wisehodl.dev/jay/go-honeybee/transport"
-	"git.wisehodl.dev/jay/go-honeybee/types"
-	"log/slog"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-type Worker interface {
-	Start(pool PoolPlugin)
-	Stop()
-	Send(data []byte) error
-	Stats() WorkerStats
-}
-
-type WorkerExitKind string
-
-const (
-	ExitDisconnected    WorkerExitKind = "disconnected"
-	ExitUnexpectedClose WorkerExitKind = "unexpected_close"
-	ExitReadError       WorkerExitKind = "read_error"
-	ExitPolicy          WorkerExitKind = "policy"
-)
-
-type WorkerStats struct {
-	ChanIncoming  int
-	ChanQueue     int
-	ChanForwarder int
-	BufferDepth   int64
-
-	TotalProcessed uint64
-	TotalDropped   uint64
-	TotalSent      uint64
-}
-
-type DefaultWorker struct {
-	id   string
-	conn *transport.Connection
-
-	heartbeat   chan struct{}
-	toQueue     chan types.ReceivedMessage
-	toForwarder chan types.ReceivedMessage
-
-	processedCount *atomic.Uint64
-	droppedCount   *atomic.Uint64
-	outgoingCount  *atomic.Uint64
-	bufferDepth    *atomic.Int64
-
-	ctx    context.Context
-	cancel context.CancelFunc
-	config *WorkerConfig
-	logger *slog.Logger
-}
-
-func NewWorker(
-	ctx context.Context,
-	id string,
-	conn *transport.Connection,
-	config *WorkerConfig,
-	logger *slog.Logger,
-) (*DefaultWorker, error) {
-	if config == nil {
-		config = GetDefaultWorkerConfig()
-	}
-	if err := ValidateWorkerConfig(config); err != nil {
-		return nil, err
-	}
-
-	wctx, cancel := context.WithCancel(ctx)
-	return &DefaultWorker{
-		id:             id,
-		conn:           conn,
-		heartbeat:      make(chan struct{}),
-		toQueue:        make(chan types.ReceivedMessage, 256),
-		toForwarder:    make(chan types.ReceivedMessage, 256),
-		processedCount: &atomic.Uint64{},
-		droppedCount:   &atomic.Uint64{},
-		outgoingCount:  &atomic.Uint64{},
-		bufferDepth:    &atomic.Int64{},
-		config:         config,
-		ctx:            wctx,
-		cancel:         cancel,
-		logger:         logger,
-	}, nil
-}
-
-func (w *DefaultWorker) Start(pool PoolPlugin) {
-	if w.logger != nil {
-		w.logger.Debug("starting")
-	}
-
-	var wg sync.WaitGroup
-	wg.Add(5)
-
-	go func() {
-		defer wg.Done()
-		RunReader(w.ctx, pool.OnExit, w.conn, w.toQueue, w.heartbeat, w.logger)
-	}()
-
-	go func() {
-		defer wg.Done()
-		RunHeartbeatForwarder(w.ctx, w.conn, w.heartbeat, w.logger)
-	}()
-
-	go func() {
-		defer wg.Done()
-		queue.RunQueue(w.id, w.ctx, w.toQueue, w.toForwarder, w.config.MaxQueueSize, w.droppedCount, w.bufferDepth)
-	}()
-
-	go func() {
-		defer wg.Done()
-		RunForwarder(w.id, w.ctx, w.toForwarder, pool.Inbox, w.processedCount, pool.InboxCounter)
-	}()
-
-	go func() {
-		defer wg.Done()
-		RunWatchdog(w.ctx, pool.OnExit, w.heartbeat, w.config.InactivityTimeout, w.logger)
-	}()
-
-	if w.logger != nil {
-		w.logger.Info("started")
-	}
-
-	wg.Wait()
-
-	if w.logger != nil {
-		w.logger.Info("stopped")
-	}
-}
-
-func (w *DefaultWorker) Stop() {
-	if w.logger != nil {
-		w.logger.Debug("shutting down")
-	}
-	w.cancel()
-}
-
-func (w *DefaultWorker) Send(data []byte) error {
-	if err := w.conn.Send(data); err != nil {
-		return err
-	}
-
-	select {
-	case w.heartbeat <- struct{}{}:
-	case <-w.ctx.Done():
-	}
-
-	w.outgoingCount.Add(1)
-
-	return nil
-}
-
-func (w *DefaultWorker) Stats() WorkerStats {
-	return WorkerStats{
-		ChanIncoming:  len(w.conn.Incoming()),
-		ChanQueue:     len(w.toQueue),
-		ChanForwarder: len(w.toForwarder),
-		BufferDepth:   w.bufferDepth.Load(),
-
-		TotalProcessed: w.processedCount.Load(),
-		TotalDropped:   w.droppedCount.Load(),
-		TotalSent:      w.outgoingCount.Load(),
-	}
-}
-
-func RunReader(
-	ctx context.Context,
-	onPeerClose OnExitFunction,
-
-	conn *transport.Connection,
-	messages chan<- types.ReceivedMessage,
-	heartbeat chan<- struct{},
-
-	logger *slog.Logger,
-) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case data, ok := <-conn.Incoming():
-			if !ok {
-				var err error
-				// determine exit kind
-				// by default, the peer dropped unexpectedly
-				kind := ExitUnexpectedClose
-				select {
-				// the peer-side error is sent before the connection is closed,
-				// so a non-blocking call here is correct
-				// if an error is not sent, then assume the default event kind
-				case err = <-conn.Errors():
-					if errors.Is(err, transport.ErrPeerClosedClean) {
-						kind = ExitDisconnected
-					}
-					if errors.Is(err, transport.ErrPeerClosedUnexpected) {
-						kind = ExitUnexpectedClose
-					}
-					if errors.Is(err, transport.ErrReadError) {
-						kind = ExitReadError
-					}
-				default:
-				}
-
-				if logger != nil {
-					if kind == ExitUnexpectedClose || kind == ExitReadError {
-						logger.Error("reader: peer dropped", "event", kind, "error", err)
-					} else {
-						logger.Info("reader: peer disconnected", "event", kind)
-					}
-				}
-
-				onPeerClose(kind)
-				return
-			}
-
-			messages <- types.ReceivedMessage{Data: data, ReceivedAt: time.Now()}
-
-			select {
-			case heartbeat <- struct{}{}:
-			case <-ctx.Done():
-				return
-			}
-		}
-	}
-}
-
-func RunHeartbeatForwarder(
-	ctx context.Context,
-	conn *transport.Connection,
-	heartbeat chan<- struct{},
-	logger *slog.Logger,
-) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-conn.Heartbeat():
-			select {
-			case heartbeat <- struct{}{}:
-				if logger != nil {
-					logger.Debug("ping-pong heartbeat")
-				}
-			case <-ctx.Done():
-				return
-			}
-		}
-	}
-}
-
-func RunForwarder(
-	id string,
-	ctx context.Context,
-	messages <-chan types.ReceivedMessage,
-	inbox chan<- types.InboxMessage,
-	workerProcessedCount *atomic.Uint64,
-	poolInboxCount *atomic.Uint64,
-) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case msg, ok := <-messages:
-			if !ok {
-				return
-			}
-			select {
-			case <-ctx.Done():
-				return
-
-			case inbox <- types.InboxMessage{
-				ID:         id,
-				Data:       msg.Data,
-				ReceivedAt: msg.ReceivedAt,
-			}:
-				workerProcessedCount.Add(1)
-				poolInboxCount.Add(1)
-			}
-		}
-	}
-}
-
-func RunWatchdog(
-	ctx context.Context,
-	onInactive OnExitFunction,
-	heartbeat <-chan struct{},
-	timeout time.Duration,
-	logger *slog.Logger,
-) {
-	// disable watchdog timeout if not configured
-	if timeout <= 0 {
-		if logger != nil {
-			logger.Debug("watchdog: disabled")
-		}
-		// drain heartbeats
-		// wait for cancel and exit
-		for {
-			select {
-			case <-heartbeat:
-			case <-ctx.Done():
-				return
-			}
-		}
-	}
-
-	if logger != nil {
-		logger.Debug("watchdog: enabled", "timeout", timeout)
-	}
-
-	timer := time.NewTimer(timeout)
-	defer timer.Stop()
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-heartbeat:
-			// drain the timer channel and reset
-			if !timer.Stop() {
-				select {
-				case <-timer.C:
-				default:
-				}
-			}
-			timer.Reset(timeout)
-		// timer completed
-		case <-timer.C:
-			// signal peer is inactive
-			if logger != nil {
-				logger.Info("watchdog: no activity observed")
-			}
-			onInactive(ExitPolicy)
-			return
-		}
-	}
-}

inbound/worker_forwarder_test.go

@@ -1,33 +0,0 @@
-package inbound
-
-import (
-	"context"
-	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
-	"git.wisehodl.dev/jay/go-honeybee/types"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-func TestRunForwarder(t *testing.T) {
-	t.Run("message passes through to inbox", func(t *testing.T) {
-		id := "wss://test"
-		messages := make(chan types.ReceivedMessage, 1)
-		inbox := make(chan types.InboxMessage, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		go RunForwarder(id, ctx, messages, inbox, &atomic.Uint64{}, &atomic.Uint64{})
-
-		messages <- types.ReceivedMessage{Data: []byte("hello"), ReceivedAt: time.Now()}
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case msg := <-inbox:
-				return string(msg.Data) == "hello" && msg.ID == "wss://test"
-			default:
-				return false
-			}
-		}, "expected message")
-	})
-}

inbound/worker_reader_test.go

@@ -1,213 +0,0 @@
-package inbound
-
-import (
-	"context"
-	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
-	"git.wisehodl.dev/jay/go-honeybee/transport"
-	"git.wisehodl.dev/jay/go-honeybee/types"
-	"github.com/gorilla/websocket"
-	"github.com/stretchr/testify/assert"
-	"io"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-func TestRunReader(t *testing.T) {
-	t.Run("message forwarded with correct data and non-zero receivedAt", func(t *testing.T) {
-		conn, _, incoming, _ := setupTestConnection(t)
-		defer conn.Close()
-
-		messages := make(chan types.ReceivedMessage, 1)
-		heartbeat := make(chan struct{}, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		go RunReader(ctx, func(WorkerExitKind) {}, conn, messages, heartbeat, nil)
-
-		before := time.Now()
-		incoming <- honeybeetest.MockIncomingData{MsgType: websocket.TextMessage, Data: []byte("hello")}
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case msg := <-messages:
-				return string(msg.Data) == "hello" && msg.ReceivedAt.After(before)
-			default:
-				return false
-			}
-		}, "expected message")
-	})
-
-	t.Run("heartbeat sent per forwarded message", func(t *testing.T) {
-		conn, _, incoming, _ := setupTestConnection(t)
-		defer conn.Close()
-
-		messages := make(chan types.ReceivedMessage, 10)
-		heartbeat := make(chan struct{}, 10)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		count := atomic.Int32{}
-		go func() {
-			for range heartbeat {
-				count.Add(1)
-			}
-		}()
-		go func() {
-			for range messages {
-			}
-		}()
-		go RunReader(ctx, func(WorkerExitKind) {}, conn, messages, heartbeat, nil)
-
-		const n = 3
-		for i := 0; i < n; i++ {
-			incoming <- honeybeetest.MockIncomingData{MsgType: websocket.TextMessage, Data: []byte("msg")}
-		}
-
-		honeybeetest.Eventually(t, func() bool {
-			return count.Load() == n
-		}, "expected heartbeats")
-	})
-
-	t.Run("clean close calls onPeerClose with ExitCleanDisconnect", func(t *testing.T) {
-		mock := honeybeetest.NewMockSocket()
-		mock.CloseFunc = func() error {
-			mock.Once.Do(func() { close(mock.Closed) })
-			return nil
-		}
-		mock.ReadMessageFunc = func() (int, []byte, error) {
-			return 0, nil, &websocket.CloseError{Code: websocket.CloseNormalClosure}
-		}
-
-		conn, err := transport.NewConnectionFromSocket(mock, nil, nil)
-		assert.NoError(t, err)
-
-		messages := make(chan types.ReceivedMessage, 1)
-		heartbeat := make(chan struct{}, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		var gotKind WorkerExitKind
-		done := make(chan struct{})
-		go RunReader(ctx, func(kind WorkerExitKind) {
-			gotKind = kind
-			close(done)
-		}, conn, messages, heartbeat, nil)
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case <-done:
-				return true
-			default:
-				return false
-			}
-		}, "expected onPeerClose")
-
-		assert.Equal(t, ExitDisconnected, gotKind)
-	})
-
-	t.Run("unexpected close calls onPeerClose with ExitUnexpectedDrop", func(t *testing.T) {
-		mock := honeybeetest.NewMockSocket()
-		mock.CloseFunc = func() error {
-			mock.Once.Do(func() { close(mock.Closed) })
-			return nil
-		}
-		mock.ReadMessageFunc = func() (int, []byte, error) {
-			return 0, nil, &websocket.CloseError{Code: websocket.CloseProtocolError}
-		}
-
-		conn, err := transport.NewConnectionFromSocket(mock, nil, nil)
-		assert.NoError(t, err)
-
-		messages := make(chan types.ReceivedMessage, 1)
-		heartbeat := make(chan struct{}, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		var gotKind WorkerExitKind
-		done := make(chan struct{})
-		go RunReader(ctx, func(kind WorkerExitKind) {
-			gotKind = kind
-			close(done)
-		}, conn, messages, heartbeat, nil)
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case <-done:
-				return true
-			default:
-				return false
-			}
-		}, "expected onPeerClose")
-
-		assert.Equal(t, ExitUnexpectedClose, gotKind)
-	})
-
-	t.Run("read error calls onPeerClose with ExitUnexpectedDrop", func(t *testing.T) {
-		mock := honeybeetest.NewMockSocket()
-		mock.CloseFunc = func() error {
-			mock.Once.Do(func() { close(mock.Closed) })
-			return nil
-		}
-		mock.ReadMessageFunc = func() (int, []byte, error) {
-			return 0, nil, io.EOF
-		}
-
-		conn, err := transport.NewConnectionFromSocket(mock, nil, nil)
-		assert.NoError(t, err)
-
-		messages := make(chan types.ReceivedMessage, 1)
-		heartbeat := make(chan struct{}, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		var gotKind WorkerExitKind
-		done := make(chan struct{})
-		go RunReader(ctx, func(kind WorkerExitKind) {
-			gotKind = kind
-			close(done)
-		}, conn, messages, heartbeat, nil)
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case <-done:
-				return true
-			default:
-				return false
-			}
-		}, "expected onPeerClose")
-
-		assert.Equal(t, ExitReadError, gotKind)
-	})
-
-	t.Run("ctx.Done exits without calling onPeerClose", func(t *testing.T) {
-		conn, _, _, _ := setupTestConnection(t)
-		defer conn.Close()
-
-		messages := make(chan types.ReceivedMessage, 1)
-		heartbeat := make(chan struct{}, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-
-		called := atomic.Bool{}
-		done := make(chan struct{})
-		go func() {
-			RunReader(ctx, func(WorkerExitKind) {
-				called.Store(true)
-			}, conn, messages, heartbeat, nil)
-			close(done)
-		}()
-
-		cancel()
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case <-done:
-				return true
-			default:
-				return false
-			}
-		}, "expected RunReader to exit")
-
-		assert.False(t, called.Load())
-	})
-}

inbound/worker_test.go

@@ -1,266 +0,0 @@
-package inbound
-
-import (
-	"context"
-	"fmt"
-	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
-	"git.wisehodl.dev/jay/go-honeybee/transport"
-	"git.wisehodl.dev/jay/go-honeybee/types"
-	"github.com/gorilla/websocket"
-	"github.com/stretchr/testify/assert"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-type workerTestVars struct {
-	worker   *DefaultWorker
-	conn     *transport.Connection
-	incoming chan honeybeetest.MockIncomingData
-	outgoing chan honeybeetest.MockOutgoingData
-	pool     PoolPlugin
-	inbox    chan types.InboxMessage
-	events   chan PoolEvent
-	exitKind *atomic.Value
-	wg       *sync.WaitGroup
-}
-
-func setupWorkerTest(t *testing.T) workerTestVars {
-	t.Helper()
-
-	conn, _, incoming, outgoing := setupTestConnection(t)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	var err error
-	worker, err := NewWorker(ctx, "peer-1", conn, nil, nil)
-	assert.NoError(t, err)
-	worker.cancel = cancel
-
-	inbox := make(chan types.InboxMessage, 256)
-	events := make(chan PoolEvent, 10)
-	exitKind := &atomic.Value{}
-
-	var once sync.Once
-	pool := PoolPlugin{
-		Inbox:  inbox,
-		Events: events,
-		OnExit: func(kind WorkerExitKind) {
-			once.Do(func() { exitKind.Store(kind) })
-		},
-		InboxCounter: &atomic.Uint64{},
-	}
-
-	wg := &sync.WaitGroup{}
-	wg.Add(1)
-
-	return workerTestVars{
-		worker:   worker,
-		conn:     conn,
-		incoming: incoming,
-		outgoing: outgoing,
-		pool:     pool,
-		inbox:    inbox,
-		events:   events,
-		exitKind: exitKind,
-		wg:       wg,
-	}
-}
-
-func TestWorkerStart(t *testing.T) {
-	t.Run("socket data arrives on inbox", func(t *testing.T) {
-		v := setupWorkerTest(t)
-		defer v.worker.Stop()
-
-		go v.worker.Start(v.pool)
-
-		v.incoming <- honeybeetest.MockIncomingData{
-			MsgType: websocket.TextMessage,
-			Data:    []byte("hello"),
-		}
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case msg := <-v.inbox:
-				return msg.ID == "peer-1" && string(msg.Data) == "hello"
-			default:
-				return false
-			}
-		}, "expected message on inbox")
-	})
-
-	t.Run("clean peer close calls OnExit with ExitCleanDisconnect", func(t *testing.T) {
-		v := setupWorkerTest(t)
-		defer v.worker.Stop()
-
-		go v.worker.Start(v.pool)
-
-		v.incoming <- honeybeetest.MockIncomingData{
-			Err: &websocket.CloseError{Code: websocket.CloseNormalClosure},
-		}
-
-		honeybeetest.Eventually(t, func() bool {
-			val := v.exitKind.Load()
-			return val != nil && val.(WorkerExitKind) == ExitDisconnected
-		}, "expected ExitCleanDisconnect")
-	})
-
-	t.Run("unexpected peer close calls OnExit with ExitUnexpectedDrop", func(t *testing.T) {
-		v := setupWorkerTest(t)
-		defer v.worker.Stop()
-
-		go v.worker.Start(v.pool)
-
-		v.incoming <- honeybeetest.MockIncomingData{
-			Err: &websocket.CloseError{Code: websocket.CloseProtocolError},
-		}
-
-		honeybeetest.Eventually(t, func() bool {
-			val := v.exitKind.Load()
-			return val != nil && val.(WorkerExitKind) == ExitUnexpectedClose
-		}, "expected ExitUnexpectedDrop")
-	})
-
-	t.Run("watchdog timeout calls OnExit with ExitInactive", func(t *testing.T) {
-		conn, _, _, _ := setupTestConnection(t)
-
-		ctx, cancel := context.WithCancel(context.Background())
-		worker, err := NewWorker(ctx, "peer-1", conn, &WorkerConfig{
-			InactivityTimeout: 20 * time.Millisecond,
-		}, nil)
-		assert.NoError(t, err)
-		worker.cancel = cancel
-		defer worker.Stop()
-
-		exitKind := &atomic.Value{}
-		var once sync.Once
-		pool := PoolPlugin{
-			Inbox:  make(chan types.InboxMessage, 256),
-			Events: make(chan PoolEvent, 10),
-			OnExit: func(kind WorkerExitKind) {
-				once.Do(func() { exitKind.Store(kind) })
-			},
-		}
-
-		var wg sync.WaitGroup
-		wg.Add(1)
-		go func() {
-			worker.Start(pool)
-			wg.Done()
-		}()
-
-		honeybeetest.Eventually(t, func() bool {
-			val := exitKind.Load()
-			return val != nil && val.(WorkerExitKind) == ExitPolicy
-		}, "expected ExitInactive")
-	})
-}
-
-func TestWorkerStop(t *testing.T) {
-	v := setupWorkerTest(t)
-
-	go func() { v.worker.Start(v.pool); v.wg.Done() }()
-
-	v.worker.Stop()
-
-	done := make(chan struct{})
-	go func() { v.wg.Wait(); close(done) }()
-
-	honeybeetest.Eventually(t, func() bool {
-		select {
-		case <-done:
-			return true
-		default:
-			return false
-		}
-	}, "expected wg to drain")
-
-	// does not call onExit
-	assert.Nil(t, v.exitKind.Load())
-}
-
-func TestWorkerSend(t *testing.T) {
-	t.Run("Send delivers data to socket", func(t *testing.T) {
-		v := setupWorkerTest(t)
-		defer v.worker.Stop()
-
-		go v.worker.Start(v.pool)
-
-		err := v.worker.Send([]byte("hello"))
-		assert.NoError(t, err)
-
-		honeybeetest.ExpectWrite(t, v.outgoing, websocket.TextMessage, []byte("hello"))
-	})
-
-	t.Run("Send produces heartbeats", func(t *testing.T) {
-		v := setupWorkerTest(t)
-		defer v.worker.Stop()
-
-		count := atomic.Int32{}
-		go func() {
-			for range v.worker.heartbeat {
-				count.Add(1)
-			}
-		}()
-
-		// do not start the worker, allow heartbeats to be drained manually
-
-		for i := 0; i < 3; i++ {
-			err := v.worker.Send([]byte(fmt.Sprintf("msg-%d", i)))
-			assert.NoError(t, err)
-		}
-
-		honeybeetest.Eventually(t, func() bool {
-			return count.Load() == 3
-		}, "expected heartbeats")
-	})
-
-	t.Run("Send returns error after connection closed", func(t *testing.T) {
-		v := setupWorkerTest(t)
-		defer v.worker.Stop()
-
-		go v.worker.Start(v.pool)
-
-		v.conn.Close()
-
-		honeybeetest.Eventually(t, func() bool {
-			return v.conn.State() == transport.StateClosed
-		}, "expected connection closed")
-
-		err := v.worker.Send([]byte("hello"))
-		assert.Error(t, err)
-	})
-}
-
-func TestHeartbeatForwarder(t *testing.T) {
-	t.Run("connection level heartbeat propagates", func(t *testing.T) {
-		socket, _, _ := honeybeetest.SetupTestSocket(t)
-		var pongHandler func(string) error
-		socket.SetPongHandlerFunc = func(h func(string) error) { pongHandler = h }
-
-		conn, err := transport.NewConnectionFromSocket(socket, nil, nil)
-		assert.NoError(t, err)
-
-		heartbeat := make(chan struct{}, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		go RunHeartbeatForwarder(ctx, conn, heartbeat, nil)
-
-		honeybeetest.Eventually(t, func() bool {
-			return pongHandler != nil
-		}, "expected Connection to register PongHandler")
-
-		if pongHandler == nil {
-			t.Fatal("pong handler was never set")
-		}
-
-		pongHandler("") // Trigger pong
-
-		select {
-		case <-heartbeat:
-		case <-time.After(time.Second):
-			t.Fatal("pong did not propagate to worker heartbeat")
-		}
-	})
-}

inbound/worker_watchdog_test.go

@@ -1,135 +0,0 @@
-package inbound
-
-import (
-	"context"
-	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
-	"github.com/stretchr/testify/assert"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-func TestRunWatchdog(t *testing.T) {
-	t.Run("heartbeat resets timer, onInactive not called", func(t *testing.T) {
-		heartbeat := make(chan struct{})
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		called := atomic.Bool{}
-		go RunWatchdog(ctx, func(WorkerExitKind) { called.Store(true) }, heartbeat, 200*time.Millisecond, nil)
-
-		for i := 0; i < 5; i++ {
-			time.Sleep(20 * time.Millisecond)
-			heartbeat <- struct{}{}
-		}
-
-		honeybeetest.Never(t, func() bool {
-			return called.Load()
-		}, "unexpected onInactive call")
-	})
-
-	t.Run("timeout fires onInactive exactly once", func(t *testing.T) {
-		heartbeat := make(chan struct{})
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		var gotKind WorkerExitKind
-		count := atomic.Int32{}
-		done := make(chan struct{})
-		go RunWatchdog(ctx, func(kind WorkerExitKind) {
-			count.Add(1)
-			gotKind = kind
-			close(done)
-		}, heartbeat, 20*time.Millisecond, nil)
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case <-done:
-				return true
-			default:
-				return false
-			}
-		}, "expected onInactive")
-
-		assert.Equal(t, int32(1), count.Load())
-		assert.Equal(t, ExitPolicy, gotKind)
-	})
-
-	t.Run("ctx.Done exits without calling onInactive", func(t *testing.T) {
-		heartbeat := make(chan struct{})
-		ctx, cancel := context.WithCancel(context.Background())
-
-		called := atomic.Bool{}
-		done := make(chan struct{})
-		go func() {
-			RunWatchdog(ctx, func(WorkerExitKind) { called.Store(true) }, heartbeat, 20*time.Second, nil)
-			close(done)
-		}()
-
-		cancel()
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case <-done:
-				return true
-			default:
-				return false
-			}
-		}, "expected RunWatchdog to exit")
-
-		assert.False(t, called.Load())
-	})
-
-	t.Run("zero timeout exits on ctx.Done without firing onInactive", func(t *testing.T) {
-		heartbeat := make(chan struct{})
-		ctx, cancel := context.WithCancel(context.Background())
-
-		called := atomic.Bool{}
-		done := make(chan struct{})
-		go func() {
-			RunWatchdog(ctx, func(WorkerExitKind) { called.Store(true) }, heartbeat, 0, nil)
-			close(done)
-		}()
-
-		cancel()
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case <-done:
-				return true
-			default:
-				return false
-			}
-		}, "expected RunWatchdog to exit")
-
-		assert.False(t, called.Load())
-	})
-
-	t.Run("disabled keepalive drains heartbeats without blocking", func(t *testing.T) {
-		heartbeat := make(chan struct{})
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		done := make(chan struct{})
-		go func() {
-			RunWatchdog(ctx, func(WorkerExitKind) {}, heartbeat, 0, nil)
-			close(done)
-		}()
-
-		// these must not block
-		for i := 0; i < 5; i++ {
-			heartbeat <- struct{}{}
-		}
-
-		cancel()
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case <-done:
-				return true
-			default:
-				return false
-			}
-		}, "expected RunWatchdog to exit")
-	})
-}

pool.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"

pool_test.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"

queue/queue.go

@@ -1,131 +0,0 @@
-package queue
-
-import (
-	"context"
-	"git.wisehodl.dev/jay/go-honeybee/types"
-	"sync/atomic"
-)
-
-func RunQueue(
-	id string,
-	ctx context.Context,
-	in <-chan types.ReceivedMessage,
-	out chan<- types.ReceivedMessage,
-	maxQueueSize int,
-	droppedCount *atomic.Uint64,
-	bufferDepth *atomic.Int64,
-) {
-	var next types.ReceivedMessage
-	var queue messageQueue
-	if maxQueueSize > 0 {
-		queue = newBoundedRing(maxQueueSize)
-	} else {
-		queue = newUnboundedRing(1024)
-	}
-
-	for {
-		var outOrNil chan<- types.ReceivedMessage
-
-		// enable out channel if queue is populated
-		if queue.len() > 0 {
-			outOrNil = out
-			next = queue.peek()
-		}
-
-		select {
-		case <-ctx.Done():
-			return
-		case msg := <-in:
-			// limit queue size if maximum is configured
-			if maxQueueSize > 0 && queue.len() >= maxQueueSize {
-				// drop oldest message
-				_ = queue.pop()
-				droppedCount.Add(1)
-				bufferDepth.Add(-1)
-			}
-			// add new message
-			queue.push(msg)
-			bufferDepth.Add(1)
-		// send next message to out channel
-		case outOrNil <- next:
-			_ = queue.pop()
-			bufferDepth.Add(-1)
-		}
-	}
-}
-
-// Ring Buffer Queue
-
-type messageQueue interface {
-	push(types.ReceivedMessage)
-	pop() types.ReceivedMessage
-	peek() types.ReceivedMessage
-	len() int
-}
-
-type ring struct {
-	buf  []types.ReceivedMessage
-	head int
-	size int
-}
-
-func (r *ring) len() int { return r.size }
-
-func (r *ring) pop() types.ReceivedMessage {
-	m := r.buf[r.head]
-	var zero types.ReceivedMessage
-	r.buf[r.head] = zero // release reference for GC
-	r.head = (r.head + 1) % len(r.buf)
-	r.size--
-	return m
-}
-
-func (r *ring) peek() types.ReceivedMessage {
-	m := r.buf[r.head]
-	return m
-}
-
-// shared write at logical tail; caller guarantees space exists
-func (r *ring) writeTail(m types.ReceivedMessage) {
-	r.buf[(r.head+r.size)%len(r.buf)] = m
-	r.size++
-}
-
-// Bounded ring
-
-type boundedRing struct{ ring }
-
-func newBoundedRing(cap int) *boundedRing {
-	return &boundedRing{ring{buf: make([]types.ReceivedMessage, cap)}}
-}
-
-func (b *boundedRing) push(m types.ReceivedMessage) {
-	if b.size == len(b.buf) {
-		b.buf[b.head] = m
-		b.head = (b.head + 1) % len(b.buf)
-		return
-	}
-	b.writeTail(m)
-}
-
-// Unbounded Ring
-
-type unboundedRing struct{ ring }
-
-func newUnboundedRing(initialCap int) *unboundedRing {
-	if initialCap < 1 {
-		initialCap = 1
-	}
-	return &unboundedRing{ring{buf: make([]types.ReceivedMessage, initialCap)}}
-}
-
-func (u *unboundedRing) push(m types.ReceivedMessage) {
-	if u.size == len(u.buf) {
-		bigger := make([]types.ReceivedMessage, len(u.buf)*2)
-		n := copy(bigger, u.buf[u.head:])
-		copy(bigger[n:], u.buf[:u.head])
-		u.buf = bigger
-		u.head = 0
-	}
-	u.writeTail(m)
-}

queue/queue_test.go

@@ -1,105 +0,0 @@
-package queue
-
-import (
-	"context"
-	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
-	"git.wisehodl.dev/jay/go-honeybee/types"
-	"github.com/stretchr/testify/assert"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-func TestRunQueue(t *testing.T) {
-	t.Run("message passes through to inbox", func(t *testing.T) {
-		id := "wss://test"
-		inChan := make(chan types.ReceivedMessage, 1)
-		outChan := make(chan types.ReceivedMessage, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		go RunQueue(id, ctx, inChan, outChan, 0, &atomic.Uint64{}, &atomic.Int64{})
-
-		inChan <- types.ReceivedMessage{Data: []byte("hello"), ReceivedAt: time.Now()}
-
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case msg := <-outChan:
-				return string(msg.Data) == "hello"
-			default:
-				return false
-			}
-		}, "expected message")
-	})
-
-	t.Run("oldest message dropped when queue is full", func(t *testing.T) {
-		id := "wss://test"
-		inChan := make(chan types.ReceivedMessage, 1)
-		outChan := make(chan types.ReceivedMessage, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		gate := make(chan struct{})
-		gatedInbox := make(chan types.ReceivedMessage)
-
-		// gate the inbox from receiving messages until the gate is opened
-		go func() {
-			<-gate
-			for msg := range gatedInbox {
-				outChan <- msg
-			}
-		}()
-
-		go RunQueue(id, ctx, inChan, gatedInbox, 2, &atomic.Uint64{}, &atomic.Int64{})
-
-		// send three messages while the gated inbox is blocked
-		inChan <- types.ReceivedMessage{Data: []byte("first"), ReceivedAt: time.Now()}
-		inChan <- types.ReceivedMessage{Data: []byte("second"), ReceivedAt: time.Now()}
-		inChan <- types.ReceivedMessage{Data: []byte("third"), ReceivedAt: time.Now()}
-
-		// allow time for the first message to be dropped
-		time.Sleep(20 * time.Millisecond)
-
-		// close the gate, draining messages into the inbox
-		close(gate)
-
-		// receive messages from the inbox
-		var received []string
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case msg := <-outChan:
-				received = append(received, string(msg.Data))
-			default:
-			}
-			return len(received) == 2
-		}, "expected messages")
-
-		// first message was dropped
-		assert.Equal(t, []string{"second", "third"}, received)
-
-	})
-
-	t.Run("exits on context cancellation", func(t *testing.T) {
-		id := "wss://test"
-		inChan := make(chan types.ReceivedMessage, 1)
-		outChan := make(chan types.ReceivedMessage, 1)
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		done := make(chan struct{})
-		go func() {
-			RunQueue(id, ctx, inChan, outChan, 0, &atomic.Uint64{}, &atomic.Int64{})
-			close(done)
-		}()
-
-		cancel()
-		honeybeetest.Eventually(t, func() bool {
-			select {
-			case <-done:
-				return true
-			default:
-				return false
-			}
-		}, "expected done signal")
-	})
-}

worker.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"

worker_dialer_test.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"

worker_keepalive_test.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"

worker_send_test.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"

worker_session_inner_test.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"

worker_session_test.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"

worker_start_test.go

@@ -1,4 +1,4 @@
-package outbound
+package honeybee
 
 import (
 	"context"