func (this *Server) checkConfiguration() error {
var err error
this.configOnce.Do(func() {
if this.KeepAlive == 0 {
this.KeepAlive = DefaultKeepAlive
}
if this.ConnectTimeout == 0 {
this.ConnectTimeout = DefaultConnectTimeout
}
if this.AckTimeout == 0 {
this.AckTimeout = DefaultAckTimeout
}
if this.TimeoutRetries == 0 {
this.TimeoutRetries = DefaultTimeoutRetries
}
if this.Authenticator == "" {
this.Authenticator = "mockSuccess"
}
this.authMgr, err = auth.NewManager(this.Authenticator)
if err != nil {
return
}
if this.SessionsProvider == "" {
this.SessionsProvider = "mem"
}
this.sessMgr, err = sessions.NewManager(this.SessionsProvider)
if err != nil {
return
}
if this.TopicsProvider == "" {
this.TopicsProvider = "mem"
}
this.topicsMgr, err = topics.NewManager(this.TopicsProvider)
return
})
return err
}
func TestServiceSubRetain(t *testing.T) {
runClientServerTests(t, func(c *Client) {
rmsg := message.NewPublishMessage()
rmsg.SetRetain(true)
rmsg.SetQoS(0)
rmsg.SetTopic([]byte("abc"))
rmsg.SetPayload([]byte("this is a test"))
tmgr, _ := topics.NewManager("mem")
err := tmgr.Retain(rmsg)
require.NoError(t, err)
done := make(chan struct{})
sub := newSubscribeMessage(1)
c.Subscribe(sub,
func(msg, ack message.Message, err error) error {
unsub := newUnsubscribeMessage()
return c.Unsubscribe(unsub, func(msg, ack message.Message, err error) error {
close(done)
return nil
})
},
func(msg *message.PublishMessage) error {
require.Equal(t, msg.Topic(), []byte("abc"))
require.Equal(t, msg.Payload(), []byte("this is a test"))
return nil
})
select {
case <-done:
case <-time.After(time.Millisecond * 100):
require.FailNow(t, "Timed out waiting for subscribe response")
}
})
}
// Connect is for MQTT clients to open a connection to a remote server. It needs to
// know the URI, e.g., "tcp://127.0.0.1:1883", so it knows where to connect to. It also
// needs to be supplied with the MQTT CONNECT message.
func (this *Client) Connect(uri string, msg *message.ConnectMessage) (err error) {
this.checkConfiguration()
if msg == nil {
return fmt.Errorf("msg is nil")
}
u, err := url.Parse(uri)
if err != nil {
return err
}
if u.Scheme != "tcp" {
return ErrInvalidConnectionType
}
conn, err := net.Dial(u.Scheme, u.Host)
if err != nil {
return err
}
defer func() {
if err != nil {
conn.Close()
}
}()
if msg.KeepAlive() < minKeepAlive {
msg.SetKeepAlive(minKeepAlive)
}
if err = writeMessage(conn, msg); err != nil {
return err
}
conn.SetReadDeadline(time.Now().Add(time.Second * time.Duration(this.ConnectTimeout)))
resp, err := getConnackMessage(conn)
if err != nil {
return err
}
if resp.ReturnCode() != message.ConnectionAccepted {
return resp.ReturnCode()
}
this.svc = &service{
id: atomic.AddUint64(&gsvcid, 1),
client: true,
conn: conn,
keepAlive: int(msg.KeepAlive()),
connectTimeout: this.ConnectTimeout,
ackTimeout: this.AckTimeout,
timeoutRetries: this.TimeoutRetries,
}
err = this.getSession(this.svc, msg, resp)
if err != nil {
return err
}
p := topics.NewMemProvider()
topics.Register(this.svc.sess.ID(), p)
this.svc.topicsMgr, err = topics.NewManager(this.svc.sess.ID())
if err != nil {
return err
}
if err := this.svc.start(); err != nil {
this.svc.stop()
return err
}
this.svc.inStat.increment(int64(msg.Len()))
this.svc.outStat.increment(int64(resp.Len()))
return nil
}