Example #1
0
//Kick kick stun
func Kick(sn string) {
	_, err := rabbit.channel.QueueDeclare(
		"stun_queue", // name
		false,        // durable
		false,        // delete when unused
		false,        // exclusive
		false,        // no-wait
		nil,
		//amqp.Table{"x-message-ttl": int32(300000)}, // arguments in ms
	)

	if err != nil {
		log.Info("[amqp] QueueDeclare error: %s", err)
		return
	}
	//stun kick
	props := MessageProperties{
		CorrelationID:   "",
		ReplyTo:         "",
		ContentEncoding: "UTF-8",
		ContentType:     "text/plain",
	}

	kickmsg := Message{MessageProperties: props, Body: []byte(sn)}

	err = rabbit.publish("", "stun_queue", kickmsg)
	if err != nil {
		log.Info("[amqp] send error: %s", err)
		return
	}
	return
}
Example #2
0
//SendMsg send msg
func SendMsg(msg Message, sendTo string) (err error) {
	rabbit := new(RabbitMQ)
	if err = rabbit.Connect(); err != nil {
		log.Info("[amqp] connect error: %s", err)
		return
	}
	defer rabbit.Close()
	_, err = rabbit.channel.QueueDeclare(
		sendTo, // name
		false,  // durable
		false,  // delete when unused
		false,  // exclusive
		false,  // no-wait
		amqp.Table{"x-message-ttl": int32(300000)}, // arguments in ms
	)
	if err != nil {
		log.Info("[amqp] QueueDeclare error: %s", err)
		return
	}
	err = rabbit.publish("", sendTo, msg)
	if err != nil {
		log.Info("[amqp] send error: %s", err)
		return
	}
	return
}
Example #3
0
//Connect create a new amqp conn
func (r *RabbitMQ) Connect() (err error) {
	r.conn, err = amqp.Dial(Conf.AMQPUrl)
	if err != nil {
		log.Info("[amqp] connect error: %s\n", err)
		return err
	}
	r.channel, err = r.conn.Channel()
	if err != nil {
		log.Info("[amqp] get channel error: %s\n", err)
		return err
	}
	r.done = make(chan error)
	return nil
}
Example #4
0
//SendText send text
func SendText(text, sendTo string) (err error) {
	rabbit := new(RabbitMQ)
	if err := rabbit.Connect(); err != nil {
		log.Info("[amqp] connect error: %s", err)
		return err
	}
	defer rabbit.Close()
	err = rabbit.publishText("", sendTo, text)
	if err != nil {
		log.Info("[amqp] send error: %s", err)
		return err
	}
	return nil
}
Example #5
0
//Reply rpc reply
func Reply(msg Message, sendTo string) (err error) {
	rabbit := new(RabbitMQ)
	if err = rabbit.Connect(); err != nil {
		log.Info("[amqp] connect error: %s", err)
		return
	}
	defer rabbit.Close()
	err = rabbit.publish("", sendTo, msg)
	if err != nil {
		log.Info("[amqp] send error: %s", err)
		return
	}
	return
}
Example #6
0
//ReciveMsg query msg
func ReciveMsg(queue string) (message Message) {
	rabbit := new(RabbitMQ)
	if err := rabbit.Connect(); err != nil {
		log.Info("[amqp] connect error: %s", err)
		return message
	}
	defer rabbit.Close()
	msg, err := rabbit.consumeQueue(queue)
	if err != nil {
		log.Info("[amqp] get error: %s", err)
		return message
	}
	return msg
}
Example #7
0
func initHTTP(addrs []string) (err error) {
	var (
		bind         string
		listener     *net.TCPListener
		addr         *net.TCPAddr
		server       *http.Server
		httpServeMux = http.NewServeMux()
	)
	globalSessions = session.NewManager()

	httpServeMux.HandleFunc("/ACS/tr069", tr069)

	for _, bind = range addrs {
		if addr, err = net.ResolveTCPAddr("tcp4", bind); err != nil {
			log.Error("net.ResolveTCPAddr(\"tcp4\", \"", bind, "\") error:", err)
			return
		}
		if listener, err = net.ListenTCP("tcp4", addr); err != nil {
			log.Error("net.ListenTCP(\"tcp4\", \"", bind, "\") error:", err)
			return
		}
		server = &http.Server{Handler: httpServeMux}
		log.Info("start http listen: \"%s\"", bind)
		go func() {
			if err = server.Serve(listener); err != nil {
				log.Error("server.Serve(\"%s\") error(%v)", bind, err)
				panic(err)
			}
		}()
	}
	return
}
Example #8
0
//Close close conn
func (r *RabbitMQ) Close() (err error) {
	err = r.conn.Close()
	if err != nil {
		log.Info("[amqp] close error: %s", err)
		return err
	}
	return nil
}
Example #9
0
//PublishText publish text msg
func (r *RabbitMQ) publishText(exchange, key, text string) (err error) {
	err = r.channel.Publish(exchange, key, false, false,
		amqp.Publishing{
			ContentType:   "text/plain",
			CorrelationId: "",
			ReplyTo:       "",
			Body:          []byte(text),
		},
	)
	if err != nil {
		log.Info("[amqp] publish message error: %s", err)
		return err
	}
	return nil
}
Example #10
0
//Publish publish amqp msg
func (r *RabbitMQ) publish(exchange, key string, msg Message) (err error) {
	err = r.channel.Publish(exchange, key, false, false,
		amqp.Publishing{
			Headers:         msg.Headers,
			ContentType:     msg.ContentType,
			ContentEncoding: msg.ContentEncoding,
			CorrelationId:   msg.CorrelationID,
			//Expiration:      msg.Expiration,
			Body: msg.Body,
		},
	)
	if err != nil {
		log.Info("[amqp] publish message error: %s", err)
		return err
	}
	return nil
}
Example #11
0
//ConsumeQueue bindding queue
func (r *RabbitMQ) consumeQueue(queue string) (message Message, err error) {
	deliver, ok, err := r.channel.Get(queue, true)
	if err != nil {
		log.Info("[amqp] consume queue error: %s", err)
		return message, err
	}
	if ok {
		return Message{
			MessageProperties: MessageProperties{
				Headers:         deliver.Headers,
				CorrelationID:   deliver.CorrelationId,
				ReplyTo:         deliver.ReplyTo,
				ContentEncoding: deliver.ContentEncoding,
				ContentType:     deliver.ContentType,
			},
			Body: deliver.Body,
		}, nil
	}
	return message, nil
}
Example #12
0
func (q *MsgQueue) fetchMsg() {
	log.Info("fetch")
	conn, err := amqp.Dial(Conf.AMQPUrl)
	if err != nil {
		log.Error("Failed to connect to RabbitMQ", err)
		return
	}
	defer conn.Close()

	ch, err := conn.Channel()
	if err != nil {
		log.Error("Failed to open a channel", err)
		return
	}
	defer ch.Close()

	qu, err := ch.QueueDeclare(
		Conf.ACSQueue, // name
		false,         // durable
		false,         // delete when unused
		false,         // exclusive
		false,         // no-wait
		nil,           // arguments
	)
	if err != nil {
		log.Error("Failed to declare a queue ", err)
		return
	}

	err = ch.Qos(
		1,     // prefetch count
		0,     // prefetch size
		false, // global
	)
	if err != nil {
		log.Error("Failed to set QoS", err)
		return
	}

	msgs, err := ch.Consume(
		qu.Name, // queue
		"",      // consumer
		false,   // auto-ack
		false,   // exclusive
		false,   // no-local
		false,   // no-wait
		nil,     // args
	)
	if err != nil {
		log.Error("Failed to register a consumer", err)
		return
	}
	forever := make(chan bool)
	go func(flag chan bool) {
		log.Error("closing", <-conn.NotifyClose(make(chan *amqp.Error)))
		flag <- true
	}(forever)
	go func() {
		for deliver := range msgs {
			if Debug {
				log.Debug("Received a message: %s", deliver.Body)
				log.Debug("Received a message replyTo: %s", deliver.ReplyTo)
			}
			deliver.Ack(false)
			if deliver.Headers["DeviceID"] != nil {
				sn := deliver.Headers["DeviceID"].(string)
				msg := Message{
					MessageProperties: MessageProperties{
						Headers:         deliver.Headers,
						CorrelationID:   deliver.CorrelationId,
						ReplyTo:         deliver.ReplyTo,
						ContentEncoding: deliver.ContentEncoding,
						ContentType:     deliver.ContentType,
					},
					Body: deliver.Body,
				}
				//q.Push(sn, msg)
				var channel *Channel
				if channel = DefaultBucket.Channel(sn); channel != nil { //根据sub key找到user对应的channel
					err := channel.Push(msg.MessageProperties, msg.Body)
					if err != nil {
						log.Warn("push msg into %s ch err:%s", sn, err)
					}
				} else {
					//new channel
					channel = NewChannel(Conf.RingSize)
					err := channel.Push(msg.MessageProperties, msg.Body)
					if err != nil {
						log.Warn("push msg into %s new ch err:%s", sn, err)
					}
					DefaultBucket.Put(sn, channel)
				}
				//send to stun
				//dot_count := bytes.Count(d.Body, []byte("."))
				//t := time.Duration(dot_count)
				//time.Sleep(t * time.Second)
				//models.Kick(sn)
				SendText(sn, "stun_queue")
			}
		}
	}()

	<-forever
}