queue

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

type Config struct {
	MaxSize int

	// Messages will be discarded after this many failures, or
	// pushed to DLQ if DLQ is supported
	MaxHandleFailures int

	PollInterval time.Duration

	// Used for internal retrying, not for message retrying
	MaxRetries int

	// Specify how many consumers are consuming the queue using `Subscribe`.
	// Be aware that too many consumers can cause order of messages to be changed.
	// If you want to ensure the order of messages, please use FIFO queue and set ConsumerCount to 1
	ConsumerCount int

	// Specify standard message
	// Use json message if nil
	Message            Message
	MessageIDGenerator message.MessageIDGenerator
}

type DLQ interface {
	Queue

	// Push `items` of messages to associated Queue
	Redrive(items int) error

	AssociatedQueue() Queue
}

type DLQer interface {
	DLQ() (DLQ, error)
}

type Factory interface {
	// Create a new queue if name does not exist
	// If name already exists, return the existing queue
	GetOrCreate(name string, options ...Option) (Queue, error)
}

type Handler func(msg Message) error

type JsonMessage struct {
	message.JsonMessage
}

type Kind uint8

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

type MemoryQueue struct {
	*BaseQueue
	// contains filtered or unexported fields
}

type Message interface {
	message.Message

	RetryCount() int
	AddRetryCount()
	TotalRetryCount() int
	RefreshRetryCount()

	CreatedAt() time.Time
	UpdatedAt() time.Time

	RefreshUpdatedAt()
}

type Option func(*Config)

type Purgeable interface {
	// Clean up the queue
	Purge() error
}

type Queue interface {
	Kind() Kind

	Name() string

	// Reports max size of queue
	// -1 for unlimited
	MaxSize() int

	// Reports max handle failures
	// Messages will be discarded after this many failures, or
	// pushed to DLQ if DLQ is supported
	MaxHandleFailures() int

	// Push data to end of queue
	// Failed if queue is full or closed
	Enqueue([]byte) error

	// The implementation MUST set the retryCount of the message to 0 if its retryCount > MaxHandleFailures,
	// in the case, the message is from DLQ redriving.
	Dequeue() (Message, error)

	// Subscribe queue with message confirmation.
	// Once handler returns error, it'll automatically put message back to queue using `Recover` mechanism internally.
	Subscribe(h Handler)

	Close()
}

type Recoverable interface {

	// If the queue supports `visibility window` like AWS SQS, the message will be put back to queue atomically without calling `Recover`.
	// It's useful if the panic is from outside of the queue handler.
	// But it's recommended to use `Recover` if the panic is from inside the queue handler for retrying the message fast.
	Recover(Message) error
}

type RecoverableQueue interface {
	Queue

	Recoverable
}

type RedisQueue struct {
	*BaseQueue
	// contains filtered or unexported fields
}

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

type SafeQueue interface {
	Queue

	Recoverable
	IsRecoverable() bool

	Purgeable
	IsPurgeable() bool

	DLQer
	IsDLQSupported() bool
}

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