rabbids

type Binding struct {
	Exchange    string   `mapstructure:"exchange"`
	RoutingKeys []string `mapstructure:"routing_keys"`
	Options     Options  `mapstructure:"options"`
}

type Config struct {
	// Connections describe the connections used by consumers.
	Connections map[string]Connection `mapstructure:"connections"`
	// Exchanges have all the exchanges used by consumers.
	// This exchanges are declared on startup of the rabbids client.
	Exchanges map[string]ExchangeConfig `mapstructure:"exchanges"`
	// DeadLetters have all the deadletters queues used internally by other queues
	// This will be declared at startup of the rabbids client.
	DeadLetters map[string]DeadLetter `mapstructure:"dead_letters"`
	// Consumers describes configuration list for consumers.
	Consumers map[string]ConsumerConfig `mapstructure:"consumers"`
	// Registered Message handlers used by consumers
	Handlers map[string]MessageHandler
}

type Connection struct {
	DSN     string        `mapstructure:"dsn"`
	Timeout time.Duration `mapstructure:"timeout"`
	Sleep   time.Duration `mapstructure:"sleep"`
	Retries int           `mapstructure:"retries"`
}

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

type ConsumerConfig struct {
	Connection    string      `mapstructure:"connection"`
	Workers       int         `mapstructure:"workers"`
	PrefetchCount int         `mapstructure:"prefetch_count"`
	DeadLetter    string      `mapstructure:"dead_letter"`
	Queue         QueueConfig `mapstructure:"queue"`
	Options       Options     `mapstructure:"options"`
}

type DeadLetter struct {
	Queue QueueConfig `mapstructure:"queue"`
}

type ExchangeConfig struct {
	Type    string  `mapstructure:"type"`
	Options Options `mapstructure:"options"`
}

type Fields map[string]interface{}

type File interface {
	io.Reader
	Stat() (os.FileInfo, error)
}

type LoggerFN func(message string, fields Fields)

type Message struct {
	amqp.Delivery
}

type MessageHandler interface {
	// Handle a single message, this method MUST be safe for concurrent use
	Handle(m Message)
	// Close the handler, this method is called when the consumer is closing
	Close()
}

type MessageHandlerFunc func(m Message)

type Options struct {
	Durable    bool       `mapstructure:"durable"`
	Internal   bool       `mapstructure:"internal"`
	AutoDelete bool       `mapstructure:"auto_delete"`
	Exclusive  bool       `mapstructure:"exclusive"`
	NoWait     bool       `mapstructure:"no_wait"`
	NoLocal    bool       `mapstructure:"no_local"`
	AutoAck    bool       `mapstructure:"auto_ack"`
	Args       amqp.Table `mapstructure:"args"`
}

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

type ProducerOption func(*Producer) error

type Publishing struct {
	// Exchange name
	Exchange string
	// The routing key
	Key string
	// Data to be encoded inside the message
	Data interface{}
	// Delay is the duration to wait until the message is delivered to the queue.
	// The max delay period is 268,435,455 seconds, or about 8.5 years.
	Delay time.Duration

	amqp.Publishing
	// contains filtered or unexported fields
}

type PublishingError struct {
	Publishing
	Err error
}

type PublishingOption func(*Publishing)

type QueueConfig struct {
	Name     string    `mapstructure:"name"`
	Bindings []Binding `mapstructure:"bindings"`
	Options  Options   `mapstructure:"options"`
}

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

type Serializer interface {
	Marshal(interface{}) ([]byte, error)
	// Name return the name used on the content type of the messsage
	Name() string
}