endpoint

type Acknowledger interface {
	// Ack acknowledges the message, indicating that is was handled successfully
	// and does not need to be retried.
	Ack(ctx context.Context) error

	// Retry requeues the message so that it is retried at some point in the
	// future.
	//
	// d is a hint as to how long the transport should wait before retrying
	// this message.
	Retry(ctx context.Context, err error, d time.Duration) error

	// Reject indicates that the message could not be handled and should not be
	// retried. Depending on the transport, this may move the message to some form
	// of error queue or otherwise drop the message completely.
	Reject(ctx context.Context, err error) error
}

type AttemptID struct {
	ident.ID
}

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

type Endpoint struct {
	Name              string
	OutboundTransport OutboundTransport
	InboundTransport  InboundTransport
	InboundPipeline   InboundPipeline
	OutboundPipeline  OutboundPipeline
	RetryPolicy       RetryPolicy
	SenderValidators  []Validator
	Tracer            opentracing.Tracer
	// contains filtered or unexported fields
}

type InboundEnvelope struct {
	ax.Envelope

	// SourceEndpoint is the endpoint that sent the message.
	SourceEndpoint string

	// AttemptID uniquely identifies the attempt to process this message.
	AttemptID AttemptID

	// AttemptCount is the number of times that an attempt has been made to process
	// this message.
	//
	// Messages may be retried after a failure handling the message, or if
	// an endpoint crashes, for example. Not all transports support an attempt
	// count. If the attempt count is unknown, it is set to zero.
	//
	// The attempt count may be reset if a message is manually re-queued after
	// being rejected by the retry policy.
	AttemptCount uint

	// SpanContext is the tracing context that was propagated with the message.
	SpanContext opentracing.SpanContext
}

type InboundPipeline interface {
	// Initialize is called during initialization of the endpoint, after the
	// transport is initialized. It can be used to inspect or further
	// configure the endpoint as per the needs of the pipeline.
	Initialize(ctx context.Context, ep *Endpoint) error

	// Accept forwards an inbound message through the pipeline until
	// it is handled by some application-defined message handler(s).
	Accept(ctx context.Context, sink MessageSink, env InboundEnvelope) error
}

type InboundRejecter struct {
	Validators []Validator
	Next       InboundPipeline
}

type InboundTransport interface {
	// Initialize sets up the transport to communicate as an endpoint named ep.
	Initialize(ctx context.Context, ep string) error

	// Subscribe configures the transport to listen to messages of type mt that are
	// sent using op.
	Subscribe(ctx context.Context, op Operation, mt ax.MessageTypeSet) error

	// Receive returns the next message sent to this endpoint.
	// It blocks until a message is available, or ctx is canceled.
	Receive(ctx context.Context) (InboundEnvelope, Acknowledger, error)
}

type MessageSink interface {
	// Accept processes the message encapsulated in env.
	Accept(ctx context.Context, env OutboundEnvelope) error
}

type Operation int

type OutboundEnvelope struct {
	ax.Envelope

	// Operation is the operation to be performed on the message. It dictates
	// how the message is sent by the transport.
	Operation Operation

	// DestinationEndpoint is the endpoint to which the message is sent when
	// Operation is OpSendUnicast. The field is ignored for other operations.
	DestinationEndpoint string

	// SpanContext is the tracing context to propagate with the message.
	SpanContext opentracing.SpanContext
}

type OutboundPipeline interface {
	MessageSink

	// Initialize is called during initialization of the endpoint, after the
	// transport is initialized. It can be used to inspect or further
	// configure the endpoint as per the needs of the pipeline.
	Initialize(ctx context.Context, ep *Endpoint) error
}

type OutboundRejecter struct {
	Validators []Validator
	Next       OutboundPipeline
}

type OutboundTracer struct {
	Tracer opentracing.Tracer
	Next   OutboundPipeline
}

type OutboundTransport interface {
	// Initialize sets up the transport to communicate as an endpoint named ep.
	Initialize(ctx context.Context, ep string) error

	// Send sends env via the transport.
	Send(ctx context.Context, env OutboundEnvelope) error
}

type RetryPolicy func(InboundEnvelope, error) (time.Duration, bool)

type SelfValidatingMessage interface {
	ax.Message

	// Validate returns a non-nil error if the message is invalid. It is up to
	// message implementation to check validity criteria.
	//
	// This method is invoked by SelfValidator that is one the default
	// validators to verify the message.
	Validate() error
}

type SelfValidator struct{}

type SinkSender struct {
	Sink       MessageSink
	Validators []Validator
}

type TimeLimiter struct {
	Timeout time.Duration
	Next    InboundPipeline
}

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

type Validator interface {
	// Validate checks if m is valid.
	//
	// It returns a non-nil error if the message is invalid. The meaning of
	// 'valid' in is implementation-defined.
	Validate(ctx context.Context, m ax.Message) error
}