// Function to send keep alive message over specified channel
func sendKeepAlive(channel *amqp.Channel, client ClientConfig) error {
// Create a keepalive struct to send to server
body := &KeepAlive{
Name: client.Name,
Address: client.Address,
Subscriptions: client.Subscriptions,
Timestamp: time.Now().Unix(),
}
// Parse the keepalive struct to json
bodyJson, err := json.Marshal(body)
if err != nil {
return err
}
// Create the amqp message to publish
msg := amqp.Publishing{
ContentType: "application/octet-stream",
DeliveryMode: amqp.Persistent,
Priority: 0,
Body: bodyJson,
}
// Publish message to amqp server
if err := channel.Publish("keepalives", "", false, false, msg); err != nil {
return err
}
// Returns nil as error if message was sent successfully
return nil
}
func (rc RequestChan) publish() error {
var (
err error
out *amqp.Channel
)
for r := range rc {
if r == nil {
break
}
for out == nil {
out, err = dial()
if err != nil {
out = nil
log.Println(err)
time.Sleep(*backoff)
}
}
err = out.Publish(*exchange, *key, false, false,
amqp.Publishing{
Headers: amqp.Table(r.Headers),
ContentType: r.ContentType,
Body: r.Body,
},
)
if err != nil {
return err
}
}
return nil
}
func handleChange(channel *amqp.Channel, ev *fsnotify.FileEvent) error {
// check to see if the file is locked. If it is then break
path, _ := filepath.Rel(rootDir, ev.Name)
if FileIsLocked(path) {
return nil
}
log.Printf("PUBLISHER: publishing %dB path (%q)", len(path), path)
var change = &Change{
IsCreate: ev.IsCreate(),
IsDelete: ev.IsDelete(),
IsMod: ev.IsModify(),
IsMove: ev.IsRename(),
ModDate: time.Now().UTC(),
Path: path,
Source: hostname,
Checksum: Checksum(ev.Name),
}
msg, err := json.Marshal(change)
if err != nil {
log.Fatalf("ERROR marshaling msg %s", change)
}
if err := channel.Publish(
"changes", // publish to an exchange
"", // routing to 0 or more queues
false, // mandatory
false, // immediate
amqp.Publishing{
Headers: amqp.Table{},
ContentType: "application/json",
ContentEncoding: "",
Body: msg,
DeliveryMode: amqp.Transient, // 1=non-persistent, 2=persistent
Priority: 0, // 0-9
// a bunch of application/implementation-specific fields
/*
ContentType string // MIME content type
ContentEncoding string // MIME content encoding
DeliveryMode uint8 // Transient (0 or 1) or Persistent (2)
Priority uint8 // 0 to 9
CorrelationId string // correlation identifier
ReplyTo string // address to to reply to (ex: RPC)
Expiration string // message expiration spec
MessageId string // message identifier
Timestamp time.Time // message timestamp
Type string // message type name
UserId string // creating user id - ex: "guest"
AppId string // creating application id
*/
},
); err != nil {
log.Fatalf("Exchange Publish: %s", err)
panic(err)
}
return nil
}
func cmdMain(ch *amqp.Channel) {
fmt.Println(len(os.Args))
if len(os.Args) != 4 {
cmdUsage()
}
name := os.Args[2]
val, _ := strconv.Atoi(os.Args[3])
fmt.Println("ARGS", os.Args, name, val)
m := UpdateMsg{name, val}
msg, err := json.Marshal(m)
if err != nil {
log.Fatal("Barf!", err)
}
err = ch.Publish(
"updateMsgs", // exchange
"", // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "text/json",
Body: msg,
})
failOnError(err, "Failed to publish a message")
log.Printf("Sending msg -- %s", msg)
os.Exit(0)
}
func (rc requestCh) publish() error {
var (
err error
out *amqp.Channel
)
for r := range rc {
if r == nil {
break
}
for out == nil {
out, err = dial()
if err != nil {
out = nil
log.Println(err)
time.Sleep(*backoff)
}
}
err = out.Publish(*exchange, *key, false, false,
amqp.Publishing{
Headers: amqp.Table(r.headers),
DeliveryMode: amqp.Persistent,
Body: []byte(r.body),
},
)
if err != nil {
return err
}
}
return nil
}
func (r *Rabbitmq) Publish(ch *amqp.Channel, msg *amqp.Publishing) (err error) {
try_count := 3
if ch == nil {
log.Printf("[WARNING] send to mq failed: Channel must not be empty\n")
return errors.New("ampq channel is nil")
}
defer func() {
if f := recover(); f != nil {
log.Printf("[WARNING] send to mq failed:%v\n", f)
err = f.(error)
}
}()
for i := 0; i < try_count; i++ {
err = ch.Publish(r.Exchange, r.RoutingKey, false, false, *msg)
if err != nil {
conn_err := r.Reconn()
ch1, _ := r.Channel()
*ch = *ch1
log.Printf("[WARNING] RabbitMQ Reconn err is %v send to bnow failed:%v try Count:%v\n", conn_err, err, i)
time.Sleep(time.Second)
continue
}
break
}
return
}
func monitoring(uri string, queueName string, mgmtUri string, prefix string) {
var (
queueConn *amqp.Connection
queueChan *amqp.Channel
err error
)
queueConn, queueChan, err = rabbitmqConnect(uri, queueName)
if err != nil {
return
}
for {
log.Printf("fetch rabbitmq stats")
var metrics []graphite.Metric
for _, metric := range fetchQueueMetrics(mgmtUri, prefix) {
metrics = append(metrics, metric)
}
for _, metric := range fetchExchangeMetrics(mgmtUri, prefix) {
metrics = append(metrics, metric)
}
for _, metric := range metrics {
body := []byte(metric.Name + "\t" + metric.Value + "\t" + strconv.FormatInt(metric.Timestamp, 10))
msg := amqp.Publishing{ContentType: "text/plain", Body: body}
err = queueChan.Publish("", queueName, false, false, msg)
if err != nil {
log.Printf("publish err: %s", err)
return
}
//log.Printf("metric\t%s\t\t%s", metric.Name, metric.Value)
}
time.Sleep(time.Second * 5)
}
queueChan.Close()
queueConn.Close()
}
func produce(conn *amqp.Connection, channel *amqp.Channel, val *interface{}) {
if val == nil {
log.Warn("the redis json is nil")
return
}
body, err := json.Marshal(val)
if err != nil || body == nil {
log.Error("redis event to json error: %s , oplog is : %s ", err, string(body))
} else {
routingKey := "redis.event"
log.Info("routing key is : %s ", routingKey)
err = channel.Publish(
EXCHANGE_KEY, // exchange
routingKey, // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "text/plain",
Body: body,
})
if err != nil {
log.Error("publish message err : %s ", err)
}
//TODO recreate channel ?
}
}
func SendEmail(req *http.Request, mail Email, r render.Render, ch *amqp.Channel) {
msg, _ := json.Marshal(mail)
q, _ := ch.QueueDeclare(
"email", // name
true, // durable
false, // delete when usused
false, // exclusive
false, // no-wait
nil, // arguments
)
err := ch.Publish(
"", // exchange
q.Name, // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "json/plain",
Body: []byte(msg),
})
if err == nil {
r.JSON(http.StatusOK, map[string]interface{}{"Email": mail})
} else {
r.JSON(http.StatusInternalServerError, err)
}
}
func (s *Server) run() error {
ch, err := s.dial()
if err != nil {
return err
}
for name, sink := range s.Sinks {
if err := ch.ExchangeDeclare(name, sink.Type, true, false, false, false, nil); err != nil {
return err
}
go func(name string, sink *Sink) {
var (
ch *amqp.Channel
elt []byte
err error
)
for s.alive {
if err != nil {
ch = nil
log.Println(err)
err = nil
time.Sleep(*backoff)
continue
}
if len(elt) == 0 {
elt = <-sink.ch
}
if ch == nil {
if ch, err = s.dial(); err != nil {
continue
}
}
if ch != nil {
err = ch.Publish(name, name, false, false, amqp.Publishing{Body: elt})
if err == nil {
elt = nil
}
}
}
}(name, sink)
}
for i := 0; i < *threads; i++ {
go func() {
for s.alive {
elt := <-s.ch
for _, sink := range s.Sinks {
if sink.regex != nil && !sink.regex.Match(elt) {
continue
}
sink.ch <- elt
}
}
}()
}
go s.consumer()
return nil
}
func moveToFailQueue(ch *amqp.Channel, msgBody []byte, headers map[string]string) bool {
var tableHeader amqp.Table
tableHeader = make(amqp.Table)
mapB, _ := json.Marshal(headers)
tableHeader["sended"] = string(mapB)
ch.Publish("", "events-hook-comm-fail-queue", false, false, amqp.Publishing{Headers: tableHeader, Body: msgBody})
return true
}
func publishQueueName(ch *amqp.Channel) {
msg := amqp.Publishing{Body: []byte(*name)}
ch.Publish(
"amq.fanout", // exchange string
"", // key string
false, // mandatory bool
false, // immediate bool
msg) // msg amqp.Publishing
}
func PublishJson(content []byte, exchange string, ch *amqp.Channel) error {
return ch.Publish(
exchange, // exchange
"", // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "application/json",
Body: content,
})
}
func PushKey(ch *amqp.Channel, r HttpResponse, queueName string) error {
v := fmt.Sprintf("http_response:%s:%s", r.CrawlerName, r.Url)
msg := amqp.Publishing{
// DeliveryMode: amqp.Persistent,
DeliveryMode: amqp.Transient,
ContentType: "text/plain",
Body: []byte(v),
}
err := ch.Publish("", queueName, false, false, msg)
return err
}
func HandleMessageBytes(bytes []byte, channel *amqp.Channel, debugger amqptools.Debugger) {
var err error
delivery := &amqptools.DeliveryPlus{}
err = json.Unmarshal(bytes, &delivery)
if debugger.WithError(err, "Unable to unmarshal delivery into JSON: ", err) {
os.Exit(7)
}
// DO STUFF WITH INPUT LINE
rawDelivery := delivery.RawDelivery
bodyBytes := rawDelivery.Body
errorMessage := &ErrorMessage{}
err = json.Unmarshal(bodyBytes, &errorMessage)
if debugger.WithError(err, "Unable to unmarshal delivery into JSON: ", err) {
os.Exit(7)
}
oMsg := errorMessage.OriginalMessage
debugger.Print(fmt.Sprintf("consumed message: %+v", errorMessage.OriginalMessage))
var timestamp time.Time
if *timeNow {
timestamp = time.Now().UTC()
} else {
timestamp, err = time.Parse(timeFormat, oMsg.Properties.Timestamp)
if debugger.WithError(err, fmt.Sprintf("Unable to parse timestamp: %+v", oMsg.Properties.Timestamp), err) {
os.Exit(11)
}
}
msg := &amqp.Publishing{
ContentType: oMsg.Properties.ContentType,
ContentEncoding: oMsg.Properties.ContentEncoding,
DeliveryMode: uint8(oMsg.Properties.DeliveryMode),
CorrelationId: oMsg.Properties.CorrelationId,
MessageId: oMsg.Properties.MessageId,
Timestamp: timestamp,
AppId: oMsg.Properties.AppId,
Body: []byte(oMsg.Payload),
}
err = channel.Publish(oMsg.Exchange, oMsg.RoutingKey, true, false, *msg)
if debugger.WithError(err, "Unable to publish: ", err) {
os.Exit(19)
}
}
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 ensureNonZeroMessageRate(ch *amqp.Channel) {
for i := 0; i < 2000; i++ {
q, _ := ch.QueueDeclare(
"", // name
false, // durable
false, // delete when usused
true, // exclusive
false,
nil)
ch.Publish("", q.Name, false, false, amqp.Publishing{Body: []byte("")})
}
}
func binary(ch *amqp.Channel, exchange string, n int) error {
for i := 0; i < n; i++ {
next := fmt.Sprintf("%63b", rand.Int63())
err := ch.Publish(exchange, exchange, false, false, amqp.Publishing{
Body: []byte(next),
})
if err != nil {
return err
}
}
return nil
}
func publish(ch *amqp.Channel, q amqp.Queue, c <-chan string) {
for {
connectionStatus := <-c
if connectionStatus == "lost" {
for i := 0; i < 40; i++ {
conn, err := amqp.Dial("amqp://*****:*****@localhost:5672/")
if err != nil {
fmt.Println("Failed to connect to RabbitMQ")
time.Sleep(1 * time.Second)
continue
} else {
defer conn.Close()
}
}
}
if connectionStatus == "ok" {
conn, err := amqp.Dial("amqp://*****:*****@localhost:5672/")
if err != nil {
fmt.Println("Failed to connect to RabbitMQ")
time.Sleep(1 * time.Second)
continue
} else {
defer conn.Close()
}
ch, _ := conn.Channel()
defer ch.Close()
body := bodyFrom(os.Args)
q, err := ch.QueueDeclare(
"task_queue", // name
true, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
err = ch.Publish(
"", // exchange
q.Name, // routing key
false, // mandatory
false,
amqp.Publishing{
DeliveryMode: amqp.Persistent,
ContentType: "text/plain",
Body: []byte(body),
})
if err == nil {
log.Printf(" [x] Sent %s", body)
}
}
time.Sleep(1 * time.Second)
}
}
// send sends a message using the given queue and a channel.
func send(msg []byte, rk string, ch *amqp.Channel, q amqp.Queue) {
err := ch.Publish(
"", // exchange
rk, // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "text/plain",
Body: msg,
})
if err != nil {
log.Fatalf("Failed to publish a message: %s", err)
}
}
func connectKey(ch *amqp.Channel, key string, exchange string) {
body := utils.RandomTimelineEvent()
bodyJSON, err := json.Marshal(body)
err = ch.Publish(
exchange, // exchange
key, // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "application/json",
Body: []byte(bodyJSON),
})
utils.FailOnError(err, "failed to publish a message")
log.Printf(" [x] Sent %s", body)
}
// Publish a task to an AMQP channel,
// default exchange is "",
// default routing key is "celery"
func (t *Task) Publish(ch *amqp.Channel, exchange, key, content_type string) error {
body, err := json.Marshal(t)
if err != nil {
return err
}
msg := amqp.Publishing{
DeliveryMode: amqp.Persistent,
Timestamp: time.Now(),
ContentType: content_type,
ContentEncoding: "utf-8",
Body: body,
}
return ch.Publish(exchange, key, false, false, msg)
}
func publishMessages(wg *sync.WaitGroup, ch *amqp.Channel, qName string, msgs chan string) {
for m := range msgs {
err := ch.Publish(
"",
qName,
false,
false,
amqp.Publishing{
MessageId: fmt.Sprintf(m),
ContentType: "text/plain",
Body: []byte(m),
})
failOnError(err, "Failed to send msg")
}
wg.Done()
}
func publishMessage(ch *amqp.Channel, exchange, routingKey, text string) {
ch.Publish(
exchange,
routingKey,
false,
false,
amqp.Publishing{
Headers: amqp.Table{},
ContentType: "application/json",
ContentEncoding: "",
Body: []byte(text),
DeliveryMode: amqp.Transient,
Priority: 0,
})
}
// Function to send keep alive message over specified channel
func Send(channel *amqp.Channel, msgType string, msgBody []byte) error {
// Create the amqp message to publish
msg := amqp.Publishing{
ContentType: "application/octet-stream",
DeliveryMode: amqp.Persistent,
Priority: 0,
Body: msgBody,
}
// Publish message to amqp server
if err := channel.Publish(msgType, "", false, false, msg); err != nil {
return err
}
// Returns nil as error if message was sent successfully
return nil
}
func publish(channel *amqp.Channel, i int, tenant string, queue string) (err error) {
err = channel.Publish(
"", //exchange
queue, //routingKey, for some reason we need to put the queue name here
false,
false,
amqp.Publishing{
Headers: amqp.Table{},
ContentType: "text/plain",
ContentEncoding: "UTF-8",
Body: []byte(fmt.Sprintf("%d,%s", i, tenant)),
DeliveryMode: 2, // 1=non-persistent, 2=persistent
Priority: 9,
},
)
return
}
func (s *client) send(ch *amqp.Channel, group uint64, o *Options, payload []byte) ([]byte, error) {
id, err := s.flake.Next()
if err != nil {
return nil, err
}
groupString := fmt.Sprintf("%d", group)
envelope := amqp.Publishing{
MessageId: fmt.Sprintf("%d", id),
CorrelationId: groupString,
Body: payload,
DeliveryMode: amqp.Transient,
Headers: amqp.Table{timestampHeader: time.Now().UnixNano()},
}
if o.Persistent {
envelope.DeliveryMode = amqp.Persistent
}
mandatory := false
immediate := false
if err := ch.Publish(o.Exchange, o.Key, mandatory, immediate, envelope); err != nil {
return nil, fmt.Errorf("Could not publish to exchange %s: %s", o.Exchange, err)
}
h := murmur3.New32()
h.Write(payload)
sum := h.Sum(nil)
size := float32(len(payload)) / 1024
if len(o.Verbose) > 0 {
log.Infof("[%d] sending %.2f kB (%x) to %s", id, size, sum, o.Key)
} else {
log.Infof("[%d] sending %.2f kB (%x)", id, size, sum)
}
return sum, nil
}
func dispatchMessage(c *amqp.Channel, message interface{}, queueName string) (err error) {
body, err := json.Marshal(message)
if err == nil {
err = c.Publish(
"", // exchange
queueName, // routing key
true, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "text/plain",
Body: []byte(body),
})
if err != nil {
fmt.Printf("Failed to dispatch message: %s\n", err)
}
} else {
fmt.Printf("Failed to marshal message %v (%s)\n", message, err)
}
return
}
func serverMain(ch *amqp.Channel) {
go msgListener(ch)
tickCounter := 1
tickLength := (60000 / bpm) / 4 // 1min divided by bpm divided by 4 microticks
for {
if bpm != 0 {
tickLength = (60000 / bpm) / 4
}
timer := time.NewTimer(time.Duration(tickLength) * time.Millisecond)
beatTick := tickCounter % 32
beat := (beatTick + 3) / 4
microTick := tickCounter % 4
if microTick == 0 {
microTick = 4
}
m := BpmMsg{bpm, microTick, tickLength, beat, tickCounter}
msg, err := json.Marshal(m)
if err != nil {
log.Fatal("Barf!", err)
}
err = ch.Publish(
"bpm", // exchange
"", // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "text/json",
Body: msg,
})
failOnError(err, "Failed to publish a message")
log.Printf("Sending msg -- %s", msg)
tickCounter++
<-timer.C // pause before next iteration - length of bpm
}
}
func handleReq(ch *amqp.Channel, d amqp.Delivery, handler rpcHandler) {
contentType, body := handler(d.ContentType, d.Body)
err := ch.Publish(
"", // exchange
d.ReplyTo, // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: contentType,
CorrelationId: d.CorrelationId,
Body: body,
})
if err != nil {
log.Error("Failed to publish a message: " + err.Error())
return
}
d.Ack(false)
}