Restructuring for worker development.

initiator/config.go

@@ -7,11 +7,7 @@ import (
 
 // Types
 
-type WorkerFactory func(
+type WorkerFactory func(id string, stop <-chan struct{}) Worker
-	id string,
-	conn *transport.Connection,
-	onReconnect func() (*transport.Connection, error),
-) Worker
 
 // Pool Config
 

initiator/pool.go

@@ -10,9 +10,20 @@ import (
 
 // Types
 
-type peer struct {
+type Peer struct {
-	conn *transport.Connection
+	id     string
-	stop chan struct{}
+	worker *Worker
+	stop   chan struct{}
+}
+
+type WorkerContext struct {
+	Inbox            chan<- InboxMessage
+	Events           chan<- PoolEvent
+	Errors           chan<- error
+	PoolDone         <-chan struct{}
+	Logger           *slog.Logger
+	Dialer           types.Dialer
+	ConnectionConfig *transport.ConnectionConfig
 }
 
 type InboxMessage struct {
@@ -21,24 +32,13 @@ type InboxMessage struct {
 	ReceivedAt time.Time
 }
 
-type PoolEventKind int
+type PoolEventKind string
 
 const (
-	EventConnected PoolEventKind = iota
+	EventConnected    PoolEventKind = "connected"
-	EventDisconnected
+	EventDisconnected               = "disconnected"
 )
 
-func (s PoolEventKind) String() string {
-	switch s {
-	case EventConnected:
-		return "connected"
-	case EventDisconnected:
-		return "disconnected"
-	default:
-		return "unknown"
-	}
-}
-
 type PoolEvent struct {
 	ID   string
 	Kind PoolEventKind
@@ -47,7 +47,7 @@ type PoolEvent struct {
 // Pool
 
 type Pool struct {
-	peers  map[string]*peer
+	peers  map[string]*Peer
 	inbox  chan InboxMessage
 	events chan PoolEvent
 	errors chan error
@@ -72,7 +72,7 @@ func NewPool(config *PoolConfig, logger *slog.Logger) (*Pool, error) {
 	}
 
 	p := &Pool{
-		peers:  make(map[string]*peer),
+		peers:  make(map[string]*Peer),
 		inbox:  make(chan InboxMessage, 256),
 		events: make(chan PoolEvent, 10),
 		errors: make(chan error, 10),
@@ -85,7 +85,7 @@ func NewPool(config *PoolConfig, logger *slog.Logger) (*Pool, error) {
 	return p, nil
 }
 
-func (p *Pool) Peers() map[string]*peer {
+func (p *Pool) Peers() map[string]*Peer {
 	return p.peers
 }
 
@@ -101,6 +101,10 @@ func (p *Pool) Errors() chan error {
 	return p.errors
 }
 
+func (p *Pool) SetDialer(d types.Dialer) {
+	p.dialer = d
+}
+
 func (p *Pool) Close() {
 	p.mu.Lock()
 	if p.closed {
@@ -112,12 +116,12 @@ func (p *Pool) Close() {
 	close(p.done)
 
 	peers := p.peers
-	p.peers = make(map[string]*peer)
+	p.peers = make(map[string]*Peer)
 
 	p.mu.Unlock()
 
-	for _, conn := range peers {
+	for _, p := range peers {
-		conn.conn.Close()
+		close(p.stop)
 	}
 
 	go func() {
@@ -180,11 +184,9 @@ func (p *Pool) Connect(id string) error {
 		conn.Close()
 		return NewPoolError("connection already exists")
 	}
-	p.peers[id] = &peer{conn: conn, stop: stop}
+	p.peers[id] = &Peer{id: id, worker: nil, stop: stop} // TODO: create worker
 	p.mu.Unlock()
 
-	// TODO: start this connection's incoming message forwarder
-
 	select {
 	case p.events <- PoolEvent{ID: id, Kind: EventConnected}:
 	case <-p.done:
@@ -215,7 +217,6 @@ func (p *Pool) Remove(id string) error {
 	p.mu.Unlock()
 
 	close(peer.stop)
-	peer.conn.Close()
 
 	select {
 	case p.events <- PoolEvent{ID: id, Kind: EventDisconnected}:
@@ -244,5 +245,5 @@ func (p *Pool) Send(id string, data []byte) error {
 		return NewPoolError("connection not found")
 	}
 
-	return peer.conn.Send(data)
+	return peer.worker.Send(data)
 }

initiator/pool_test.go

@@ -173,7 +173,8 @@ func TestPoolRemove(t *testing.T) {
 
 }
 
-func TestPoolSend(t *testing.T) {
+// TODO: update worker to be responsible for send
+func _TestPoolSend(t *testing.T) {
 	mockSocket := honeybeetest.NewMockSocket()
 	outgoingData := make(chan honeybeetest.MockOutgoingData, 10)
 	mockSocket.WriteMessageFunc = func(msgType int, data []byte) error {
@@ -218,5 +219,5 @@ func expectEvent(
 		}
 	}, honeybeetest.TestTimeout, honeybeetest.TestTick,
 		fmt.Sprintf("expected event: URL=%q, Kind=%q",
-			expectedURL, expectedKind.String()))
+			expectedURL, expectedKind))
 }

initiator/worker.go

@@ -2,51 +2,40 @@ package initiator
 
 import (
 	"git.wisehodl.dev/jay/go-honeybee/transport"
-	"log/slog"
 	"sync"
 	"time"
 )
 
-// Types
-
-type WorkerContext struct {
-	Inbox    chan<- InboxMessage
-	Events   chan<- PoolEvent
-	Errors   chan<- error
-	Stop     <-chan struct{}
-	PoolDone <-chan struct{}
-	Logger   *slog.Logger
-}
-
 // Worker
 
 type Worker struct {
-	id          string
+	id     string
-	config      *WorkerConfig
+	stop   <-chan struct{}
-	onReconnect func() (*transport.Connection, error)
+	config *WorkerConfig
+	conn   *transport.Connection
 }
 
 func NewWorker(
 	id string,
+	stop <-chan struct{},
 	config *WorkerConfig,
-	onReconnect func() (*transport.Connection, error),
-	logger *slog.Logger,
 
 ) (*Worker, error) {
 	w := &Worker{
-		id:          id,
+		id:     id,
-		config:      config,
+		stop:   stop,
-		onReconnect: onReconnect,
+		config: config,
 	}
 
 	return w, nil
 }
 
+func (w *Worker) Send(data []byte) error {
+	return w.conn.Send(data)
+}
+
 func (w *Worker) Start(
-	inbox chan<- InboxMessage,
+	ctx WorkerContext,
-	events chan<- PoolEvent,
-	stop <-chan struct{},
-	poolDone <-chan struct{},
 	wg *sync.WaitGroup,
 ) {
 }