shuttle

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

type AzServiceBusSender interface {
	SendMessage(ctx context.Context, message *azservicebus.Message, options *azservicebus.SendMessageOptions) error
	SendMessageBatch(ctx context.Context, batch *azservicebus.MessageBatch, options *azservicebus.SendMessageBatchOptions) error
	NewMessageBatch(ctx context.Context, options *azservicebus.MessageBatchOptions) (*azservicebus.MessageBatch, error)
	Close(ctx context.Context) error
}

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

type ConstantDelayStrategy struct {
	Delay time.Duration
}

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

type DefaultJSONMarshaller struct {
}

type DefaultProtoMarshaller struct {
}

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

type Handler interface {
	Handle(context.Context, MessageSettler, *azservicebus.ReceivedMessage)
}

type HandlerFunc func(ctx context.Context, settler MessageSettler, message *azservicebus.ReceivedMessage)

type HealthCheckable interface {
	HealthCheck(ctx context.Context, namespaceName string, client *azservicebus.Client) error
}

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

type HealthCheckerOptions struct {
	// HealthCheckInterval is the time between health checks.
	HealthCheckInterval time.Duration
	// HealthCheckTimeout is the context timeout for each health check
	HealthCheckTimeout time.Duration
}

type LockRenewalOptions struct {
	// Interval defines the frequency at which we renew the lock on the message. Defaults to 10 seconds.
	Interval *time.Duration
	// LockRenewalTimeout is the timeout value used on the context when sending RenewMessageLock() request.
	// Defaults to 5 seconds if not set or 0. Defaults to Lock Expiry time if set to a negative value.
	LockRenewalTimeout *time.Duration
	// CancelMessageContextOnStop will cancel the downstream message context when the renewal handler is stopped.
	// Defaults to true.
	CancelMessageContextOnStop *bool
	// MetricRecorder allows to pass a custom metric recorder for the LockRenewer.
	// Defaults to processor.Metric instance.
	MetricRecorder processor.Recorder
}

type LockRenewer interface {
	RenewMessageLock(ctx context.Context, message *azservicebus.ReceivedMessage, options *azservicebus.RenewMessageLockOptions) error
}

type Logger interface {
	Info(s string)
	Warn(s string)
	Error(s string)
}

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

type ManagedSettlingFunc func(ctx context.Context, message *azservicebus.ReceivedMessage) error

type ManagedSettlingHandler interface {
	Handle(context.Context, *azservicebus.ReceivedMessage) error
}

type ManagedSettlingOptions struct {
	// Allows to override the built-in error handling logic.
	// OnError is called before any message settling action is taken.
	// the ManagedSettlingOptions struct is passed as an argument so that the configuration
	// like RetryDecision, RetryDelayStrategy and the post-settlement hooks can be reused and composed differently
	OnError func(ctx context.Context, opts *ManagedSettlingOptions, settler MessageSettler, message *azservicebus.ReceivedMessage, handleErr error)
	// RetryDecision is invoked to decide whether an error should be retried.
	// the default is to retry 5 times before moving the message to the deadletter.
	RetryDecision RetryDecision
	// RetryDelayStrategy is invoked when a message handling does not complete successfully
	// and the RetryDecision decides to retry the message.
	// The handler will sleep for the time calculated by the delayStrategy before Abandoning the message.
	RetryDelayStrategy RetryDelayStrategy
	// OnAbandoned is invoked when the handler returns an error. It is invoked after the message is abandoned.
	OnAbandoned func(context.Context, *azservicebus.ReceivedMessage, error)
	// OnDeadLettered is invoked after the ManagedSettling dead-letters a message.
	// this occurs when the RetryDecision.CanRetry implementation returns false following an error returned by the handler
	// It is invoked after the message is dead-lettered.
	OnDeadLettered func(context.Context, *azservicebus.ReceivedMessage, error)
	// OnCompleted is a func that is invoked when the handler does not return any error. it is invoked after the message is completed.
	OnCompleted func(context.Context, *azservicebus.ReceivedMessage)
}

type Marshaller interface {
	Marshal(mb MessageBody) (*azservicebus.Message, error)
	Unmarshal(msg *azservicebus.Message, mb MessageBody) error
	ContentType() string
}

type MaxAttemptsRetryDecision struct {
	MaxAttempts uint32
}

type MessageBody any

type MessageSettler interface {
	AbandonMessage(ctx context.Context, message *azservicebus.ReceivedMessage, options *azservicebus.AbandonMessageOptions) error
	CompleteMessage(ctx context.Context, message *azservicebus.ReceivedMessage, options *azservicebus.CompleteMessageOptions) error
	DeadLetterMessage(ctx context.Context, message *azservicebus.ReceivedMessage, options *azservicebus.DeadLetterOptions) error
	DeferMessage(ctx context.Context, message *azservicebus.ReceivedMessage, options *azservicebus.DeferMessageOptions) error
	RenewMessageLock(ctx context.Context, message *azservicebus.ReceivedMessage, options *azservicebus.RenewMessageLockOptions) error
}

type NoOp struct {
}

type PanicHandlerOptions struct {
	OnPanicRecovered func(
		ctx context.Context,
		settler MessageSettler,
		message *azservicebus.ReceivedMessage,
		recovered any)
}

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

type ProcessorOptions struct {
	// MaxConcurrency is the maximum number of concurrent messages to process at a time.
	MaxConcurrency int

	// MaxReceiveCount is the maximum number of messages to receive at a time. This value is passed to the receiver.
	MaxReceiveCount int

	// ReceiveInterval is the interval between each receive call.
	ReceiveInterval *time.Duration

	// StartMaxAttempt is the maximum number of attempts to start the processor.
	StartMaxAttempt int

	// StartRetryDelay is the delay between each start attempt.
	StartRetryDelayStrategy RetryDelayStrategy
}

type Receiver interface {
	ReceiveMessages(ctx context.Context, maxMessages int, options *azservicebus.ReceiveMessagesOptions) ([]*azservicebus.ReceivedMessage, error)
	MessageSettler
}

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

type ReceiverHealthChecker struct {
	EntityName       string
	SubscriptionName string
}

type RetryDecision interface {
	// CanRetry inspects the error returned from the message handler, and the message itself to decide if it should be retried or not.
	CanRetry(err error, message *azservicebus.ReceivedMessage) bool
}

type RetryDelayStrategy interface {
	GetDelay(attempt uint32) time.Duration
}

type SendAsBatchOptions struct {
	// AllowMultipleBatch when true, allows splitting large message arrays into multiple batches.
	// When false, behaves like the original SendMessageBatch method.
	// Default: false
	AllowMultipleBatch bool
}

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

type SenderHealthChecker struct {
	EntityName string
}

type SenderOptions struct {
	// Marshaller will be used to marshall the messageBody to the azservicebus.Message Body property
	// defaults to DefaultJSONMarshaller
	Marshaller Marshaller
	// EnableTracingPropagation automatically applies WithTracePropagation option on all message sent through this sender
	EnableTracingPropagation bool
	// SendTimeout is the timeout value used on the context that sends messages
	// Defaults to 30 seconds if not set or 0
	// Disabled when set to a negative value
	SendTimeout time.Duration
}

type Settlement interface {
	Settle(context.Context, MessageSettler, *azservicebus.ReceivedMessage)
}

type SettlementHandlerOptions struct {
	// OnNilSettlement is a func that allows to handle cases where the downstream handler returns nil.
	// the default behavior is to panic.
	OnNilSettlement func() Settlement
}

type Settler func(ctx context.Context, message *azservicebus.ReceivedMessage) Settlement

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