messagequeue

type Chunker[T any] interface {
	// Start the chunker
	Start(buffer <-chan T, handler Handler[T]) error
	// Stop the chunker and clean up any resources
	Stop() error
}

type ChunkerOptions struct {
	// ChunkSize determines the desired chunk size for entries to be returned
	// from the buffer.
	ChunkSize uint
	// MaxElementWait determines the maximum time an entry will wait to be chunked.
	// Smaller durations may result in chunks that are less than the desired size.
	MaxElementWait time.Duration
}

type EnqueueMessageResult struct {
	// Message this result is for
	*Message
	// Success indicates whether the message was successfully enqueued
	Success bool
	// SenderFault when success is false, indicates that the enqueue failed due
	// to a malformed message
	SenderFault bool
	// Error that occurred when enqueueing the message
	Error string
}

type Enqueuer interface {
	// Start validates configurations and creates the resources necessary to
	// handle enqueuing messages.
	Start(messageQueue MessageQueue) error
	// Enqueue the passed message. This operation may be
	// buffered and errors enqueueing will not be available for immediate handling.
	Enqueue(messages *Message) error
	// Stop all active workers, drain queues, and free resources.
	Stop() error
}

type EnqueuerOptions struct {
	*ChunkerOptions
	// Logger for the enqueuer to use
	Logger log.Logger
	// BufferSize to use for forming batches, must be greater than BatchSize
	BufferSize uint
	// FailedBufferSize for messages that fail to enqueue. This should be at
	// least equal to BatchSize to avoid blocking.
	FailedBufferSize uint
	// FailureHandler receives messages that failed to enqueue, optional.
	FailureHandler HandleFailedEnqueue
}

type HandleFailedEnqueue func(Enqueuer, *EnqueueMessageResult)

type HandleMessage func(context.Context, *Message) bool

type Handler[T any] func(chunk []T)

type Job interface {
	Work() bool
}

type Message struct {
	// ID uniquely identifies this message
	ID string
	// External field used by the sdk
	External string
	// Trace field for telemetry
	Trace string
	// Delay before this message becomes visible after being enqueued
	Delay time.Duration
	// Service this message is for
	Service string
	// Method that should be invoked to process this message
	Method string
	// Body can contain any structured (JSON, XML) or unstructured text
	// limitations are determined by the implementation
	Body string
	// Deadline for processing this message
	Deadline time.Time
}

type MessageQueue interface {
	// Enqueue all the passed messages as a batch
	EnqueueBatch(context.Context, []*Message) ([]*EnqueueMessageResult, error)
	// Dequeue up to the passed count of messages waiting up to the passed
	// duration
	Dequeue(ctx context.Context, count int, wait, visibilityTimeout time.Duration) ([]*Message, error)
	// Delete the passed message from the queue so that it is not processed by
	// other workers
	// TODO: [COR-553] Batch delete messages
	Delete(context.Context, *Message) error
}

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

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

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

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

type Poller interface {
	// Poll for messages on the passed queue
	Poll(HandleMessage, MessageQueue) error
	// Stop polling for messages
	Stop() error
}

type PollerOptions struct {
	// Logger to use for reporting errors
	Logger log.Logger
	// ConcurrentMessageHandlers that should be running at any given time
	ConcurrentMessageHandlers int
	// WaitForBatch the specified duration before prematurely returning with less
	// than the desired number of messages.
	WaitForBatch time.Duration
	// DequeueCount is the number of messages to attempt to dequeue per request.
	// maximum will vary by implementation
	DequeueCount int
	// QueueOperationTimeout
	QueueOperationTimeout time.Duration
	// VisibilityTimeout is the amount of time a message is hidden from other
	// consumers after it has been received by a message queue client.
	VisibilityTimeout time.Duration
}

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