queue

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

type ByteQueue struct {
	BaseQueue
}

type DurableQueue struct {

	// DurableQueue extends a BaseQueue
	BaseQueue
	// contains filtered or unexported fields
}

type Processor interface {
	// Push pushes a given `payload` into the keyspace at `key` over the
	// given `redis.Conn`. This function should block until the item can
	// succesfully be confirmed to have been pushed.
	Push(conn redis.Conn, src string, payload []byte) (err error)

	// Pull pulls a given `payload` from the keyspace at `key` over the
	// given `redis.Conn`. This function should block until the given
	// timeout has elapsed, or an item is available. If the timeout has
	// passed, a redis.ErrNil will be returned.
	Pull(conn redis.Conn, src string, timeout time.Duration) (payload []byte, err error)

	// PullTo transfers a given payload from the source (src) keyspace to
	// the destination (dest) keyspace and returns the moved item in the
	// payload space. If an error was encountered, then it will be returned
	// immediately. Timeout semantisc are idential to those on Pull, unless
	// noted otherwise in implementation.
	PullTo(conn redis.Conn, src, dest string, timeout time.Duration) (payload []byte, err error)

	// Moves all elements from the src queue to the end of the destination
	// It should return a redis.ErrNil when the source queue is empty.
	Concat(conn redis.Conn, src, dest string) (err error)
}

type Queue interface {
	// Source returns the keyspace in Redis from which this queue is
	// populated.
	Source() string

	// Push pushes the given payload (a byte slice) into the specified
	// keyspace by delegating into the `Processor`'s `func Push`. It obtains
	// a connection to Redis using the pool, which is passed into the
	// Processor, and recycles that connection after the function has
	// returned.
	//
	// If an error occurs during Pushing, it will be returned, and it can be
	// assumed that the payload is not in Redis.
	Push(payload []byte) (err error)

	// Pull returns the next available payload, blocking until data can be
	// returned.
	Pull(timeout time.Duration) (payload []byte, err error)

	// Takes all elements from the source queue and adds them to this one. This
	// can be a long-running operation. If a persistent error is returned while
	// moving things, then concat will stop, though the concat operation can
	// be safely resumed at any time.
	//
	// Returns the number of items successfully moved and any error that
	// occurred.
	Concat(src string) (moved int, err error)

	// Processor returns the processor that is being used to push and pull.
	// If no processor is specified, a first-in-first-out will be returned
	// by default.
	Processor() Processor

	// SetProcessor sets the current processor to the specified processor by
	// aquiring a write lock into the mutex guarding that field. The
	// processor will be switched over during the next iteration of a
	// Pull-cycle, or a call to Push.
	SetProcessor(processor Processor)
}