// Connects to the message queue, opens a channel, declares a queue
func (amqpBroker *AMQPBroker) open() (*amqp.Connection, *amqp.Channel, amqp.Queue, <-chan amqp.Confirmation, error) {
var err error
var channel *amqp.Channel
var queue amqp.Queue
if conn == nil {
once.Do(amqpBroker.connect)
}
if conn == nil {
return conn, channel, queue, nil, fmt.Errorf("Can't connect to the server")
}
channel, err = conn.Channel()
if err != nil {
fmt.Printf("Channel: %s\n", err)
}
if err := channel.ExchangeDeclare(
amqpBroker.config.Exchange, // name of the exchange
amqpBroker.config.ExchangeType, // type
true, // durable
false, // delete when complete
false, // internal
false, // noWait
nil, // arguments
); err != nil {
fmt.Printf("Exchange: %s\n", err)
}
queue, err = channel.QueueDeclare(
amqpBroker.config.DefaultQueue, // name
true, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
if err != nil {
fmt.Printf("Queue Declare: %s\n", err)
}
if err := channel.QueueBind(
queue.Name, // name of the queue
amqpBroker.config.BindingKey, // binding key
amqpBroker.config.Exchange, // source exchange
false, // noWait
nil, // arguments
); err != nil {
fmt.Printf("Queue Bind: %s\n", err)
}
confirmsChan := make(chan amqp.Confirmation, 1)
// Enable publish confirmations
if err := channel.Confirm(false); err != nil {
close(confirmsChan)
fmt.Printf("Channel could not be put into confirm mode: %s\n", err)
}
return conn, channel, queue, channel.NotifyPublish(confirmsChan), nil
}
func Publish(messages chan *amqp.Publishing, connectionUri, exchange,
routingKey string, mandatory, immediate bool, results chan *PublishResult) {
var err error
var conn *amqp.Connection
var channel *amqp.Channel
defer close(results)
if conn, err = amqp.Dial(connectionUri); err != nil {
results <- &PublishResult{"Failed to connect", err, true}
return
}
defer conn.Close()
if channel, err = conn.Channel(); err != nil {
results <- &PublishResult{"Failed to get channel", err, true}
return
}
pubAcks, pubNacks := channel.NotifyConfirm(make(chan uint64), make(chan uint64))
chanClose := channel.NotifyClose(make(chan *amqp.Error))
if err = channel.Confirm(false); err != nil {
results <- &PublishResult{
"Failed to put channel into confirm mode",
err,
true,
}
return
}
for message := range messages {
err = channel.Publish(exchange, routingKey, mandatory, immediate, *message)
if err != nil {
results <- &PublishResult{"Failed to publish message", err, false}
continue
}
select {
case err = <-chanClose:
results <- &PublishResult{"Channel closed!", err, true}
case <-pubAcks:
results <- &PublishResult{
fmt.Sprintf("Published to exchange '%s' routing key '%v': %+v", exchange, routingKey, message),
nil,
false,
}
case <-pubNacks:
results <- &PublishResult{"Received basic.nack for message", errors.New("'basic.nack'"), false}
}
}
}
func (me *AmqpConnection) Channel() (ch *AmqpChannel, err error) {
ok := true
select {
case ch, ok = <-me.channels:
break
default:
// with this,
// we can skip checking of mutex.
if me.noMore {
ch, ok = <-me.channels
break
}
me.cLock.Lock()
defer me.cLock.Unlock()
if me.cntChannels < me.maxChannel && !me.noMore {
var c *amqp.Channel
c, err = me.conn.Channel()
// enable publisher confirm
err = c.Confirm(false)
if err != nil {
break
}
ch = &AmqpChannel{
Channel: c,
Confirm: c.NotifyPublish(make(chan amqp.Confirmation, 1)),
Cancel: c.NotifyCancel(make(chan string, 1)),
}
me.cntChannels++
} else {
me.noMore = true
ch, ok = <-me.channels
break
}
}
if !ok {
err = errors.New("channel pool is closed")
}
return
}
func (que *TSQueue) Channel(conn *amqp.Connection) *amqp.Channel {
var err error
var ch *amqp.Channel
ch, err = conn.Channel()
if que.Acknowledge {
ch.Confirm(false)
que.Ack, que.NAck = ch.NotifyConfirm(make(chan uint64, 1), make(chan uint64, 1))
}
Fail(err, "Failed to open a channel")
_, err = ch.QueueDeclare(
que.Name, // name
false, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
Fail(err, "Failed to declare a queue")
return ch
}
// Connects to the message queue, opens a channel, declares a queue
func (amqpBackend *AMQPBackend) open(taskUUID string) (*amqp.Connection, *amqp.Channel, amqp.Queue, <-chan amqp.Confirmation, error) {
var (
conn *amqp.Connection
channel *amqp.Channel
queue amqp.Queue
err error
)
// Connect
// From amqp docs: DialTLS will use the provided tls.Config when it encounters an amqps:// scheme
// and will dial a plain connection when it encounters an amqp:// scheme.
conn, err = amqp.DialTLS(amqpBackend.config.Broker, amqpBackend.config.TLSConfig)
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Dial: %s", err)
}
// Open a channel
channel, err = conn.Channel()
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Channel: %s", err)
}
// Declare an exchange
err = channel.ExchangeDeclare(
amqpBackend.config.Exchange, // name of the exchange
amqpBackend.config.ExchangeType, // type
true, // durable
false, // delete when complete
false, // internal
false, // noWait
nil, // arguments
)
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Exchange Declare: %s", err)
}
// Declare a queue
arguments := amqp.Table{
"x-message-ttl": int32(amqpBackend.getExpiresIn()),
}
queue, err = channel.QueueDeclare(
taskUUID, // name
false, // durable
true, // delete when unused
false, // exclusive
false, // no-wait
arguments,
)
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Queue Declare: %s", err)
}
// Bind the queue
if err := channel.QueueBind(
queue.Name, // name of the queue
taskUUID, // binding key
amqpBackend.config.Exchange, // source exchange
false, // noWait
nil, // arguments
); err != nil {
return conn, channel, queue, nil, fmt.Errorf("Queue Bind: %s", err)
}
// Enable publish confirmations
if err := channel.Confirm(false); err != nil {
return conn, channel, queue, nil, fmt.Errorf("Channel could not be put into confirm mode: %s", err)
}
return conn, channel, queue, channel.NotifyPublish(make(chan amqp.Confirmation, 1)), nil
}
// Connects to the message queue, opens a channel, declares a queue
func (amqpBroker *AMQPBroker) open() (*amqp.Connection, *amqp.Channel, amqp.Queue, <-chan amqp.Confirmation, error) {
var (
conn *amqp.Connection
channel *amqp.Channel
queue amqp.Queue
err error
)
// Connect
conn, err = amqp.Dial(amqpBroker.config.Broker)
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Dial: %s", err)
}
// Open a channel
channel, err = conn.Channel()
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Channel: %s", err)
}
// Declare an exchange
if err := channel.ExchangeDeclare(
amqpBroker.config.Exchange, // name of the exchange
amqpBroker.config.ExchangeType, // type
true, // durable
false, // delete when complete
false, // internal
false, // noWait
nil, // arguments
); err != nil {
return conn, channel, queue, nil, fmt.Errorf("Exchange Declare: %s", err)
}
// Declare a queue
queue, err = channel.QueueDeclare(
amqpBroker.config.DefaultQueue, // name
true, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Queue Declare: %s", err)
}
// Bind the queue
if err := channel.QueueBind(
queue.Name, // name of the queue
amqpBroker.config.BindingKey, // binding key
amqpBroker.config.Exchange, // source exchange
false, // noWait
nil, // arguments
); err != nil {
return conn, channel, queue, nil, fmt.Errorf("Queue Bind: %s", err)
}
// Enable publish confirmations
if err := channel.Confirm(false); err != nil {
return conn, channel, queue, nil, fmt.Errorf("Channel could not be put into confirm mode: %s", err)
}
return conn, channel, queue, channel.NotifyPublish(make(chan amqp.Confirmation, 1)), nil
}
// Connects to the message queue, opens a channel, declares a queue
func (amqpBackend *AMQPBackend) open(taskUUID string) (*amqp.Connection, *amqp.Channel, amqp.Queue, <-chan amqp.Confirmation, error) {
var conn *amqp.Connection
var channel *amqp.Channel
var queue amqp.Queue
var err error
conn, err = amqp.Dial(amqpBackend.config.ResultBackend)
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Dial: %s", err)
}
channel, err = conn.Channel()
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Channel: %s", err)
}
err = channel.ExchangeDeclare(
amqpBackend.config.Exchange, // name of the exchange
amqpBackend.config.ExchangeType, // type
true, // durable
false, // delete when complete
false, // internal
false, // noWait
nil, // arguments
)
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Exchange: %s", err)
}
arguments := amqp.Table{
"x-message-ttl": int32(amqpBackend.getExpiresIn()),
}
queue, err = channel.QueueDeclare(
taskUUID, // name
false, // durable
true, // delete when unused
false, // exclusive
false, // no-wait
arguments,
)
if err != nil {
return conn, channel, queue, nil, fmt.Errorf("Queue Declare: %s", err)
}
if err := channel.QueueBind(
queue.Name, // name of the queue
taskUUID, // binding key
amqpBackend.config.Exchange, // source exchange
false, // noWait
nil, // arguments
); err != nil {
return conn, channel, queue, nil, fmt.Errorf("Queue Bind: %s", err)
}
confirmsChan := make(chan amqp.Confirmation, 1)
// Enable publish confirmations
if err := channel.Confirm(false); err != nil {
close(confirmsChan)
return conn, channel, queue, nil, fmt.Errorf("Channel could not be put into confirm mode: %s", err)
}
return conn, channel, queue, channel.NotifyPublish(confirmsChan), nil
}