func (cp *ConsumerPool) run() chan []common.MapStr {
conn, err := amqp.Dial(cp.ServerURI)
utils.FailOnError(err, "Failed to connect to RabbitMQ")
defer conn.Close()
ch, err := conn.Channel()
utils.FailOnError(err, "Failed to open a channel")
defer conn.Close()
events := make(chan []common.MapStr)
selCases := make([]reflect.SelectCase, len(cp.Consumers))
for i, c := range cp.Consumers {
consumerChan := c.Run(ch)
selCases[i].Dir = reflect.SelectRecv
selCases[i].Chan = reflect.ValueOf(consumerChan)
}
go func() {
for {
_, recv, recvOK := reflect.Select(selCases)
if recvOK {
events <- recv.Interface().([]common.MapStr)
}
}
}()
return events
}
func startConsuming(uri string, qName string, payloads chan<- []byte) {
conn, err := amqp.Dial(uri)
utils.FailOnError(err, "Failed to connect to RabbitMQ")
defer conn.Close()
ch, err := conn.Channel()
utils.FailOnError(err, "Failed to open a channel")
defer conn.Close()
q, err := ch.Consume(qName, "", false, false, false, false, nil)
utils.FailOnError(err, "Failed to register consumer")
// TODO: dryrun value to config
dryrun := true
maxMsgs := 10
count := 1
for m := range q {
payloads <- m.Body
if dryrun == true {
m.Nack(false, true)
count++
if count >= maxMsgs {
break
}
} else {
m.Ack(false)
}
}
close(payloads)
fmt.Println("Finished consuming")
}
func amqpConnect() (*amqp.Connection, *amqp.Channel) {
conn, err := amqp.Dial("amqp://*****:*****@localhost:5672/")
utils.FailOnError(err, "Failed to connect to RabbitMQ")
ch, err := conn.Channel()
utils.FailOnError(err, "Failed to open a channel")
return conn, ch
}
/*
Run ...
*/
func (c *Consumer) Run(ch *amqp.Channel) chan []common.MapStr {
events := make(chan []common.MapStr)
// TODO: make exchange part of config
deliveries, err := ch.Consume("test", *c.cfg.Name, false, false, false, false, nil)
utils.FailOnError(err, "Failed to register consumer")
go c.consume(deliveries, events)
return events
}
func (p *Publisher) send(ch *amqp.Channel, msg string) {
err := (*ch).Publish(p.exch, p.routingKey, false, true, amqp.Publishing{
DeliveryMode: amqp.Persistent,
ContentType: "text/plain",
Body: []byte(msg),
})
utils.FailOnError(err, "Failed to publish message")
}
func firehosePublisher(exch string, routingKey string, ch *amqp.Channel) {
for i := 0; i < 1000; i++ {
err := (*ch).Publish(exch, routingKey, false, true, amqp.Publishing{
DeliveryMode: amqp.Persistent,
ContentType: "text/plain",
Body: []byte(fmt.Sprintf("{\"test\": %d}", i)),
})
utils.FailOnError(err, "Failed to send message")
}
}
// Config extracts settings from the config file
func (mb *Amqpbeat) Config(b *beat.Beat) error {
// Config loading goes here
err := cfgfile.Read(&mb.config, "")
utils.FailOnError(err, "Error reading configuration file")
//if err != nil {
// logp.Err("Error reading configuration file: %v", err)
// return err
// }
logp.Debug("amq", " is configured")
return nil
}
func (cp *ConsumerPool) init(cfg *config.AmqpConfig) {
cp.ServerURI = *cfg.ServerURI
cp.Consumers = make([]*Consumer, len(*cfg.Channels))
for i, chConfig := range *cfg.Channels {
c := new(Consumer)
c.Init(&chConfig, func(b []byte) common.MapStr {
e := new(common.MapStr)
err := json.Unmarshal(b, e)
utils.FailOnError(err, "Failed to marshal event")
return *e
})
cp.Consumers[i] = c
}
}
// Run ...
func (mb *Amqpbeat) Run(b *beat.Beat) error {
args := os.Args
payloads := make(chan []byte)
fmt.Println(mb.config.AmqpInput)
fmt.Println((*mb.config.AmqpInput.Channels)[0])
fmt.Println((*mb.config.AmqpInput.Channels)[0].Name)
go startConsuming(args[1], *(*mb.config.AmqpInput.Channels)[0].Name, payloads)
for p := range payloads {
var event map[string]interface{}
err := json.Unmarshal(p, &event)
utils.FailOnError(err, "Failed to unmarshal value")
event["@timestamp"] = common.Time(time.Now())
event["type"] = "openstack"
fmt.Println(event)
mb.events.PublishEvent(event, publisher.Sync)
}
return nil
}
func newBeat(cfgFile string, client *MockClient) (*Amqpbeat, *beat.Beat) {
wd, err := os.Getwd()
utils.FailOnError(err, "Could not determine working directory")
ab := &Amqpbeat{}
b := beat.NewBeat("amqpbeat", "0.0.0", ab)
ab.ConfigWithFile(b, fmt.Sprintf("%s/../test/config/%s", wd, cfgFile))
if client == nil {
client = &MockClient{
eventsPublished: func(event []common.MapStr, beat *Amqpbeat) {
},
}
}
client.beat = ab
b.Events = client
ab.Setup(b)
return ab, b
}
// ConfigWithFile ...
func (ab *Amqpbeat) ConfigWithFile(b *beat.Beat, path string) error {
// Config loading goes here
err := cfgfile.Read(&ab.config, path)
utils.FailOnError(err, "Error reading configuration file")
return nil
}
func newPublisher(exch string, routingKey string, ch *amqp.Channel) *Publisher {
_, err := ch.QueueDeclare(routingKey, false, true, false, false, nil)
utils.FailOnError(err, fmt.Sprintf("Failed to declare queue %s", routingKey))
return &Publisher{exch: exch, routingKey: routingKey, ch: ch}
}