worq

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

type AsyncResult struct {
	ID string
}

type Binder interface {
	Bind(ctx Context, v interface{}) error
	Unbind(ctx Context, id string, queue string, sig *Signature) (*Publishing, error)
}

type Broker interface {
	Consume(ctx Context, queueName string) (Consumer, error)

	Close() error

	Enqueue(*Publishing) error
}

type Consumer interface {
	Next() bool
	Err() error
	Message() (Message, error)
	Close() error

	Ack(message Message) error
	Nack(message Message, requeue bool) error
}

type Context interface {
	App() *App

	Logger() logrus.FieldLogger

	Consumer() Consumer

	Message() Message

	Bind(v interface{}) error

	Reject(requeue bool) error

	Deadline() (deadline time.Time, ok bool)

	Done() <-chan struct{}

	Err() error

	Value(key interface{}) interface{}
}

type Message interface {
	Queue() string

	ID() string

	Task() string

	Headers() map[string]interface{}

	ContentType() string

	Body() []byte
}

type MockContext struct {
	MessageFactory func() Message
	// contains filtered or unexported fields
}

type MockMessage struct {
	MockQueue       string
	MockID          string
	MockTask        string
	MockHeaders     map[string]interface{}
	MockContentType string
	MockBody        []byte
}

type OptionFunc func(*App) error

type Protocol interface {
	ID(message Message) (string, error)

	Task(message Message) (string, error)
}

type Publishing struct {
	ID          string
	Queue       string
	Headers     map[string]interface{}
	ContentType string
	Body        []byte
}

type Signature struct {
	Task string
	Args interface{}
}

type TaskFunc func(ctx Context) error

type TaskNotFound struct {
	Name string
}

type TaskRejected struct {
	Requeue bool
}