storage

type AdapterQueue interface {
	String() string
	Append(message Messager) error
	Register(name string, f ConsumerFunc)
	Run()
	Shutdown()
}

type Cache interface {
	// Get returns the value stored under key, or ErrCacheMiss when the key is
	// absent or expired. An empty string is a legal value and is returned with
	// a nil error.
	Get(ctx context.Context, key string) (string, error)

	// Set stores a value with a time to live. A ttl of zero or less means the
	// entry never expires.
	Set(ctx context.Context, key, val string, ttl time.Duration) error

	// Del removes keys. Removing an absent key is not an error.
	Del(ctx context.Context, keys ...string) error

	// Incr atomically adds delta and returns the resulting value. An absent key
	// starts from zero. delta may be negative. A key created this way has no
	// ttl; call Expire to add one. The read-modify-write must be atomic.
	Incr(ctx context.Context, key string, delta int64) (int64, error)

	// Expire resets the time to live, returning ErrCacheMiss when the key is
	// absent. A ttl of zero or less makes the entry permanent.
	Expire(ctx context.Context, key string, ttl time.Duration) error

	// Close releases the underlying resources. It is idempotent. Afterwards
	// every other method returns ErrCacheClosed, unless ctx is already done,
	// in which case the context error wins.
	io.Closer
}

type ConsumerFunc func(Messager) error

type Handler func(ctx context.Context, msg Message) error

type Message struct {
	// ID is assigned by the queue on publish. It is ignored on input.
	ID string

	// Topic routes the message to a handler.
	Topic string

	// Values carries the payload.
	//
	// Only string values are guaranteed to arrive unchanged. Everything else is
	// undefined across implementations, because a broker-backed queue has to
	// serialise the map and an in-process one does not: the Redis queue returns
	// a published int as a float64, the memory queue returns the int. Use
	// strings, or encode the payload yourself.
	Values map[string]interface{}

	// Attempts counts deliveries of this message, starting at 1. A handler can
	// use it to give up on a message that keeps failing.
	Attempts int
}

type Messager interface {
	SetID(string)
	SetStream(string)
	SetValues(map[string]interface{})
	GetID() string
	GetStream() string
	GetValues() map[string]interface{}
	GetPrefix() string
	SetPrefix(string)
	SetErrorCount(count int)
	GetErrorCount() int
}

type Queue interface {
	// Publish enqueues a message. The topic must have a subscriber, otherwise
	// ErrNoHandler is returned rather than dropping the message silently.
	Publish(ctx context.Context, msg Message) error

	// Subscribe registers the handler for a topic. It must be called before
	// Start, because an implementation may fix its set of topics there and a
	// late subscription would then let Publish succeed with nothing reading it.
	//
	// Where more than one rule is broken at once, every implementation has to
	// answer alike: a bad argument outranks the queue's state, and among
	// states the terminal one outranks the rest. So ErrNilHandler, then
	// ErrQueueClosed, then ErrQueueAlreadyStarted, then
	// ErrTopicAlreadySubscribed.
	Subscribe(topic string, h Handler) error

	// Start begins consuming and blocks until ctx is done or an unrecoverable
	// error occurs. A context cancellation is not an error.
	Start(ctx context.Context) error

	// Close stops accepting new messages and waits for in-flight deliveries to
	// finish. It is idempotent. Bound the wait with a context of your own if
	// you need to.
	io.Closer
}