jay/go-honeybee
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Various performance and correctness improvements.

Browse Source
This commit is contained in:
Jay
2026-04-20 22:41:37 -04:00
parent 72b1ca7ad1
commit daf9f7534e
25 changed files with 577 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files
inbound/config.go
+43
View File
@@ -99,6 +99,9 @@ type WorkerFactory func(
) (Worker, error)
type PoolConfig struct {
InboxBufferSize int
EventsBufferSize int
ErrorsBufferSize int
ConnectionConfig *transport.ConnectionConfig
WorkerConfig *WorkerConfig
WorkerFactory WorkerFactory
@@ -119,6 +122,9 @@ func NewPoolConfig(options ...PoolOption) (*PoolConfig, error) {
func GetDefaultPoolConfig() *PoolConfig {
return &PoolConfig{
InboxBufferSize: 256,
EventsBufferSize: 10,
ErrorsBufferSize: 10,
ConnectionConfig: nil,
WorkerConfig: nil,
WorkerFactory: nil,
@@ -148,6 +154,43 @@ func ValidatePoolConfig(config *PoolConfig) error {
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 WithErrorsBufferSize(value int) PoolOption {
return func(c *PoolConfig) error {
if err := validateBufferSize(value); err != nil {
return err
}
c.ErrorsBufferSize = value
return nil
}
}
func WithConnectionConfig(cc *transport.ConnectionConfig) PoolOption {
return func(c *PoolConfig) error {
if err := transport.ValidateConnectionConfig(cc); err != nil {
inbound/config_test.go
+17
View File
@@ -101,8 +101,12 @@ func TestNewPoolConfig(t *testing.T) {
func TestDefaultPoolConfig(t *testing.T) {
conf := GetDefaultPoolConfig()
assert.Equal(t, &PoolConfig{
InboxBufferSize: 256,
EventsBufferSize: 10,
ErrorsBufferSize: 10,
ConnectionConfig: nil,
WorkerConfig: nil,
WorkerFactory: nil,
}, conf)
}
@@ -160,6 +164,19 @@ func TestValidatePoolConfig(t *testing.T) {
}
}
func TestWithBufferSizes(t *testing.T) {
conf := &PoolConfig{}
err := applyPoolOptions(conf,
WithInboxBufferSize(100),
WithEventsBufferSize(20),
WithErrorsBufferSize(20),
)
assert.NoError(t, err)
assert.Equal(t, 100, conf.InboxBufferSize)
assert.Equal(t, 20, conf.EventsBufferSize)
}
func TestWithConnectionConfig(t *testing.T) {
conf := &PoolConfig{}
inbound/errors.go
+1
View File
@@ -12,4 +12,5 @@ var (
// 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/pool.go
+14 -5
View File
@@ -42,6 +42,7 @@ type InboxMessage struct {
type PoolPlugin struct {
Inbox chan<- InboxMessage
Events chan<- PoolEvent
Errors chan<- error
Logger *slog.Logger
OnExit OnExitFunction
}
@@ -62,6 +63,7 @@ type Pool struct {
peers map[string]*Peer
inbox chan InboxMessage
events chan PoolEvent
errors chan error
config *PoolConfig
logger *slog.Logger
@@ -100,8 +102,9 @@ func NewPool(ctx context.Context, config *PoolConfig, logger *slog.Logger) (*Poo
ctx: pctx,
cancel: cancel,
peers: make(map[string]*Peer),
inbox: make(chan InboxMessage, 256),
events: make(chan PoolEvent, 10),
inbox: make(chan InboxMessage, config.InboxBufferSize),
events: make(chan PoolEvent, config.EventsBufferSize),
errors: make(chan error, config.ErrorsBufferSize),
config: config,
logger: logger,
}, nil
@@ -127,6 +130,10 @@ func (p *Pool) Events() <-chan PoolEvent {
return p.events
}
func (p *Pool) Errors() <-chan error {
return p.errors
}
func (p *Pool) Close() {
p.mu.Lock()
if p.closed {
@@ -137,21 +144,22 @@ func (p *Pool) Close() {
p.closed = true
p.cancel()
// remove all peers
p.peers = make(map[string]*Peer)
// 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)
close(p.errors)
}()
}
@@ -263,6 +271,7 @@ func (p *Pool) addLocked(id string, socket types.Socket) error {
pool := PoolPlugin{
Inbox: p.inbox,
Events: p.events,
Errors: p.errors,
Logger: logger,
OnExit: onExit,
}
inbound/worker.go
+28 -42
View File
@@ -1,10 +1,11 @@
package inbound
import (
"container/list"
"context"
"errors"
"git.wisehodl.dev/jay/go-honeybee/queue"
"git.wisehodl.dev/jay/go-honeybee/transport"
"git.wisehodl.dev/jay/go-honeybee/types"
"sync"
"time"
)
@@ -23,11 +24,6 @@ const (
ExitPolicy
)
type ReceivedMessage struct {
data []byte
receivedAt time.Time
}
type DefaultWorker struct {
id string
conn *transport.Connection
@@ -62,19 +58,25 @@ func NewWorker(
}
func (w *DefaultWorker) Start(pool PoolPlugin) {
messages := make(chan ReceivedMessage, 256)
toQueue := make(chan types.ReceivedMessage, 256)
toForwarder := make(chan types.ReceivedMessage, 256)
var wg sync.WaitGroup
wg.Add(3)
wg.Add(4)
go func() {
defer wg.Done()
RunReader(w.ctx, pool.OnExit, w.conn, messages, w.heartbeat)
RunReader(w.ctx, pool.OnExit, w.conn, toQueue, w.heartbeat)
}()
go func() {
defer wg.Done()
RunForwarder(w.id, w.ctx, messages, pool.Inbox, w.config.MaxQueueSize)
queue.RunQueue(w.id, w.ctx, toQueue, toForwarder, w.config.MaxQueueSize)
}()
go func() {
defer wg.Done()
RunForwarder(w.id, w.ctx, toForwarder, pool.Inbox)
}()
go func() {
@@ -107,7 +109,7 @@ func RunReader(
onPeerClose OnExitFunction,
conn *transport.Connection,
messages chan<- ReceivedMessage,
messages chan<- types.ReceivedMessage,
heartbeat chan<- struct{},
) {
for {
@@ -134,7 +136,7 @@ func RunReader(
return
}
messages <- ReceivedMessage{data: data, receivedAt: time.Now()}
messages <- types.ReceivedMessage{Data: data, ReceivedAt: time.Now()}
select {
case heartbeat <- struct{}{}:
@@ -148,43 +150,27 @@ func RunReader(
func RunForwarder(
id string,
ctx context.Context,
messages <-chan ReceivedMessage,
messages <-chan types.ReceivedMessage,
inbox chan<- InboxMessage,
maxQueueSize int,
) {
queue := list.New()
for {
var out chan<- InboxMessage
var next ReceivedMessage
// enable inbox if it is populated
if queue.Len() > 0 {
out = inbox
// read the first message in the queue
next = queue.Front().Value.(ReceivedMessage)
}
select {
case <-ctx.Done():
return
case msg := <-messages:
// limit queue size if maximum is configured
if maxQueueSize > 0 && queue.Len() >= maxQueueSize {
// drop oldest message
queue.Remove(queue.Front())
case msg, ok := <-messages:
if !ok {
return
}
select {
case <-ctx.Done():
return
case inbox <- InboxMessage{
ID: id,
Data: msg.Data,
ReceivedAt: msg.ReceivedAt,
}:
}
// add new message
queue.PushBack(msg)
// send next message to inbox
case out <- InboxMessage{
ID: id,
Data: next.data,
ReceivedAt: next.receivedAt,
}:
// drop message from queue
queue.Remove(queue.Front())
}
}
}
inbound/worker_forwarder_test.go
+4 -75
View File
@@ -3,7 +3,7 @@ package inbound
import (
"context"
"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
"github.com/stretchr/testify/assert"
"git.wisehodl.dev/jay/go-honeybee/types"
"testing"
"time"
)
@@ -11,14 +11,14 @@ import (
func TestRunForwarder(t *testing.T) {
t.Run("message passes through to inbox", func(t *testing.T) {
id := "wss://test"
messages := make(chan ReceivedMessage, 1)
messages := make(chan types.ReceivedMessage, 1)
inbox := make(chan InboxMessage, 1)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go RunForwarder(id, ctx, messages, inbox, 0)
go RunForwarder(id, ctx, messages, inbox)
messages <- ReceivedMessage{data: []byte("hello"), receivedAt: time.Now()}
messages <- types.ReceivedMessage{Data: []byte("hello"), ReceivedAt: time.Now()}
honeybeetest.Eventually(t, func() bool {
select {
@@ -29,75 +29,4 @@ func TestRunForwarder(t *testing.T) {
}
}, "expected message")
})
t.Run("oldest message dropped when queue is full", func(t *testing.T) {
id := "wss://test"
messages := make(chan ReceivedMessage, 1)
inbox := make(chan InboxMessage, 1)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
gate := make(chan struct{})
gatedInbox := make(chan InboxMessage)
// gate the inbox from receiving messages until the gate is opened
go func() {
<-gate
for msg := range gatedInbox {
inbox <- msg
}
}()
go RunForwarder(id, ctx, messages, gatedInbox, 2)
// send three messages while the gated inbox is blocked
messages <- ReceivedMessage{data: []byte("first"), receivedAt: time.Now()}
messages <- ReceivedMessage{data: []byte("second"), receivedAt: time.Now()}
messages <- 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 := <-inbox:
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"
messages := make(chan ReceivedMessage, 1)
inbox := make(chan InboxMessage, 1)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
go func() {
RunForwarder(id, ctx, messages, inbox, 0)
close(done)
}()
cancel()
honeybeetest.Eventually(t, func() bool {
select {
case <-done:
return true
default:
return false
}
}, "expected done signal")
})
}
inbound/worker_reader_test.go
+8 -7
View File
@@ -4,6 +4,7 @@ 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"
@@ -17,7 +18,7 @@ func TestRunReader(t *testing.T) {
conn, _, incoming, _ := setupTestConnection(t)
defer conn.Close()
messages := make(chan ReceivedMessage, 1)
messages := make(chan types.ReceivedMessage, 1)
heartbeat := make(chan struct{}, 1)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -30,7 +31,7 @@ func TestRunReader(t *testing.T) {
honeybeetest.Eventually(t, func() bool {
select {
case msg := <-messages:
return string(msg.data) == "hello" && msg.receivedAt.After(before)
return string(msg.Data) == "hello" && msg.ReceivedAt.After(before)
default:
return false
}
@@ -41,7 +42,7 @@ func TestRunReader(t *testing.T) {
conn, _, incoming, _ := setupTestConnection(t)
defer conn.Close()
messages := make(chan ReceivedMessage, 10)
messages := make(chan types.ReceivedMessage, 10)
heartbeat := make(chan struct{}, 10)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -81,7 +82,7 @@ func TestRunReader(t *testing.T) {
conn, err := transport.NewConnectionFromSocket(mock, nil, nil)
assert.NoError(t, err)
messages := make(chan ReceivedMessage, 1)
messages := make(chan types.ReceivedMessage, 1)
heartbeat := make(chan struct{}, 1)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -118,7 +119,7 @@ func TestRunReader(t *testing.T) {
conn, err := transport.NewConnectionFromSocket(mock, nil, nil)
assert.NoError(t, err)
messages := make(chan ReceivedMessage, 1)
messages := make(chan types.ReceivedMessage, 1)
heartbeat := make(chan struct{}, 1)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -155,7 +156,7 @@ func TestRunReader(t *testing.T) {
conn, err := transport.NewConnectionFromSocket(mock, nil, nil)
assert.NoError(t, err)
messages := make(chan ReceivedMessage, 1)
messages := make(chan types.ReceivedMessage, 1)
heartbeat := make(chan struct{}, 1)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -183,7 +184,7 @@ func TestRunReader(t *testing.T) {
conn, _, _, _ := setupTestConnection(t)
defer conn.Close()
messages := make(chan ReceivedMessage, 1)
messages := make(chan types.ReceivedMessage, 1)
heartbeat := make(chan struct{}, 1)
ctx, cancel := context.WithCancel(context.Background())