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

Remove root honeybee package; promote inbound and outbound as primary API

Browse Source 
- Delete honeybee.go (coincidental-strength re-export module)
- Add Socket, InboxMessage, NormalizeURL re-exports to inbound/pool.go
- Add InboxMessage, Dialer, NormalizeURL re-exports to outbound/pool.go
- Add Socket, Dialer re-exports to honeybeetest/mocks.go
- Update README, CONFIG, EXTEND to reflect new import structure
This commit is contained in:
Jay
2026-05-18 09:25:55 -04:00
parent 9616764899
commit b8a2d47846
7 changed files with 103 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CONFIG.md
+35 -29
View File
@@ -8,7 +8,9 @@ Logging can be controlled independently at the pool, worker, and connection leve
## Connection Options
These are passed to `NewConnectionConfig` or supplied via `WithInboundConnectionConfig` / `WithOutboundConnectionConfig`.
`ConnectionConfig` is defined in the `transport` package. Import `git.wisehodl.dev/jay/go-honeybee/transport` to construct one, then pass it to a pool via `inbound.WithConnectionConfig` or `outbound.WithConnectionConfig`.
These options are passed to `transport.NewConnectionConfig`.
### Write Behavior
@@ -63,95 +65,99 @@ Overrides the minimum log level for connection-scoped records. Does not affect p
## Inbound Pool Options
Import `git.wisehodl.dev/jay/go-honeybee/inbound`.
### Pool
These are passed to `NewInboundPoolConfig`.
These are passed to `inbound.NewPoolConfig`.
**`WithInboundInboxBufferSize(int)`**
**`inbound.WithInboxBufferSize(int)`**
Sets the capacity of the pool's shared inbox channel. Must be at least 1.
**`WithInboundEventsBufferSize(int)`**
**`inbound.WithEventsBufferSize(int)`**
Sets the capacity of the pool's events channel. Must be at least 1.
**`WithInboundPoolLoggingEnabled(bool)`**
**`inbound.WithPoolLoggingEnabled(bool)`**
Enables or disables pool-level logging.
**`WithInboundPoolLogLevel(slog.Level)`**
**`inbound.WithPoolLogLevel(slog.Level)`**
Overrides the minimum log level for pool-scoped records only.
### Worker
These are passed to `NewInboundWorkerConfig` or embedded in the pool config.
These are passed to `inbound.NewWorkerConfig` or embedded in the pool config.
**`WithInboundInactivityTimeout(duration)`**
Enables the inactivity watchdog. When no data messages or pong replies arrive within this duration, the peer is evicted and `InboundEventEvictedPolicy` is emitted. When set to zero, the watchdog is disabled and connections persist until removed or remotely terminated. Must not be negative.
**`inbound.WithInactivityTimeout(duration)`**
Enables the inactivity watchdog. When no data messages or pong replies arrive within this duration, the peer is evicted and `inbound.EventEvictedPolicy` is emitted. When set to zero, the watchdog is disabled and connections persist until removed or remotely terminated. Must not be negative.
**`WithInboundMaxQueueSize(int)`**
**`inbound.WithMaxQueueSize(int)`**
Bounds the worker's internal message queue. When the queue is full, the oldest undelivered message is dropped. When set to zero, the queue is unbounded. Must not be negative.
**`WithInboundWorkerLoggingEnabled(bool)`**
**`inbound.WithWorkerLoggingEnabled(bool)`**
Enables or disables worker-level logging.
**`WithInboundWorkerLogLevel(slog.Level)`**
**`inbound.WithWorkerLogLevel(slog.Level)`**
Overrides the minimum log level for worker-scoped records only.
### Wiring
**`WithInboundConnectionConfig(*ConnectionConfig)`**
**`inbound.WithConnectionConfig(*transport.ConnectionConfig)`**
Supplies a connection config that is applied to every socket added to the pool.
**`WithInboundWorkerConfig(*WorkerConfig)`**
**`inbound.WithWorkerConfig(*inbound.WorkerConfig)`**
Supplies a worker config that is applied to every worker the pool creates.
**`WithInboundWorkerFactory(WorkerFactory)`**
**`inbound.WithWorkerFactory(inbound.WorkerFactory)`**
Replaces the default worker constructor. See [EXTEND.md](EXTEND.md) for the factory contract.
## Outbound Pool Options
Import `git.wisehodl.dev/jay/go-honeybee/outbound`.
### Pool
These are passed to `NewOutboundPoolConfig`.
These are passed to `outbound.NewPoolConfig`.
**`WithOutboundInboxBufferSize(int)`**
**`outbound.WithInboxBufferSize(int)`**
Sets the capacity of the pool's shared inbox channel. Must be at least 1.
**`WithOutboundEventsBufferSize(int)`**
**`outbound.WithEventsBufferSize(int)`**
Sets the capacity of the pool's events channel. Must be at least 1.
**`WithOutboundPoolLoggingEnabled(bool)`**
**`outbound.WithPoolLoggingEnabled(bool)`**
Enables or disables pool-level logging.
**`WithOutboundPoolLogLevel(slog.Level)`**
**`outbound.WithPoolLogLevel(slog.Level)`**
Overrides the minimum log level for pool-scoped records only.
### Worker
These are passed to `NewOutboundWorkerConfig` or embedded in the pool config.
These are passed to `outbound.NewWorkerConfig` or embedded in the pool config.
**`WithOutboundKeepaliveTimeout(duration)`**
**`outbound.WithKeepaliveTimeout(duration)`**
Enables the keepalive mechanism. When no heartbeat (inbound data, outbound send, or pong reply) is observed within this duration, the current connection is closed and a new one is dialed. When set to zero, keepalive is disabled. Must not be negative.
**`WithReconnectDelay(duration)`**
**`outbound.WithReconnectDelay(duration)`**
Sets the delay between a disconnect and the next dial attempt. Applies after every session end, including those triggered by keepalive. The default of 2 seconds prevents tight reconnect loops against unavailable peers. Set to zero in tests or when immediate reconnection is required. Must not be negative.
**`WithOutboundMaxQueueSize(int)`**
**`outbound.WithMaxQueueSize(int)`**
Bounds the worker's internal message queue. When the queue is full, the oldest undelivered message is dropped. When set to zero, the queue is unbounded. Must not be negative.
**`WithOutboundWorkerLoggingEnabled(bool)`**
**`outbound.WithWorkerLoggingEnabled(bool)`**
Enables or disables worker-level logging.
**`WithOutboundWorkerLogLevel(slog.Level)`**
**`outbound.WithWorkerLogLevel(slog.Level)`**
Overrides the minimum log level for worker-scoped records only.
### Wiring
**`WithOutboundConnectionConfig(*ConnectionConfig)`**
**`outbound.WithConnectionConfig(*transport.ConnectionConfig)`**
Supplies a connection config used when dialing each peer.
**`WithOutboundWorkerConfig(*WorkerConfig)`**
**`outbound.WithWorkerConfig(*outbound.WorkerConfig)`**
Supplies a worker config applied to every worker the pool creates.
**`WithOutboundWorkerFactory(WorkerFactory)`**
**`outbound.WithWorkerFactory(outbound.WorkerFactory)`**
Replaces the default worker constructor. See [EXTEND.md](EXTEND.md) for the factory contract.
## Defaults
EXTEND.md
+23 -11
View File
@@ -30,18 +30,30 @@ The behavioral contract for each method:
The pool constructs a `PoolPlugin` and passes it to `Start`. It gives the worker access to pool-level channels and the logging handler.
```go
// inbound.PoolPlugin
type PoolPlugin struct {
Inbox chan<- InboxMessage
Events chan<- PoolEvent
Inbox chan<- inbound.InboxMessage
Events chan<- inbound.PoolEvent
InboxCounter *atomic.Uint64
OnExit OnExitFunction // inbound only
OnExit inbound.OnExitFunction // inbound only
Handler slog.Handler
}
// outbound.PoolPlugin
type PoolPlugin struct {
ID string
Inbox chan<- outbound.InboxMessage
Events chan<- outbound.PoolEvent
InboxCounter *atomic.Uint64
Dialer outbound.Dialer
ConnectionConfig *transport.ConnectionConfig
Handler slog.Handler
}
```
**`Inbox`** The shared channel that delivers received messages to the pool's consumer. All peers in the pool deliver to the same inbox channel. Workers must include their peer ID in each `InboxMessage`.
**`Events`** The shared channel for lifecycle events. Outbound workers emit `EventConnected` and `EventDisconnected` directly. Inbound workers do not touch this channel directly; instead they call `OnExit`, and the pool translates the exit kind into the appropriate event. All events include a timestamp in the `At` field.
**`Events`** The shared channel for lifecycle events. Outbound workers emit `outbound.EventConnected` and `outbound.EventDisconnected` directly. Inbound workers do not touch this channel directly; instead they call `OnExit`, and the pool translates the exit kind into the appropriate event. All events include a timestamp in the `At` field.
**`InboxCounter`** An atomic counter owned by the pool. Workers must increment this once for each message forwarded to `Inbox`. The pool reads it in `Stats()`.
@@ -54,18 +66,18 @@ type PoolPlugin struct {
### Factory Signature
```go
type WorkerFactory func(
type inbound.WorkerFactory func(
ctx context.Context,
id string,
conn *transport.Connection,
config *WorkerConfig,
config *inbound.WorkerConfig,
logger *slog.Logger,
) (Worker, error)
) (inbound.Worker, error)
```
The pool calls the factory under its write lock when `Add` or `Replace` is called. The factory must return without blocking. The pool constructs `logger` from the worker logging config before calling the factory; pass it to your worker or ignore it.
The factory is set via `WithInboundWorkerFactory` on the pool config.
The factory is set via `inbound.WithWorkerFactory` on the pool config.
### Building Blocks
@@ -94,16 +106,16 @@ The default inbound worker is assembled from these exported functions. Each can
### Factory Signature
```go
type WorkerFactory func(
type outbound.WorkerFactory func(
ctx context.Context,
id string,
logger *slog.Logger,
) (Worker, error)
) (outbound.Worker, error)
```
The pool calls the factory under its write lock when `Connect` is called. The factory must return without blocking. Note that the outbound factory does not receive a `*transport.Connection`; the worker is responsible for dialing and managing its own connections. The pool constructs `logger` from the worker logging config before calling the factory.
The factory is set via `WithOutboundWorkerFactory` on the pool config.
The factory is set via `outbound.WithWorkerFactory` on the pool config.
### Building Blocks
README.md
+26 -22
View File
@@ -5,8 +5,6 @@ WebSocket connection and pool primitives in Go. Built for Nostr.
## Library Map
```txt
honeybee.go top-level re-exports and constructors
transport/ single-connection primitives
connection.go *Connection, state machine, reader goroutine, pinger
config.go ConnectionConfig, RetryConfig, options
@@ -27,7 +25,7 @@ outbound/ pool for self-initiated connections
logging/ structured log construction
logging.go logger constructors, ForcedLevelHandler
types/ shared interfaces (Dialer, Socket)
types/ internal interfaces
honeybeetest/ test helpers and mocks for consumers
````
@@ -71,10 +69,12 @@ replace git.wisehodl.dev/jay/go-honeybee => github.com/wisehodl/go-honeybee late
### Bare Connection
A `Connection` wraps a single WebSocket. Use it directly when you need one socket and do not want pool semantics.
Use `transport` directly when you need one socket and do not want pool semantics.
```go
conn, err := honeybee.NewConnection("wss://example.com", nil, nil)
import "git.wisehodl.dev/jay/go-honeybee/transport"
conn, err := transport.NewConnection("wss://example.com", nil, nil)
if err != nil { /* handle error */ }
if err := conn.Connect(ctx); err != nil { /* handle error */ }
@@ -116,7 +116,9 @@ The inbound pool manages connections initiated by peers. The consumer accepts a
Each pool requires a non-empty string ID. This ID is attached to all structured log records emitted by the pool, its workers, and their connections.
```go
pool, err := honeybee.NewInboundPool(ctx, "my-pool", nil, handler)
import "git.wisehodl.dev/jay/go-honeybee/inbound"
pool, err := inbound.NewPool(ctx, "my-pool", nil, handler)
if err != nil { /* handle error */ }
defer pool.Close()
@@ -137,10 +139,10 @@ go func() {
for ev := range pool.Events() {
// ev.At is the event timestamp
switch ev.Kind {
case honeybee.InboundEventDisconnected: // clean close
case honeybee.InboundEventDroppedClose: // peer closed with abnormal code
case honeybee.InboundEventDroppedError: // read error
case honeybee.InboundEventEvictedPolicy: // inactivity timeout
case inbound.EventDisconnected: // clean close
case inbound.EventDroppedClose: // peer closed with abnormal code
case inbound.EventDroppedError: // read error
case inbound.EventEvictedPolicy: // inactivity timeout
}
}
}()
@@ -152,7 +154,7 @@ pool.Send(peerID, []byte("response"))
Use `Replace` if you need to swap the socket for a peer while keeping its ID. No events are emitted during this process.
The watchdog is configured via `WithInboundInactivityTimeout`. When set to zero, it is disabled. When set, the watchdog observes message traffic and disconnects the peer if no messages arrive within the configured duration. The watchdog is disabled by default, meaning connections persist until manually removed or remotely terminated.
The watchdog is configured via `inbound.WithInactivityTimeout`. When set to zero, it is disabled. When set, the watchdog observes message traffic and disconnects the peer if no messages arrive within the configured duration. The watchdog is disabled by default, meaning connections persist until manually removed or remotely terminated.
### Outbound Pool
@@ -161,7 +163,9 @@ The outbound pool connects to peers by their URLs and keeps them connected. It r
Each pool requires a non-empty string ID. This ID is attached to all structured log records emitted by the pool, its workers, and their connections.
```go
pool, err := honeybee.NewOutboundPool(ctx, "my-pool", nil, handler)
import "git.wisehodl.dev/jay/go-honeybee/outbound"
pool, err := outbound.NewPool(ctx, "my-pool", nil, handler)
if err != nil { /* handle error */ }
defer pool.Close()
@@ -179,8 +183,8 @@ go func() {
for ev := range pool.Events() {
// ev.At is the event timestamp
switch ev.Kind {
case honeybee.OutboundEventConnected:
case honeybee.OutboundEventDisconnected:
case outbound.EventConnected:
case outbound.EventDisconnected:
}
}
}()
@@ -188,11 +192,11 @@ go func() {
pool.Send("wss://peer.example.com", []byte("hello"))
```
URLs are normalized by the pool. `wss://peer.example.com`, `wss://peer.example.com/`, and `WSS://Peer.Example.Com:443` all identify the same peer. `honeybee.NormalizeURL` is also available directly if you need to use the same URLs as keys elsewhere.
URLs are normalized by the pool. `wss://peer.example.com`, `wss://peer.example.com/`, and `WSS://Peer.Example.Com:443` all identify the same peer. `outbound.NormalizeURL` is also available directly if you need to use the same URLs as keys elsewhere.
Every time a connection is established, `OutboundEventConnected` is emitted. Every time a connection drops for any reason, `OutboundEventDisconnected` is emitted. A peer that reconnects three times produces three Connected/Disconnected pairs.
Every time a connection is established, `outbound.EventConnected` is emitted. Every time a connection drops for any reason, `outbound.EventDisconnected` is emitted. A peer that reconnects three times produces three Connected/Disconnected pairs.
Keepalive is configured via `WithOutboundKeepaliveTimeout`. The worker records a heartbeat on every inbound message, every successful send, and every received pong. If no heartbeats arrive before the keepalive timer fires, the connection is proactively disconnected and reconnected. When set to zero, keepalive is disabled.
Keepalive is configured via `outbound.WithKeepaliveTimeout`. The worker records a heartbeat on every inbound message, every successful send, and every received pong. If no heartbeats arrive before the keepalive timer fires, the connection is proactively disconnected and reconnected. When set to zero, keepalive is disabled.
After a disconnect, the worker waits for `ReconnectDelay` before attempting the next connection. The default is 2 seconds. Set to zero in tests or when you need immediate reconnection.
@@ -208,7 +212,7 @@ For inbound workers, pong-derived heartbeats reset the inactivity watchdog timer
For outbound workers, pong-derived heartbeats reset the keepalive timer. A peer that sends no data but responds to pings will not be disconnected and reconnected by the keepalive mechanism.
The ping interval is configured via `WithPingInterval` on the `ConnectionConfig`. The default is 20 seconds. Set to zero to disable pings entirely, in which case only data messages and outbound sends generate heartbeats.
The ping interval is configured via `transport.WithPingInterval` on the `transport.ConnectionConfig`. Import `git.wisehodl.dev/jay/go-honeybee/transport` to construct a `ConnectionConfig`, then pass it to the pool via `inbound.WithConnectionConfig` or `outbound.WithConnectionConfig`. The default is 20 seconds. Set to zero to disable pings entirely, in which case only data messages and outbound sends generate heartbeats.
## Statistics
@@ -228,8 +232,8 @@ peerStats, err := pool.PeerStats(peerID)
// peerStats.Worker — queue depths, buffer depth, processed/dropped/sent counts
// peerStats.Connection — channel depths, receive/send/heartbeat counts (inbound)
// Bare connection
connStats := conn.Stats()
// Bare connection (transport package)
connStats := conn.Stats() // conn is a *transport.Connection
// connStats.TotalReceived, connStats.TotalSent, connStats.TotalHeartbeats
```
@@ -263,8 +267,8 @@ go test -race ./...
The `honeybeetest` package provides mocks and assertions for code that builds on Honeybee:
- `MockSocket` implements `types.Socket` with pluggable function fields for every method, including `WriteControl` and `SetPongHandler`.
- `MockDialer` implements `types.Dialer` with a pluggable `DialContextFunc`.
- `MockSocket` implements `honeybeetest.Socket` with pluggable function fields for every method, including `WriteControl` and `SetPongHandler`.
- `MockDialer` implements `honeybeetest.Dialer` with a pluggable `DialContextFunc`.
- `MockSlogHandler` captures `slog` records for assertions against log output. Child handlers produced via `WithAttrs` share the same record slice as the parent, so attributes added by the logging package appear on the correct records.
- `Eventually(t, condition, msg)` polls a condition until it holds or the test timeout expires.
- `Never(t, condition, msg)` asserts a condition never holds over a short window.
honeybee.go
-181
View File
@@ -1,181 +0,0 @@
package honeybee
import (
"context"
"log/slog"
"git.wisehodl.dev/jay/go-honeybee/inbound"
"git.wisehodl.dev/jay/go-honeybee/outbound"
"git.wisehodl.dev/jay/go-honeybee/transport"
"git.wisehodl.dev/jay/go-honeybee/types"
)
// Functions
func NormalizeURL(input string) (string, error) {
return transport.NormalizeURL(input)
}
// Connection types
type Connection = transport.Connection
type ConnectionConfig = transport.ConnectionConfig
type RetryConfig = transport.RetryConfig
type ConnectionOption = transport.ConnectionOption
type ConnectionStats = transport.ConnectionStats
// Common Types
type InboxMessage = types.InboxMessage
// Outbound Pool types
type OutboundPool = outbound.Pool
type OutboundPoolConfig = outbound.PoolConfig
type OutboundPoolOption = outbound.PoolOption
type OutboundWorkerConfig = outbound.WorkerConfig
type OutboundWorkerOption = outbound.WorkerOption
type OutboundPoolEvent = outbound.PoolEvent
type OutboundPoolEventKind = outbound.PoolEventKind
type OutboundPoolStats = outbound.PoolStats
type OutboundWorkerStats = outbound.WorkerStats
// Pool event constants
const (
OutboundEventConnected = outbound.EventConnected
OutboundEventDisconnected = outbound.EventDisconnected
)
// Inbound Pool types
type InboundPool = inbound.Pool
type InboundPoolConfig = inbound.PoolConfig
type InboundPoolOption = inbound.PoolOption
type InboundWorkerConfig = inbound.WorkerConfig
type InboundWorkerOption = inbound.WorkerOption
type InboundWorkerFactory = inbound.WorkerFactory
type InboundWorker = inbound.Worker
type InboundWorkerExitKind = inbound.WorkerExitKind
type InboundPoolEvent = inbound.PoolEvent
type InboundPoolEventKind = inbound.PoolEventKind
type InboundPoolStats = inbound.PoolStats
type InboundWorkerStats = inbound.WorkerStats
// Inbound Pool event constants
const (
InboundEventDisconnected = inbound.EventDisconnected
InboundEventDroppedClose = inbound.EventDroppedClose
InboundEventDroppedError = inbound.EventDroppedError
InboundEventEvictedPolicy = inbound.EventEvictedPolicy
)
// Inbound Worker exit kinds
const (
InboundExitDisconnected = inbound.ExitDisconnected
InboundExitUnexpectedClose = inbound.ExitUnexpectedClose
InboundExitReadError = inbound.ExitReadError
InboundExitPolicy = inbound.ExitPolicy
)
// Connection constructors
func NewConnection(url string, config *ConnectionConfig, logger *slog.Logger) (*Connection, error) {
return transport.NewConnection(url, config, logger)
}
func NewConnectionConfig(opts ...ConnectionOption) (*ConnectionConfig, error) {
return transport.NewConnectionConfig(opts...)
}
// Connection options
var (
WithIncomingBufferSize = transport.WithIncomingBufferSize
WithErrorsBufferSize = transport.WithErrorsBufferSize
WithoutRetry = transport.WithoutRetry
WithRetryMaxRetries = transport.WithRetryMaxRetries
WithRetryInitialDelay = transport.WithRetryInitialDelay
WithRetryMaxDelay = transport.WithRetryMaxDelay
WithRetryJitterFactor = transport.WithRetryJitterFactor
WithWriteTimeout = transport.WithWriteTimeout
WithCloseHandler = transport.WithCloseHandler
WithConnectionLoggingEnabled = transport.WithLoggingEnabled
WithConnectionLogLevel = transport.WithLogLevel
)
// Outbound Pool constructors
func NewOutboundPool(ctx context.Context, id string, config *OutboundPoolConfig, handler slog.Handler) (*OutboundPool, error) {
return outbound.NewPool(ctx, id, config, handler)
}
func NewOutboundPoolConfig(opts ...OutboundPoolOption) (*OutboundPoolConfig, error) {
return outbound.NewPoolConfig(opts...)
}
func NewOutboundWorkerConfig(opts ...OutboundWorkerOption) (*OutboundWorkerConfig, error) {
return outbound.NewWorkerConfig(opts...)
}
// Outbound Pool options
var (
WithOutboundInboxBufferSize = outbound.WithInboxBufferSize
WithOutboundEventsBufferSize = outbound.WithEventsBufferSize
WithOutboundPoolLoggingEnabled = outbound.WithPoolLoggingEnabled
WithOutboundPoolLogLevel = outbound.WithPoolLogLevel
WithOutboundConnectionConfig = outbound.WithConnectionConfig
WithOutboundWorkerConfig = outbound.WithWorkerConfig
WithOutboundWorkerFactory = outbound.WithWorkerFactory
)
// Outbound Worker options
var (
WithOutboundKeepaliveTimeout = outbound.WithKeepaliveTimeout
WithOutboundMaxQueueSize = outbound.WithMaxQueueSize
WithOutboundWorkerLoggingEnabled = outbound.WithWorkerLoggingEnabled
WithOutboundWorkerLogLevel = outbound.WithWorkerLogLevel
)
// Inbound Pool constructors
func NewInboundPool(ctx context.Context, id string, config *InboundPoolConfig, handler slog.Handler) (*InboundPool, error) {
return inbound.NewPool(ctx, id, config, handler)
}
func NewInboundPoolConfig(opts ...InboundPoolOption) (*InboundPoolConfig, error) {
return inbound.NewPoolConfig(opts...)
}
func NewInboundWorkerConfig(opts ...InboundWorkerOption) (*InboundWorkerConfig, error) {
return inbound.NewWorkerConfig(opts...)
}
// Inbound Pool options
var (
WithInboundInboxBufferSize = inbound.WithInboxBufferSize
WithInboundEventsBufferSize = inbound.WithEventsBufferSize
WithInboundPoolLoggingEnabled = inbound.WithPoolLoggingEnabled
WithInboundPoolLogLevel = inbound.WithPoolLogLevel
WithInboundConnectionConfig = inbound.WithConnectionConfig
WithInboundWorkerConfig = inbound.WithWorkerConfig
WithInboundWorkerFactory = inbound.WithWorkerFactory
)
// Inbound Worker options
var (
WithInboundInactivityTimeout = inbound.WithInactivityTimeout
WithInboundMaxQueueSize = inbound.WithMaxQueueSize
WithInboundWorkerLoggingEnabled = inbound.WithWorkerLoggingEnabled
WithInboundWorkerLogLevel = inbound.WithWorkerLogLevel
)
// Socket type — needed for inbound pool.Add and pool.Replace
type Socket = types.Socket
honeybeetest/mocks.go
+5
View File
@@ -9,6 +9,11 @@ import (
"time"
)
// Re-exported types for consumer convenience
type Socket = types.Socket
type Dialer = types.Dialer
// Dialer Mocks
type MockDialer struct {
inbound/pool.go
+7
View File
@@ -12,6 +12,13 @@ import (
"time"
)
// Re-exported types for consumer convenience
type Socket = types.Socket
type InboxMessage = types.InboxMessage
var NormalizeURL = transport.NormalizeURL
// Types
type PoolEventKind string
outbound/pool.go
+7
View File
@@ -11,6 +11,13 @@ import (
"time"
)
// Re-exported types for consumer convenience
type InboxMessage = types.InboxMessage
type Dialer = types.Dialer
var NormalizeURL = transport.NormalizeURL
// Types
type PoolEventKind string