rabbitmq

type AcknowledgementType int

type ClientConfig struct {
	// ConnectionURI is the string used to connect to rabbitmq, e.g `amqp://...`
	ConnectionURI string
	// Metric is an interface to collect metrics about the client and consumer
	// There is NullMetric struct if you want to skip them
	Metric Metric
	// ConnectRetryAttempts number of attempts to try and dial the rabbitmq, and create a channel
	ConnectRetryAttempts int
	// InitialReconnectDelay delay between each attempt
	InitialReconnectDelay time.Duration
}

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

type ConsumerConfig struct {
	// PrefetchCount configures how many in-flight "deliveries" are available to the consumer to ack/nack.
	// ref: https://www.rabbitmq.com/consumer-prefetch.html
	// There's no default value for the reason that it's very easy to misuse RMQ and have multiple consumers
	// with too many deliveries in flight which results into badly distributed work load and high memory footprint
	// of the consumers.
	PrefetchCount int
}

type ExchangeConfig struct {
	Name       string
	Kind       string
	Durable    bool
	AutoDelete bool
	Internal   bool
	NoWait     bool
	Args       amqp.Table
}

type Handler interface {
	GetQueueName() string
	GetConsumerTag() string
	QueueAutoAck() bool
	ExclusiveConsumer() bool
	MustStopOnAckError() bool
	MustStopOnNAckError() bool
	MustStopOnRejectError() bool
	WaitToConsumeInflight() bool
	ReceiveMessage(ctx context.Context, msg *Message) (acknowledgement HandlerAcknowledgement, err error)
}

type HandlerAcknowledgement struct {
	Acknowledgement AcknowledgementType
	Requeue         bool
}

type Message struct {
	// The application specific payload of the message
	Body []byte

	// Correlation identifier
	CorrelationID string
	// Message headers
	Headers map[string]interface{}
}

type MessageArgs struct {
	// Application or exchange specific fields,
	// the headers exchange will inspect this field.
	Headers amqp.Table

	// Correlation identifier
	CorrelationID string
}

type Metric interface {
	ObserveRabbitMQConnectionFailed()
	ObserveRabbitMQConnectionRetry()
	ObserveRabbitMQConnection()

	ObserveRabbitMQChanelConnectionFailed()
	ObserveRabbitMQChanelConnectionRetry()
	ObserveRabbitMQChanelConnection()

	ObserveMsgDelivered()
	ObserveAck(success bool)
	ObserveNack(success bool)
	ObserveReject(success bool)
	ObserveMsgPublish(success bool)
}

type NullMetric struct{}

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

type QueueBindConfig struct {
	Name     string
	Key      string
	Exchange string
	NoWait   bool
	Args     amqp.Table
}

type QueueConfig struct {
	Name       string
	Durable    bool
	AutoDelete bool
	Exclusive  bool
	NoWait     bool
	Args       amqp.Table
}

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

type RabbitMQClientInterface interface {
	CreateChannel(ctx context.Context) (*amqp.Channel, error)
	Setup(ctx context.Context, setup *Setup) error
	Close() error
}

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

type RetryableConsumerConfig struct {
	MaxRetryAttempts int
	// healthCheckFactor is a number representing how much N multiplied by backoffConfig.Max time is needed
	// for a block of code to run w/o returning an error, to consider it healthy.
	// E.g backConfig.Max = 1min, healthCheckFactor = 2, means that code needs to run 2min at least to be healthy
	// and retried again starting from backoffConfig.Base the next time it has an error.
	HealthCheckFactor  int
	BackoffConfig      *backoff.Config
	ConsumerConfig     ConsumerConfig
	RabbitClientConfig *ClientConfig
}

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

type RetryableProducerConfig struct {
	MaxRetryAttempts int
	// HealthCheckFactor is a number representing how much N multiplied by backoffConfig.Max time is needed
	// for a block of code to run w/o returning an error, to consider it healthy.
	// E.g backConfig.Max = 1min, healthCheckFactor = 2, means that code needs to run 2min at least to be healthy
	// and retried again starting from backoffConfig.Base the next time it has an error.
	HealthCheckFactor  int
	BackoffConfig      *backoff.Config
	RabbitClientConfig *ClientConfig
}

type Setup struct {
	Exchanges     []ExchangeConfig
	Queues        []QueueConfig
	QueueBindings []QueueBindConfig
}