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
}
Exemple #11
0
// 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}
}