func newPublishMessageLarge(qos byte) *message.PublishMessage {
msg := message.NewPublishMessage()
msg.SetTopic([]byte("test"))
msg.SetPayload(make([]byte, 1024))
msg.SetQoS(qos)
return msg
}
func newPublishMessageLarge(pktid uint16, qos byte) *message.PublishMessage {
msg := message.NewPublishMessage()
msg.SetPacketId(pktid)
msg.SetTopic([]byte("abc"))
msg.SetPayload(make([]byte, 1024))
msg.SetQoS(qos)
return msg
}
func startFanPublisher(t testing.TB, cid int, wg *sync.WaitGroup) {
now := time.Now()
runClientTest(t, cid, wg, func(svc *service.Client) {
select {
case <-done:
case <-time.After(time.Second * time.Duration(subscribers)):
glog.Infof("(surgemq%d) Timed out waiting for subscribe response", cid)
return
}
cnt := messages
sent := 0
payload := make([]byte, size)
msg := message.NewPublishMessage()
msg.SetTopic(topic)
msg.SetQoS(qos)
for i := 0; i < cnt; i++ {
binary.BigEndian.PutUint32(payload, uint32(cid*cnt+i))
msg.SetPayload(payload)
err := svc.Publish(msg, nil)
if err != nil {
break
}
sent++
}
since := time.Since(now).Nanoseconds()
statMu.Lock()
totalSent += int64(sent)
totalSentTime += int64(since)
if since > sentSince {
sentSince = since
}
statMu.Unlock()
glog.Debugf("(surgemq%d) Sent %d messages in %d ns, %d ns/msg, %d msgs/sec", cid, sent, since, int(float64(since)/float64(cnt)), int(float64(sent)/(float64(since)/float64(time.Second))))
select {
case <-done2:
case <-time.Tick(time.Second * time.Duration(nap*publishers)):
glog.Errorf("Timed out waiting for messages to be received.")
}
})
}
func (this *rnode) rinsert(topic []byte, msg *message.PublishMessage) error {
// If there's no more topic levels, that means we are at the matching rnode.
if len(topic) == 0 {
l := msg.Len()
// Let's reuse the buffer if there's enough space
if l > cap(this.buf) {
this.buf = make([]byte, l)
} else {
this.buf = this.buf[0:l]
}
if _, err := msg.Encode(this.buf); err != nil {
return err
}
// Reuse the message if possible
if this.msg == nil {
this.msg = message.NewPublishMessage()
}
if _, err := this.msg.Decode(this.buf); err != nil {
return err
}
return nil
}
// Not the last level, so let's find or create the next level snode, and
// recursively call it's insert().
// ntl = next topic level
ntl, rem, err := nextTopicLevel(topic)
if err != nil {
return err
}
level := string(ntl)
// Add snode if it doesn't already exist
n, ok := this.rnodes[level]
if !ok {
n = newRNode()
this.rnodes[level] = n
}
return n.rinsert(rem, msg)
}
func (this *Session) RetainMessage(msg *message.PublishMessage) error {
this.mu.Lock()
defer this.mu.Unlock()
this.rbuf = make([]byte, msg.Len())
this.Retained = message.NewPublishMessage()
if _, err := msg.Encode(this.rbuf); err != nil {
return err
}
if _, err := this.Retained.Decode(this.rbuf); 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
}
func startMeshClient(t testing.TB, cid int, wg *sync.WaitGroup) {
runClientTest(t, cid, wg, func(svc *service.Client) {
done2 := make(chan struct{})
cnt := messages
expected := publishers * cnt
received := 0
sent := 0
now := time.Now()
since := time.Since(now).Nanoseconds()
sub := newSubscribeMessage("test", 0)
svc.Subscribe(sub,
func(msg, ack message.Message, err error) error {
subs := atomic.AddInt64(&subdone, 1)
if subs == int64(publishers) {
close(done)
}
return nil
},
func(msg *message.PublishMessage) error {
if received == 0 {
now = time.Now()
}
received++
//glog.Debugf("(surgemq%d) messages received=%d", cid, received)
since = time.Since(now).Nanoseconds()
if received == expected {
close(done2)
}
return nil
})
select {
case <-done:
case <-time.After(time.Second * time.Duration(publishers)):
glog.Infof("(surgemq%d) Timed out waiting for subscribe response", cid)
return
}
payload := make([]byte, size)
msg := message.NewPublishMessage()
msg.SetTopic(topic)
msg.SetQoS(qos)
go func() {
now := time.Now()
for i := 0; i < cnt; i++ {
binary.BigEndian.PutUint32(payload, uint32(cid*cnt+i))
msg.SetPayload(payload)
err := svc.Publish(msg, nil)
if err != nil {
break
}
sent++
}
since := time.Since(now).Nanoseconds()
statMu.Lock()
totalSent += int64(sent)
totalSentTime += int64(since)
if since > sentSince {
sentSince = since
}
statMu.Unlock()
glog.Debugf("(surgemq%d) Sent %d messages in %d ns, %d ns/msg, %d msgs/sec", cid, sent, since, int(float64(since)/float64(cnt)), int(float64(sent)/(float64(since)/float64(time.Second))))
}()
select {
case <-done2:
case <-time.Tick(time.Second * time.Duration(nap*publishers)):
glog.Errorf("Timed out waiting for messages to be received.")
}
statMu.Lock()
totalRcvd += int64(received)
totalRcvdTime += int64(since)
if since > rcvdSince {
rcvdSince = since
}
statMu.Unlock()
glog.Debugf("(surgemq%d) Received %d messages in %d ns, %d ns/msg, %d msgs/sec", cid, received, since, int(float64(since)/float64(cnt)), int(float64(received)/(float64(since)/float64(time.Second))))
})
}
