xorbie

package module

Go to main page

Versions in this module

v0

v0.0.19

Sep 1, 2026

v0.0.18

Aug 29, 2026

v0.0.17

Aug 27, 2026

v0.0.16

Aug 27, 2026

v0.0.15

Aug 27, 2026

v0.0.14

Aug 27, 2026

Changes in this version

type Coordinator

+ func (c *Coordinator[K, N, M]) Publish(ctx context.Context, msg M) (coordt.PublishStats, error)

v0.0.13

Aug 26, 2026

Changes in this version

type EventOutboundGetCloserNodes

+ Deadline time.Time

type EventOutboundSendMessage

+ Deadline time.Time

type EventStartStaticPublish

+ Quorum int

v0.0.12

Aug 22, 2026

v0.0.11

Aug 22, 2026

Changes in this version

type Coordinator

+ func (c *Coordinator[K, N, M]) PublishFollowUp(ctx context.Context, msg M) (coordt.PublishStats, error)

+ func (c *Coordinator[K, N, M]) PublishOptimistic(ctx context.Context, msg M) (coordt.PublishStats, error)

+ func (c *Coordinator[K, N, M]) PublishStatic(ctx context.Context, msg M, nodes []N) (coordt.PublishStats, error)

type CoordinatorConfig

+ Publish PublishConfig[K, N, M]

type EventGetCloserNodesFailure

+ ActivityID coordt.ActivityID

type EventGetCloserNodesSuccess

+ ActivityID coordt.ActivityID

type EventOutboundGetCloserNodes

+ ActivityID coordt.ActivityID

type EventOutboundSendMessage

+ ActivityID coordt.ActivityID

+ type EventPublishFinished struct

+ ActivityID coordt.ActivityID

+ Contacted []N

+ Err error

+ Errors map[string]struct{ ... }

+ QueryStats query.QueryStats

type EventQueryFinished

+ ActivityID coordt.ActivityID

type EventQueryProgressed

+ ActivityID coordt.ActivityID

type EventSendMessageFailure

+ ActivityID coordt.ActivityID

type EventSendMessageSuccess

+ ActivityID coordt.ActivityID

type EventStartFindCloserQuery

+ ActivityID coordt.ActivityID

+ type EventStartFollowUpPublish struct

+ ActivityID coordt.ActivityID

+ KnownClosestNodes []N

+ Message M

+ Notify QueryMonitor[K, N, M, *EventPublishFinished[K, N]]

+ Target K

type EventStartMessageQuery

+ ActivityID coordt.ActivityID

+ type EventStartOptimisticPublish struct

+ ActivityID coordt.ActivityID

+ KnownClosestNodes []N

+ Message M

+ NetworkSize int

+ Notify QueryMonitor[K, N, M, *EventPublishFinished[K, N]]

+ Target K

+ type EventStartStaticPublish struct

+ ActivityID coordt.ActivityID

+ Message M

+ Nodes []N

+ Notify QueryMonitor[K, N, M, *EventPublishFinished[K, N]]

+ Target K

type EventStopQuery

+ ActivityID coordt.ActivityID

+ type PublishBehaviour struct

+ func NewPublishBehaviour[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]](publishPool *publish.Pool[K, N, M], self N, rt kad.RoutingTable[K, N], ...) (*PublishBehaviour[K, N, M], error)

+ func (b *PublishBehaviour[K, N, M]) Notify(ctx context.Context, ev BehaviourEvent)

+ func (b *PublishBehaviour[K, N, M]) Perform(ctx context.Context) (out BehaviourEvent, performed bool)

+ func (b *PublishBehaviour[K, N, M]) Ready() <-chan struct{}

+ type PublishCommand interface

+ type PublishConfig struct

+ EnableSurvey bool

+ Keystore keystore.Keystore[K]

+ Logger *slog.Logger

+ Meter metric.Meter

+ OptimisticIndividualCertainty float64

+ OptimisticSetStrictness float64

+ QueueCapacity int

+ RecordSource func(k K) M

+ RegionMaxInFlight int

+ RegionReplication int

+ SurveyInitialPrefixLen int

+ SurveyInterval time.Duration

+ SurveyMaxPopulation int

+ SurveyMinPopulation int

+ SurveyRegionTimeout time.Duration

+ SurveyRequestConcurrency int

+ SurveyRequestTimeout time.Duration

+ SurveyTargetFunc publish.PrefixTargetFunc[K]

+ SurveyWalkInBound int

+ Tracer trace.Tracer

+ VerifyResponse func(req, resp M) error

+ func DefaultPublishConfig[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]]() *PublishConfig[K, N, M]

+ func (cfg *PublishConfig[K, N, M]) Validate() error

+ type PublishWaiter struct

+ func NewPublishWaiter[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]](n int) *PublishWaiter[K, N, M]

+ func (w *PublishWaiter[K, N, M]) Finished() <-chan CtxEvent[*EventPublishFinished[K, N]]

+ func (w *PublishWaiter[K, N, M]) NotifyFinished() chan<- CtxEvent[*EventPublishFinished[K, N]]

+ func (w *PublishWaiter[K, N, M]) NotifyProgressed() chan<- CtxEvent[*EventQueryProgressed[K, N, M]]

+ func (w *PublishWaiter[K, N, M]) Progressed() <-chan CtxEvent[*EventQueryProgressed[K, N, M]]

type RoutingConfig

+ EnableExplore bool

+ ExploreCplFunc routing.NodeIDForCplFunc[K, N]

v0.0.10

Aug 18, 2026

v0.0.9

Aug 17, 2026

Changes in this version

type BroadcastConfig

+ OptimisticIndividualCertainty float64

+ OptimisticSetStrictness float64

type Coordinator

+ func (c *Coordinator[K, N, M]) BroadcastFollowUp(ctx context.Context, msg M) (coordt.BroadcastStats, error)

+ func (c *Coordinator[K, N, M]) BroadcastOptimistic(ctx context.Context, msg M) (coordt.BroadcastStats, error)

type CoordinatorConfig

+ ReplicationFactor int

type EventBroadcastFinished

+ QueryStats query.QueryStats

+ type EventStartFollowUpBroadcast struct

+ KnownClosestNodes []N

+ Message M

+ Notify QueryMonitor[K, N, M, *EventBroadcastFinished[K, N]]

+ QueryID coordt.QueryID

+ Target K

+ type EventStartOptimisticBroadcast struct

+ KnownClosestNodes []N

+ Message M

+ NetworkSize int

+ Notify QueryMonitor[K, N, M, *EventBroadcastFinished[K, N]]

+ QueryID coordt.QueryID

+ Target K

+ type EventStartStaticBroadcast struct

+ Message M

+ Nodes []N

+ Notify QueryMonitor[K, N, M, *EventBroadcastFinished[K, N]]

+ QueryID coordt.QueryID

+ Target K

v0.0.8

Aug 16, 2026

v0.0.7

Aug 16, 2026

v0.0.6

Aug 16, 2026

Changes in this version

type Coordinator

+ func (c *Coordinator[K, N, M]) NetworkSize() (netsize.Estimate, error)

type QueryConfig

+ NetworkSize *netsize.Estimator[K, N]

type RoutingConfig

+ NetworkSize *netsize.Estimator[K, N]

v0.0.5

Aug 15, 2026

v0.0.4

Aug 15, 2026

v0.0.3

Aug 15, 2026

v0.0.2

Aug 15, 2026

v0.0.1

Aug 15, 2026

Changes in this version

+ const IncludeQueryID

+ const ProbeQueryID

+ var ErrEventDropped = errors.New("event dropped")

+ var ErrRequestDropped = errors.New("request dropped")

+ type Behaviour interface

+ Notify func(ctx context.Context, ev I)

+ Perform func(ctx context.Context) (O, bool)

+ Ready func() <-chan struct{}

+ type BehaviourEvent interface

+ type BrdcstCommand interface

+ type BroadcastConfig struct

+ Logger *slog.Logger

+ Meter metric.Meter

+ QueueCapacity int

+ Tracer trace.Tracer

+ VerifyResponse func(req, resp M) error

+ func DefaultBroadcastConfig[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]]() *BroadcastConfig[K, N, M]

+ func (cfg *BroadcastConfig[K, N, M]) Validate() error

+ type BroadcastWaiter struct

+ func NewBroadcastWaiter[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]](n int) *BroadcastWaiter[K, N, M]

+ func (w *BroadcastWaiter[K, N, M]) Finished() <-chan CtxEvent[*EventBroadcastFinished[K, N]]

+ func (w *BroadcastWaiter[K, N, M]) NotifyFinished() chan<- CtxEvent[*EventBroadcastFinished[K, N]]

+ func (w *BroadcastWaiter[K, N, M]) NotifyProgressed() chan<- CtxEvent[*EventQueryProgressed[K, N, M]]

+ func (w *BroadcastWaiter[K, N, M]) Progressed() <-chan CtxEvent[*EventQueryProgressed[K, N, M]]

+ type BufferedRoutingNotifier struct

+ func NewBufferedRoutingNotifier[K kad.Key[K], N kad.NodeID[K]]() *BufferedRoutingNotifier[K, N]

+ func (w *BufferedRoutingNotifier[K, N]) Expect(ctx context.Context, expected RoutingNotification) (RoutingNotification, error)

+ func (w *BufferedRoutingNotifier[K, N]) ExpectRoutingRemoved(ctx context.Context, id N) (*EventRoutingRemoved[K, N], error)

+ func (w *BufferedRoutingNotifier[K, N]) ExpectRoutingUpdated(ctx context.Context, id N) (*EventRoutingUpdated[K, N], error)

+ func (w *BufferedRoutingNotifier[K, N]) Notify(ctx context.Context, ev RoutingNotification)

+ type Coordinator struct

+ func NewCoordinator[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]](self N, rtr coordt.Router[K, N, M], rt routing.RoutingTableCpl[K, N], ...) (*Coordinator[K, N, M], error)

+ func (c *Coordinator[K, N, M]) AddNodes(ctx context.Context, ids []N) error

+ func (c *Coordinator[K, N, M]) Bootstrap(ctx context.Context) error

+ func (c *Coordinator[K, N, M]) BroadcastRecord(ctx context.Context, msg M) error

+ func (c *Coordinator[K, N, M]) BroadcastStatic(ctx context.Context, msg M, seeds []N) error

+ func (c *Coordinator[K, N, M]) Close() error

+ func (c *Coordinator[K, N, M]) GetClosestNodes(ctx context.Context, k K, n int) ([]N, error)

+ func (c *Coordinator[K, N, M]) ID() N

+ func (c *Coordinator[K, N, M]) IsRoutable(ctx context.Context, id N) bool

+ func (c *Coordinator[K, N, M]) NotifyConnectivity(ctx context.Context, id N)

+ func (c *Coordinator[K, N, M]) NotifyNonConnectivity(ctx context.Context, id N)

+ func (c *Coordinator[K, N, M]) QueryClosest(ctx context.Context, target K, fn coordt.QueryFunc[K, N, M], numResults int) ([]N, coordt.QueryStats, error)

+ func (c *Coordinator[K, N, M]) QueryMessage(ctx context.Context, msg M, fn coordt.QueryFunc[K, N, M], numResults int) ([]N, coordt.QueryStats, error)

+ func (c *Coordinator[K, N, M]) SetRoutingNotifier(rn RoutingNotifier)

+ type CoordinatorConfig struct

+ Brdcst BroadcastConfig[K, N, M]

+ Logger *slog.Logger

+ MeterProvider metric.MeterProvider

+ Network NetworkConfig

+ Query QueryConfig

+ Routing RoutingConfig[K, N]

+ TracerProvider trace.TracerProvider

+ func DefaultCoordinatorConfig[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]]() *CoordinatorConfig[K, N, M]

+ func (cfg *CoordinatorConfig[K, N, M]) Validate() error

+ type CtxEvent struct

+ Ctx context.Context

+ Event E

+ type EventAddNode struct

+ NodeID N

+ type EventBootstrapFinished struct

+ Err error

+ Stats query.QueryStats

+ type EventBroadcastFinished struct

+ Contacted []N

+ Err error

+ Errors map[string]struct{ ... }

+ QueryID coordt.QueryID

+ type EventGetCloserNodesFailure struct

+ Err error

+ QueryID coordt.QueryID

+ Target K

+ To N

+ type EventGetCloserNodesSuccess struct

+ CloserNodes []N

+ QueryID coordt.QueryID

+ Target K

+ To N

+ type EventNotifyConnectivity struct

+ NodeID N

+ type EventNotifyNonConnectivity struct

+ NodeID N

+ type EventOutboundGetCloserNodes struct

+ Notify Notify[BehaviourEvent]

+ QueryID coordt.QueryID

+ Target K

+ To N

+ type EventOutboundSendMessage struct

+ Message M

+ Notify Notify[BehaviourEvent]

+ QueryID coordt.QueryID

+ To N

+ type EventQueryFinished struct

+ ClosestNodes []N

+ Err error

+ QueryID coordt.QueryID

+ Stats query.QueryStats

+ type EventQueryProgressed struct

+ NodeID N

+ QueryID coordt.QueryID

+ Response M

+ Stats query.QueryStats

+ type EventRoutingPoll struct

+ type EventRoutingRemoved struct

+ NodeID N

+ type EventRoutingUpdated struct

+ NodeID N

+ type EventSendMessageFailure struct

+ Err error

+ QueryID coordt.QueryID

+ Request M

+ Target K

+ To N

+ type EventSendMessageSuccess struct

+ CloserNodes []N

+ QueryID coordt.QueryID

+ Request M

+ Response M

+ To N

+ type EventStartBootstrap struct

+ SeedNodes []N

+ type EventStartBroadcast struct

+ Config brdcst.Config

+ Message M

+ Notify QueryMonitor[K, N, M, *EventBroadcastFinished[K, N]]

+ QueryID coordt.QueryID

+ Seed []N

+ Target K

+ type EventStartFindCloserQuery struct

+ KnownClosestNodes []N

+ Notify QueryMonitor[K, N, M, *EventQueryFinished[K, N]]

+ NumResults int

+ QueryID coordt.QueryID

+ Target K

+ type EventStartMessageQuery struct

+ KnownClosestNodes []N

+ Message M

+ Notify QueryMonitor[K, N, M, *EventQueryFinished[K, N]]

+ NumResults int

+ QueryID coordt.QueryID

+ Target K

+ type EventStopQuery struct

+ QueryID coordt.QueryID

+ type NetworkBehaviour struct

+ func NewNetworkBehaviour[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]](rtr coordt.Router[K, N, M], cfg *NetworkConfig) (*NetworkBehaviour[K, N, M], error)

+ func (b *NetworkBehaviour[K, N, M]) Close()

+ func (b *NetworkBehaviour[K, N, M]) Notify(ctx context.Context, ev BehaviourEvent)

+ func (b *NetworkBehaviour[K, N, M]) Perform(ctx context.Context) (BehaviourEvent, bool)

+ func (b *NetworkBehaviour[K, N, M]) Ready() <-chan struct{}

+ type NetworkCommand interface

+ type NetworkConfig struct

+ Capacity int

+ IdleTimeout time.Duration

+ Logger *slog.Logger

+ Meter metric.Meter

+ NodeCapacity int

+ Tracer trace.Tracer

+ func DefaultNetworkConfig() *NetworkConfig

+ func (cfg *NetworkConfig) Validate() error

+ type NodeHandler struct

+ func NewNodeHandler[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]](self N, rtr coordt.Router[K, N, M], slots *slots, cfg *NetworkConfig, ...) *NodeHandler[K, N, M]

+ func (h *NodeHandler[K, N, M]) Close()

+ func (h *NodeHandler[K, N, M]) ID() N

+ func (h *NodeHandler[K, N, M]) Notify(ctx context.Context, ev NodeHandlerRequest) bool

+ type NodeHandlerRequest interface

+ type NodeHandlerResponse interface

+ type Notify interface

+ Notify func(ctx context.Context, ev E)

+ type NotifyCloser interface

+ Close func()

+ type NotifyFunc func(ctx context.Context, ev E)

+ func (f NotifyFunc[E]) Notify(ctx context.Context, ev E)

+ type PooledBroadcastBehaviour struct

+ func NewPooledBroadcastBehaviour[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]](brdcstPool *brdcst.Pool[K, N, M], cfg *BroadcastConfig[K, N, M]) (*PooledBroadcastBehaviour[K, N, M], error)

+ func (b *PooledBroadcastBehaviour[K, N, M]) Notify(ctx context.Context, ev BehaviourEvent)

+ func (b *PooledBroadcastBehaviour[K, N, M]) Perform(ctx context.Context) (out BehaviourEvent, performed bool)

+ func (b *PooledBroadcastBehaviour[K, N, M]) Ready() <-chan struct{}

+ type QueryBehaviour struct

+ func NewQueryBehaviour[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]](self N, cfg *QueryConfig) (*QueryBehaviour[K, N, M], error)

+ func (p *QueryBehaviour[K, N, M]) Notify(ctx context.Context, ev BehaviourEvent)

+ func (p *QueryBehaviour[K, N, M]) Perform(ctx context.Context) (out BehaviourEvent, performed bool)

+ func (p *QueryBehaviour[K, N, M]) Ready() <-chan struct{}

+ type QueryCommand interface

+ type QueryConfig struct

+ Concurrency int

+ Logger *slog.Logger

+ Meter metric.Meter

+ QueueCapacity int

+ RequestConcurrency int

+ RequestTimeout time.Duration

+ Timeout time.Duration

+ Tracer trace.Tracer

+ func DefaultQueryConfig() *QueryConfig

+ func (cfg *QueryConfig) Validate() error

+ type QueryMonitor interface

+ NotifyFinished func() chan<- CtxEvent[E]

+ NotifyProgressed func() chan<- CtxEvent[*EventQueryProgressed[K, N, M]]

+ type QueryMonitorHook struct

+ BeforeFinished func()

+ BeforeProgressed func()

+ func NewQueryMonitorHook[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N], E TerminalQueryEvent](qm QueryMonitor[K, N, M, E]) *QueryMonitorHook[K, N, M, E]

+ func (n *QueryMonitorHook[K, N, M, E]) NotifyFinished() chan<- CtxEvent[E]

+ func (n *QueryMonitorHook[K, N, M, E]) NotifyProgressed() chan<- CtxEvent[*EventQueryProgressed[K, N, M]]

+ type QueryWaiter struct

+ func NewQueryWaiter[K kad.Key[K], N kad.NodeID[K], M coordt.Message[K, N]](n int) *QueryWaiter[K, N, M]

+ func (w *QueryWaiter[K, N, M]) Finished() <-chan CtxEvent[*EventQueryFinished[K, N]]

+ func (w *QueryWaiter[K, N, M]) NotifyFinished() chan<- CtxEvent[*EventQueryFinished[K, N]]

+ func (w *QueryWaiter[K, N, M]) NotifyProgressed() chan<- CtxEvent[*EventQueryProgressed[K, N, M]]

+ func (w *QueryWaiter[K, N, M]) Progressed() <-chan CtxEvent[*EventQueryProgressed[K, N, M]]

+ type RoutingBehaviour struct

+ func ComposeRoutingBehaviour[K kad.Key[K], N kad.NodeID[K]](self N, ...) (*RoutingBehaviour[K, N], error)

+ func NewRoutingBehaviour[K kad.Key[K], N kad.NodeID[K]](self N, rt routing.RoutingTableCpl[K, N], cplFn routing.NodeIDForCplFunc[K, N], ...) (*RoutingBehaviour[K, N], error)

+ func (r *RoutingBehaviour[K, N]) Notify(ctx context.Context, ev BehaviourEvent)

+ func (r *RoutingBehaviour[K, N]) Perform(ctx context.Context) (out BehaviourEvent, performed bool)

+ func (r *RoutingBehaviour[K, N]) Ready() <-chan struct{}

+ type RoutingCommand interface

+ type RoutingConfig struct

+ BootstrapMinimumPopulation int

+ BootstrapPeers []N

+ BootstrapRequestConcurrency int

+ BootstrapRequestTimeout time.Duration

+ BootstrapRetryInterval time.Duration

+ BootstrapTimeout time.Duration

+ ConnectivityCheckTimeout time.Duration

+ ExploreInterval time.Duration

+ ExploreIntervalJitter float64

+ ExploreIntervalMultiplier float64

+ ExploreMaximumCpl int

+ ExploreRequestConcurrency int

+ ExploreRequestTimeout time.Duration

+ ExploreTimeout time.Duration

+ IncludeQueueCapacity int

+ IncludeRequestConcurrency int

+ Logger *slog.Logger

+ Meter metric.Meter

+ ProbeCheckInterval time.Duration

+ ProbeRequestConcurrency int

+ QueueCapacity int

+ Tracer trace.Tracer

+ func DefaultRoutingConfig[K kad.Key[K], N kad.NodeID[K]]() *RoutingConfig[K, N]

+ func (cfg *RoutingConfig[K, N]) Validate() error

+ type RoutingNotification interface

+ type RoutingNotifier interface

+ Notify func(context.Context, RoutingNotification)

+ type Telemetry struct

+ Tracer trace.Tracer

+ func NewTelemetry(meterProvider metric.MeterProvider, tracerProvider trace.TracerProvider) (*Telemetry, error)

+ func (t *Telemetry) RecordEventLoopPass(ctx context.Context, busy time.Duration)

+ type TerminalQueryEvent interface

+ type Waiter struct

+ func NewWaiter[E BehaviourEvent]() *Waiter[E]

+ func (w *Waiter[E]) Chan() <-chan WaiterEvent[E]

+ func (w *Waiter[E]) Close()

+ func (w *Waiter[E]) Notify(ctx context.Context, ev E)

+ type WaiterEvent struct

+ Ctx context.Context

+ Event E

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL