func main() {
c := &service.Client{}
msgConn := message.NewConnectMessage()
msgConn.SetVersion(3)
msgConn.SetCleanSession(true)
msgConn.SetClientId([]byte("01234567"))
msgConn.SetKeepAlive(300)
if err := c.Connect("tcp://127.0.0.1:1883", msgConn); err != nil {
log.Fatal(err)
}
log.Println("connected")
msgSub := message.NewSubscribeMessage()
msgSub.AddTopic([]byte("#"), 0)
onPub := func(msg *message.PublishMessage) error {
return pub(c, msg)
}
onComp := func(msg, ack message.Message, err error) error {
log.Printf("on complete subscribe: msg=%#v ack=%#v err=%v\n", msg, ack, err)
return err
}
if err := c.Subscribe(msgSub, onComp, onPub); err != nil {
log.Fatal(err)
}
log.Println("subscribed")
//c.Disconnect()
//log.Println("disconnected")
done := make(chan bool)
<-done
}
func client(cmd *cobra.Command, args []string) {
// Instantiates a new Client
c = &service.Client{}
// Creates a new MQTT CONNECT message and sets the proper parameters
msg := message.NewConnectMessage()
msg.SetVersion(4)
msg.SetCleanSession(true)
msg.SetClientId([]byte(fmt.Sprintf("pingmqclient%d%d", os.Getpid(), time.Now().Unix())))
msg.SetKeepAlive(300)
// Connects to the remote server at 127.0.0.1 port 1883
if err := c.Connect(clientURI, msg); err != nil {
log.Fatal(err)
}
// Creates a new SUBSCRIBE message to subscribe to topic "abc"
submsg := message.NewSubscribeMessage()
for _, t := range clientTopics {
submsg.AddTopic([]byte(t), 0)
}
c.Subscribe(submsg, nil, onPublish)
<-done
}
func main() {
flag.Parse()
done := make(chan bool)
c := &service.Client{}
msg := message.NewConnectMessage()
msg.SetVersion(3)
msg.SetCleanSession(true)
msg.SetClientId(clientID)
msg.SetKeepAlive(300)
if err := c.Connect("tcp://127.0.0.1:1883", msg); err != nil {
panic(err)
}
pub := message.NewPublishMessage()
pub.SetTopic([]byte(*topic))
pub.SetQoS(0)
pub.SetPayload([]byte(*payload))
if err := c.Publish(pub, nil); err != nil {
panic(err)
}
fmt.Println("waiting", 1)
<-done
}
func getConnectMessage(conn io.Closer) (*message.ConnectMessage, error) {
buf, err := getMessageBuffer(conn)
if err != nil {
//glog.Debugf("Receive error: %v", err)
return nil, err
}
msg := message.NewConnectMessage()
_, err = msg.Decode(buf)
//glog.Debugf("Received: %s", msg)
return msg, err
}
func getConnectMessage(conn io.Closer) (*message.ConnectMessage, error) {
buf, err := getMessageBuffer(conn)
if err != nil {
//Log.Debugc(func() string{ return fmt.Sprintf("Receive error: %v", err)})
return nil, err
}
msg := message.NewConnectMessage()
_, err = msg.Decode(buf)
//Log.Debugc(func() string{ return fmt.Sprintf("Received: %s", msg)})
return msg, err
}
func newConnectMessage() *message.ConnectMessage {
msg := message.NewConnectMessage()
msg.SetWillQos(1)
msg.SetVersion(4)
msg.SetCleanSession(true)
msg.SetClientId([]byte("surgemq"))
msg.SetKeepAlive(10)
msg.SetWillTopic([]byte("will"))
msg.SetWillMessage([]byte("send me home"))
msg.SetUsername([]byte("surgemq"))
msg.SetPassword([]byte("verysecret"))
return msg
}
func newConnectMessage(cid int) *message.ConnectMessage {
msg := message.NewConnectMessage()
msg.SetWillQos(1)
msg.SetVersion(byte(version))
msg.SetCleanSession(true)
msg.SetClientId([]byte(fmt.Sprintf("surgemq%d", cid)))
msg.SetKeepAlive(10)
msg.SetWillTopic([]byte("will"))
msg.SetWillMessage([]byte("send me home"))
msg.SetUsername([]byte(user))
msg.SetPassword([]byte(pass))
return msg
}
func main() {
flag.Parse()
c := service.Client{}
msg := message.NewConnectMessage()
msg.SetWillQos(1)
msg.SetVersion(4)
msg.SetCleanSession(true)
msg.SetClientId([]byte("surgemq"))
msg.SetKeepAlive(10)
msg.SetWillTopic([]byte("will"))
msg.SetWillMessage([]byte("send me home"))
msg.SetUsername([]byte("surgemq"))
msg.SetPassword([]byte("verysecret"))
// Connects to the remote server at 127.0.0.1 port 1883
str := *addr + ":" + *port
c.Connect("tcp://"+str, msg)
// Creates a new SUBSCRIBE message to subscribe to topic "abc"
submsg := message.NewSubscribeMessage()
submsg.AddTopic([]byte("abc"), 0)
// Subscribes to the topic by sending the message. The first nil in the function
// call is a OnCompleteFunc that should handle the SUBACK message from the server.
// Nil means we are ignoring the SUBACK messages. The second nil should be a
// OnPublishFunc that handles any messages send to the client because of this
// subscription. Nil means we are ignoring any PUBLISH messages for this topic.
c.Subscribe(submsg, onCompleteFunc, onPublishFunc)
// Creates a new PUBLISH message with the appropriate contents for publishing
pubmsg := message.NewPublishMessage()
pubmsg.SetTopic([]byte("abc"))
pubmsg.SetPayload(make([]byte, 1024))
pubmsg.SetQoS(0)
// Publishes to the server by sending the message
c.Publish(pubmsg, onCompleteFunc)
// Disconnects from the server
jklog.L().Infoln("disconnected.")
for {
time.Sleep(5000 * time.Millisecond)
// c.Publish(pubmsg, onCompleteFunc)
}
c.Disconnect()
}
func (this *Session) Update(msg *message.ConnectMessage) error {
this.mu.Lock()
defer this.mu.Unlock()
this.cbuf = make([]byte, msg.Len())
this.Cmsg = message.NewConnectMessage()
if _, err := msg.Encode(this.cbuf); err != nil {
return err
}
if _, err := this.Cmsg.Decode(this.cbuf); err != nil {
return err
}
return nil
}
func (this *Session) Init(msg *message.ConnectMessage) error {
this.mu.Lock()
defer this.mu.Unlock()
if this.initted {
return fmt.Errorf("Session already initialized")
}
this.cbuf = make([]byte, msg.Len())
this.Cmsg = message.NewConnectMessage()
if _, err := msg.Encode(this.cbuf); err != nil {
return err
}
if _, err := this.Cmsg.Decode(this.cbuf); err != nil {
return err
}
if this.Cmsg.WillFlag() {
this.Will = message.NewPublishMessage()
this.Will.SetQoS(this.Cmsg.WillQos())
this.Will.SetTopic(this.Cmsg.WillTopic())
this.Will.SetPayload(this.Cmsg.WillMessage())
this.Will.SetRetain(this.Cmsg.WillRetain())
}
this.topics = make(map[string]byte, 1)
this.id = string(msg.ClientId())
this.Pub1ack = newAckqueue(defaultQueueSize)
this.Pub2in = newAckqueue(defaultQueueSize)
this.Pub2out = newAckqueue(defaultQueueSize)
this.Suback = newAckqueue(defaultQueueSize)
this.Unsuback = newAckqueue(defaultQueueSize)
this.Pingack = newAckqueue(defaultQueueSize)
this.initted = true
return nil
}
func ExampleClient() {
// Instantiates a new Client
c := &Client{}
// Creates a new MQTT CONNECT message and sets the proper parameters
msg := message.NewConnectMessage()
msg.SetWillQos(1)
msg.SetVersion(4)
msg.SetCleanSession(true)
msg.SetClientId([]byte("surgemq"))
msg.SetKeepAlive(10)
msg.SetWillTopic([]byte("will"))
msg.SetWillMessage([]byte("send me home"))
msg.SetUsername([]byte("surgemq"))
msg.SetPassword([]byte("verysecret"))
// Connects to the remote server at 127.0.0.1 port 1883
c.Connect("tcp://127.0.0.1:1883", msg)
// Creates a new SUBSCRIBE message to subscribe to topic "abc"
submsg := message.NewSubscribeMessage()
submsg.AddTopic([]byte("abc"), 0)
// Subscribes to the topic by sending the message. The first nil in the function
// call is a OnCompleteFunc that should handle the SUBACK message from the server.
// Nil means we are ignoring the SUBACK messages. The second nil should be a
// OnPublishFunc that handles any messages send to the client because of this
// subscription. Nil means we are ignoring any PUBLISH messages for this topic.
c.Subscribe(submsg, nil, nil)
// Creates a new PUBLISH message with the appropriate contents for publishing
pubmsg := message.NewPublishMessage()
pubmsg.SetTopic([]byte("abc"))
pubmsg.SetPayload(make([]byte, 1024))
pubmsg.SetQoS(0)
// Publishes to the server by sending the message
c.Publish(pubmsg, nil)
// Disconnects from the server
c.Disconnect()
}
func NewSurgeMQ(numberOfMessages int, testLatency bool) *SurgeMQ {
uri := "tcp://127.0.0.1:1883"
client := &service.Client{}
msg := message.NewConnectMessage()
msg.SetWillQos(1)
msg.SetVersion(4)
msg.SetCleanSession(true)
msg.SetClientId([]byte("surgemq"))
msg.SetKeepAlive(10)
msg.SetWillTopic([]byte("will"))
msg.SetWillMessage([]byte("send me home"))
msg.SetUsername([]byte("surgemq"))
msg.SetPassword([]byte("verysecret"))
err := client.Connect(uri, msg)
if err != nil {
panic(err)
}
var handler benchmark.MessageHandler
if testLatency {
handler = &benchmark.LatencyMessageHandler{
NumberOfMessages: numberOfMessages,
Latencies: []float32{},
}
} else {
handler = &benchmark.ThroughputMessageHandler{NumberOfMessages: numberOfMessages}
}
return &SurgeMQ{
handler: handler,
subject: "test",
client: client,
testLatency: testLatency,
}
}