sink

type BatchPusher ¶ added in v1.2.4

type BatchPusher interface {
	BatchSize() int
	PushBatch(ctx context.Context, entries []queue.Entry) error
}

BatchPusher confirms an ordered group of queue entries as one sink write. BatchSize is the maximum number of entries the connector should provide; short batches are valid and are delivered without waiting for the batch to fill. A nil error confirms every entry in the supplied batch.

type BroadcastReport ¶

type BroadcastReport struct {
	Accepted       []bool
	RecipientDrops int64
	Err            error
}

type Broadcaster ¶

type Broadcaster interface {
	Broadcast(entries []queue.Entry) BroadcastReport
}

Broadcaster sinks fan out to connected clients without confirmation.

type ConnectorRegistrar ¶

type ConnectorRegistrar interface {
	RegisterConnector(id string, r ReplayReader)
	UnregisterConnector(id string)
}

ConnectorRegistrar lets connectors attach their queue for client replay.

type DataServer ¶

type DataServer struct {
	// contains filtered or unexported fields
}

DataServer hosts serve-mode sink endpoints with dynamically managed routes.

func NewDataServer(addr string, log *slog.Logger) *DataServer

func (d *DataServer) Addr() string

func (d *DataServer) RemoveRoute(path string)

func (d *DataServer) SetRoute(path string, h http.Handler)

func (d *DataServer) Start() error

func (d *DataServer) Stop(ctx context.Context) error

type DeliveryClass ¶

type DeliveryClass string

const (
	DeliveryConfirmed  DeliveryClass = "confirmed"
	DeliveryResumable  DeliveryClass = "resumable"
	DeliveryBestEffort DeliveryClass = "best_effort"
	DeliveryObserved   DeliveryClass = "observe_only"
)

func DeliveryClassOf(r Runtime) DeliveryClass

type DeliveryClassifier ¶

type DeliveryClassifier interface {
	DeliveryClass() DeliveryClass
}

DeliveryClassifier makes the route boundary explicit. Implementations that do not provide it are classified from their Pusher/Broadcaster seam by DeliveryClassOf.

type Pusher ¶

type Pusher interface {
	Push(ctx context.Context, e *msg.Envelope) error
}

Pusher sinks confirm each delivery (CAN). ErrSkip means "cannot carry this message, count it and move on" (e.g. envelope without raw bytes).

type ReplayReader ¶

type ReplayReader interface {
	Read(ctx context.Context, after int64, limit int) ([]queue.Entry, error)
}

ReplayReader is what serve-mode sinks use to replay history for a client.

type Runtime ¶

type Runtime interface {
	ID() string
	Stop()
	State() (string, error)
}

func New(ctx context.Context, cfg model.Sink, mgr *bus.Manager, ds *DataServer, log *slog.Logger, met *metrics.Set) (Runtime, error)

type WirePusher ¶

type WirePusher interface {
	PushWire(ctx context.Context, e *msg.Envelope) error
}

WirePusher preserves the envelope's original N2K source identity and raw payload instead of re-originating it through Beacon's claimed client.