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 newConnectMessage(cid int) *message.ConnectMessage {
msg := message.NewConnectMessage()
msg.SetWillQos(1)
msg.SetVersion(4)
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 newConnectMessage() *message.ConnectMessage {
msg := message.NewConnectMessage()
msg.SetWillQos(1)
msg.SetVersion(4)
msg.SetCleanSession(true)
msg.SetClientId([]byte(fmt.Sprintf("surgemq%d", atomic.AddUint64(&gTestClientId, 1))))
msg.SetKeepAlive(10)
msg.SetWillTopic([]byte("will"))
msg.SetWillMessage([]byte("send me home"))
msg.SetUsername([]byte("surgemq"))
msg.SetPassword([]byte("verysecret"))
return msg
}
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 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 (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
}