func StartSubscribers(amqpChan *amqp.Channel, esClient *elastic.Client, config *config.Config) { log.Println("Starting RabbitMQ subscribers") msgChan, err := amqpChan.Consume(config.AmqpQueues[0], "", true, false, false, false, nil) utils.CheckFatalError(err) go incomingDocConsumer(msgChan, esClient, config) log.Println("Started RabbitMQ subscribers") }
func amqpEventReceiver(ch *amqp.Channel, q amqp.Queue, c chan Event) { msgs, err := ch.Consume( q.Name, // queue "", // consumer true, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) if err != nil { //fixme send error to something ? } for d := range msgs { var ev Event ev.Headers = d.Headers ev.Headers["_transport-exchange"] = d.Exchange ev.Headers["_transport-RoutingKey"] = d.RoutingKey ev.Headers["_transport-ContentType"] = d.ContentType ev.Body = d.Body c <- ev } c <- Event{ Body: []byte("dc1?"), } os.Exit(1) }
/* 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 Consume(q *amqp.Queue, ch *amqp.Channel) (<-chan amqp.Delivery, error) { return ch.Consume( q.Name, // queue "", // consumer false, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) }
//ConsumeQueueWithChannel consumes a RabbitMQConnection queue with predefined settings from a provided amqp.Channel func (c *RabbitMQConnection) ConsumeQueueWithChannel(queue string, ch *amqp.Channel) (<-chan amqp.Delivery, error) { return ch.Consume( queue, "", false, //Auto ACK. False because we want to make sure of data integrity false, false, false, nil, ) }
func getDeliveries(channel *amqp.Channel, queueName string) (<-chan amqp.Delivery, error) { deliveries, err := channel.Consume(queueName, "", false, true, true, false, nil) if err != nil { if err, ok := err.(*amqp.Error); ok { if err.Code == amqp.AccessRefused && strings.HasSuffix(err.Reason, "in exclusive use") { return nil, nil } } return nil, err } return deliveries, nil }
func subscribe(ch *amqp.Channel, o *Options, tag string) (<-chan amqp.Delivery, error) { autoAck := false exclusive := false noLocal := false noWait := false var args amqp.Table if o.Priority > 0 { args = amqp.Table{} args["x-priority"] = o.Priority } return ch.Consume(o.Queue, tag, autoAck, exclusive, noLocal, noWait, args) }
func listenForDiscoveryRequests(name string, ch *amqp.Channel) { msgs, _ := ch.Consume( name, "", true, false, false, false, nil) for range msgs { publishQueueName(ch) } }
func sineMain(ch *amqp.Channel) { go sniffy() q, err := ch.QueueDeclare( "", // name false, // durable false, // delete when usused true, // exclusive false, // no-wait nil, // arguments ) failOnError(err, "Failed to declare a queue") err = ch.QueueBind( q.Name, // queue name "", // routing key "bpm", // exchange false, nil) failOnError(err, "Failed to bind a queue") msgs, err := ch.Consume( q.Name, // queue "", // consumer true, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) failOnError(err, "Failed to register a consumer") portaudio.Initialize() defer portaudio.Terminate() //s := newStereoSine(256, 320, sampleRate) s := newStereoSine(220, 220, sampleRate) defer s.Close() chk(s.Start()) defer s.Stop() for m := range msgs { var bm BpmMsg err := json.Unmarshal(m.Body, &bm) if err != nil { fmt.Println("blah", err) } bpm = bm.Bpm } }
func WaitForFile(channel *amqp.Channel, filePath string, queueName string) { defer channel.Close() <-LockFile(filePath) defer UnlockFile(filePath) msgs, err := channel.Consume( queueName, // queue "", // consumer true, // auto-ack true, // exclusive false, // no-local false, // no-wait nil, // args ) if err != nil { panic(fmt.Errorf("Failed to register a consumer: %s", err.Error())) } log.Println("waiting for file to be transfered") fullPath := filepath.Join(rootDir, filePath) file, err := os.OpenFile(fullPath, os.O_RDWR|os.O_APPEND|os.O_CREATE|os.O_TRUNC, 0600) if err != nil { log.Fatalf("couldn't open local file %s", fullPath, err) } defer file.Close() for { msg := <-msgs order, err := strconv.Atoi(msg.Headers["Order"].(string)) if err != nil { log.Println(fmt.Errorf("no order was present in the header for file transfer")) break } chunk := &FileChunk{ order, msg.Body, } if chunk.Order == -1 { break } log.Printf("writing chunk %d for file %s\n", chunk.Order, file.Name()) file.Write(chunk.Chunk) } log.Println("finished receiving file", filePath) }
func Consume(ch *amqp.Channel, b *bind) (<-chan amqp.Delivery, error) { var err error q, err := ch.QueueDeclare(b.name, true, false, false, false, nil) if err != nil { Log.Error("queue declare err: %v", err) } err = ch.QueueBind(b.name, b.key, b.exchange, false, nil) if err != nil { Log.Error("queue bind err: %v", err) } tasks, err := ch.Consume(q.Name, b.tag, false, false, false, false, nil) return tasks, err }
func consumeQueue(channel *amqp.Channel, chanName string) (<-chan amqp.Delivery, error) { msgChan, err := channel.Consume( chanName, // queue "", // consumer true, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) if err != nil { return nil, fmt.Errorf("CONSUMING '%s' CHANNEL: %s", chanName, err.Error()) } return msgChan, nil }
func (s *Server) consumer() { var ( ch *amqp.Channel err error q amqp.Queue consumer <-chan amqp.Delivery ) qArgs := amqp.Table{} if *ttl > 0 { qArgs["x-message-ttl"] = int64(*ttl) } if s.Ttl > 0 { qArgs["x-message-ttl"] = int64(s.Ttl) } for s.alive { if err != nil { ch = nil log.Println(err) err = nil time.Sleep(*backoff) continue } if ch == nil { ch, err = s.dial() } if ch != nil { q, err = ch.QueueDeclare(*queue, false, true, true, false, qArgs) if err != nil { continue } err = ch.QueueBind(q.Name, s.Source, s.Source, false, nil) if err != nil { continue } consumer, err = ch.Consume(q.Name, "mqslice", true, true, false, false, nil) if err != nil { continue } for elt := range consumer { s.ch <- elt.Body } ch.Close() ch = nil } } }
func (d *DefaultWorker) Consume(ch *amqp.Channel, cfg config.EndpointConfig) (<-chan amqp.Delivery, error) { queueName, ok := cfg.QueueConfig["queuename"].(string) if !ok { return nil, fmt.Errorf("unable to parse queuename from config") } prefetch, ok := cfg.QueueConfig["prefetch"].(int) if !ok || prefetch < 1 { prefetch = 1 } q, err := ch.QueueDeclare( queueName, // name true, // durable false, // delete when unused false, // exclusive false, // no-wait nil, // arguments ) if err != nil { return nil, err } err = ch.Qos( prefetch, // prefetch count 0, // prefetch size false, // global ) if err != nil { return nil, err } msgs, err := ch.Consume( q.Name, // queue "", // consumer false, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) if err != nil { return nil, err } return msgs, nil }
func msgListener(ch *amqp.Channel) { q, err := ch.QueueDeclare( "", // name false, // durable false, // delete when usused true, // exclusive false, // no-wait nil, // arguments ) failOnError(err, "Failed to declare a queue") err = ch.QueueBind( q.Name, // queue name "", // routing key "updateMsgs", // exchange false, nil) failOnError(err, "Failed to bind a queue") msgs, err := ch.Consume( q.Name, // queue "", // consumer true, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) failOnError(err, "Failed to register a consumer") for d := range msgs { var m UpdateMsg err := json.Unmarshal(d.Body, &m) if err != nil { fmt.Println("blah", err) } if m.Name == "bpm" { fmt.Println("Setting BPM to", m.Value) bpm = m.Value } } }
func (rb *AmqpBeat) consumeIntoStream(stream chan<- *AmqpEvent, ch *amqp.Channel, c *ChannelConfig, wg *sync.WaitGroup) { defer wg.Done() err := ch.Qos(*c.QosPrefetchCount, 0, false) if err != nil { logp.Err("Failed to set QoS on queue '%s': %v", *c.Name, err) } _, err = ch.QueueDeclare(*c.Name, *c.Durable, *c.AutoDelete, false, false, *c.Args) if err != nil { logp.Err("Failed to declare queue '%s': %v", *c.Name, err) return } q, err := ch.Consume(*c.Name, "", false, false, false, false, *c.Args) if err != nil { logp.Err("Failed to consume queue %s: %v", *c.Name, err) return } mName := fmt.Sprintf("consumer.%s", *c.Name) var msgCount int64 for { select { case d := <-q: evt, err := rb.newAmqpEvent(&d, c.TypeTag, c.TsField, c.TsFormat) msgCount++ logp.Debug("flow", "Consumed %d into %s", msgCount, *c.Name) if err != nil { logp.Warn("failed to build event for delivery, will be Nacked. (delivery = %v) (error = %v)", d, err) d.Nack(false, true) } stream <- evt rb.metrics <- &metric{name: mName, value: msgCount} case <-rb.stop: logp.Info("Consumer '%s' is stopping...", *c.Name) return } } logp.Info("Consumer '%s' has stopped.") }
func NewConsumer(consumerName string, queueName string, exchange Exchange, config *Config) (consumer *Consumer, err error) { if consumerName == "" { err = errors.New("Must give the consumer a name") return } if queueName == "" { err = errors.New("Must give the queue name.") return } if len(queueName) > 255 { err = errors.New("Must give a queue name that contains 1-255 characters.") return } if err = exchange.Validate(); err != nil { return } if config == nil { config = NewConfig() } conn, err := amqp.Dial(config.GetConnectionString()) if err != nil { return } //setup the channel var channel *amqp.Channel if channel, err = conn.Channel(); err != nil { return } //setup the exchange if err = channel.ExchangeDeclare( exchange.Name, //exchange name exchange.Type, //exchange type true, //durable false, //remove when complete false, //internal false, //noWait nil, //arguments ); err != nil { return } //setup the queue var queue amqp.Queue if queue, err = channel.QueueDeclare( queueName, // name of the queue true, // durable false, // delete when usused false, // exclusive false, // noWait nil, // arguments ); err != nil { return } if err = channel.QueueBind( queue.Name, //queue name exchange.RoutingKey, //routing key ("binding key") exchange.Name, //exchange (source) false, //noWait nil, //arguments ); err != nil { return } //setup the deliverables var messages <-chan amqp.Delivery if messages, err = channel.Consume( queue.Name, //queue name consumerName, //consumer name false, //auto acknowledge false, //exclusive false, //not local false, //no wait nil, //arguments ); err != nil { return } consumer = new(Consumer) consumer.Name = consumerName consumer.config = config consumer.conn = conn consumer.channel = channel consumer.Exchange = exchange consumer.incomingMessages = messages return }
func Start() { mq := g.Config().Mq nodes := map[string]interface{}{} // Retry RetriedLimit times if there is some problem during connecting var ch *amqp.Channel var conn *amqp.Connection var err error for i := 0; i < RetriedLimit; i++ { if conn, ch, err = setup(mq.Queue); err != nil { time.Sleep(time.Second * SleepTimePeriod) } } if err != nil { log.Println(ExitStringPrefix + "retried too many times.") return } defer conn.Close() defer ch.Close() q, err := ch.QueueDeclare( "mute", // name false, // durable false, // delete when usused false, // exclusive false, // no-wait nil, // arguments ) if err != nil { log.Printf(LogStringFormat, ExitStringPrefix+"failed to declare a queue", err) return } msgs, err := ch.Consume( q.Name, // queue "", // consumer true, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) if err != nil { log.Printf(LogStringFormat, ExitStringPrefix+"failed to register a consumer", err) return } forever := make(chan bool) var pkt Message go func() { for d := range msgs { json.Unmarshal(d.Body, &pkt) log.Printf("Received a message: %v", pkt) params := map[string]string{ "host": pkt.Hostname, "mute": "", } if pkt.Mute { params["mute"] = "1" } else { params["mute"] = "0" } payload := map[string]interface{}{ "method": "host.update", "params": params, } log.Println("payload =", payload) s, err := json.Marshal(payload) if err != nil { log.Println("json.Marshal Error:", err.Error()) } url := mq.Consumer log.Println("url =", url) reqPost, err := http.NewRequest("POST", url, bytes.NewBuffer([]byte(s))) if err != nil { log.Println("reqPost Error:", err.Error()) } reqPost.Header.Set("Content-Type", "application/json") client := &http.Client{} resp, err := client.Do(reqPost) if err != nil { log.Println("resp Error:", err.Error()) } else { defer resp.Body.Close() body, _ := ioutil.ReadAll(resp.Body) err = json.Unmarshal(body, &nodes) if err != nil { log.Println("Unmarshal Error:", err.Error()) } log.Println("nodes =", nodes) } } }() log.Println("mq.Start ok. Waiting for messages.") <-forever }
// connects to an AMQP topic and emits each message into streamtools. func (b *FromAMQP) Run() { var err error var conn *amqp.Connection var amqp_chan *amqp.Channel toOut := make(blocks.MsgChan) toError := make(chan error) host := "localhost" port := "5672" username := "******" password := "******" routingkey := "#" exchange := "amq.topic" exchange_type := "topic" for { select { case msg := <-toOut: b.out <- msg case err := <-toError: b.Error(err) case ruleI := <-b.inrule: rule := ruleI.(map[string]interface{}) routingkey, err = util.ParseString(rule, "RoutingKey") if err != nil { b.Error(err) continue } exchange, err = util.ParseString(rule, "Exchange") if err != nil { b.Error(err) continue } exchange_type, err = util.ParseString(rule, "ExchangeType") if err != nil { b.Error(err) continue } host, err = util.ParseString(rule, "Host") if err != nil { b.Error(err) continue } port, err = util.ParseString(rule, "Port") if err != nil { b.Error(err) continue } username, err = util.ParseString(rule, "Username") if err != nil { b.Error(err) continue } password, err = util.ParseString(rule, "Password") if err != nil { b.Error(err) continue } conn, err = amqp.Dial("amqp://" + username + ":" + password + "@" + host + ":" + port + "/") if err != nil { b.Error(err) continue } amqp_chan, err = conn.Channel() if err != nil { b.Error(err) continue } err = amqp_chan.ExchangeDeclare( exchange, // name exchange_type, // type true, // durable false, // auto-deleted false, // internal false, // noWait nil, // arguments ) if err != nil { b.Error(err) continue } queue, err := amqp_chan.QueueDeclare( "", // name false, // durable true, // delete when unused false, // exclusive false, // noWait nil, // arguments ) if err != nil { b.Error(err) continue } err = amqp_chan.QueueBind( queue.Name, // queue name routingkey, // routing key exchange, // exchange false, nil, ) if err != nil { b.Error(err) continue } deliveries, err := amqp_chan.Consume( queue.Name, // name "", // consumerTag true, // noAck false, // exclusive false, // noLocal false, // noWait nil, // arguments ) if err != nil { b.Error(err) continue } h := readWriteAMQPHandler{toOut, toError} go h.handle(deliveries) case <-b.quit: if amqp_chan != nil { amqp_chan.Close() } if conn != nil { conn.Close() } return case c := <-b.queryrule: c <- map[string]interface{}{ "Host": host, "Port": port, "Username": username, "Password": password, "Exchange": exchange, "ExchangeType": exchange_type, "RoutingKey": routingkey, } } } }
func clientMain(ch *amqp.Channel) { q, err := ch.QueueDeclare( "", // name false, // durable false, // delete when usused true, // exclusive false, // no-wait nil, // arguments ) failOnError(err, "Failed to declare a queue") err = ch.QueueBind( q.Name, // queue name "", // routing key "bpm", // exchange false, nil) failOnError(err, "Failed to bind a queue") msgs, err := ch.Consume( q.Name, // queue "", // consumer true, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) failOnError(err, "Failed to register a consumer") for d := range msgs { var bm BpmMsg err := json.Unmarshal(d.Body, &bm) if err != nil { fmt.Println("blah", err) } fmt.Println(bm) // if bm.TickCounter%4 == 1 { if bm.MicroTick == 1 { fmt.Println("KICK Got one Modulo 4!", bm.TickCounter) //go playrrr(kick, Soxfilter{}) //if rand.Intn(10) > 2 { go playrrr(kick, Soxfilter{Effect: "pitch", Val: strconv.Itoa(int(math.Pow(float64(bm.TickCounter%1000), 3.0)) % 1000)}) //} else { // fmt.Println("RANDY MISSS!") //} } //if bm.TickCounter%4 == 0 { // fmt.Println("SNARE Got one Modulo 3!", bm.TickCounter) // //go playrrr(snare, Soxfilter{}) // if rand.Intn(10) > 1 { // //go playrrr(snare, Soxfilter{Effect: "pitch", Val: strconv.Itoa(int(math.Pow(float64(bm.TickCounter%1000), 3.0)) % 1000)}) // go playrrr(snare, Soxfilter{}) // } //} //if bm.TickCounter%2 == 0 { // fmt.Println("HAT Got one Modulo 1!", bm.TickCounter) // // go playrrr(hat + " pitch " + strconv.Itoa(bm.TickCounter%1000)) // if rand.Intn(10) > 4 { // go playrrr(hat, Soxfilter{Effect: "pitch", Val: strconv.Itoa(int(math.Pow(float64(bm.TickCounter%1000), 3.0)) % 1000)}) // } //} } }
func (d *Topic) Consume(ch *amqp.Channel, cfg config.EndpointConfig) (<-chan amqp.Delivery, error) { queueName, ok := cfg.QueueConfig["queuename"].(string) if !ok { return nil, fmt.Errorf("unable to parse queuename from config") } topicName, ok := cfg.QueueConfig["topicname"].(string) if !ok { return nil, fmt.Errorf("unable to parse topicname from config") } exchangeName, ok := cfg.QueueConfig["exchangename"].(string) if !ok { return nil, fmt.Errorf("unable to parse exchangename from config") } prefetch, ok := cfg.QueueConfig["prefetch"].(int) if !ok || prefetch < 1 { prefetch = 1 } err := ch.ExchangeDeclare( exchangeName, // name "topic", // type true, // durable false, // auto-deleted false, // internal false, // no-wait nil, // arguments ) if err != nil { return nil, err } q, err := ch.QueueDeclare( queueName, // name true, // durable false, // delete when usused false, // exclusive false, // no-wait nil, // arguments ) if err != nil { return nil, err } err = ch.Qos( prefetch, // prefetch count 0, // prefetch size false, // global ) if err != nil { return nil, err } err = ch.QueueBind( q.Name, // queue name topicName, // routing key exchangeName, // exchange false, nil, ) if err != nil { return nil, err } msgs, err := ch.Consume( q.Name, // queue "", // consumer false, // auto-ack false, // exclusive false, // no-local false, // no-wait nil, // args ) if err != nil { return nil, err } return msgs, nil }