paho.mqtt.golang: github.com/eclipse/paho.mqtt.golang Index | Files | Directories

package mqtt

import "github.com/eclipse/paho.mqtt.golang"

Package mqtt provides an MQTT v3.1.1 client library.

Index

Package Files

client.go components.go filestore.go memstore.go message.go messageids.go net.go oops.go options.go options_reader.go ping.go router.go store.go token.go topic.go trace.go

Constants

const (
    NET component = "[net]     "
    PNG component = "[pinger]  "
    CLI component = "[client]  "
    DEC component = "[decode]  "
    MES component = "[message] "
    STR component = "[store]   "
    MID component = "[msgids]  "
    TST component = "[test]    "
    STA component = "[state]   "
    ERR component = "[error]   "
)

Component names for debug output

Variables

var ErrInvalidQos = errors.New("Invalid QoS")

ErrInvalidQos is the error returned when an packet is to be sent with an invalid Qos value

var ErrInvalidTopicEmptyString = errors.New("Invalid Topic; empty string")

ErrInvalidTopicEmptyString is the error returned when a topic string is passed in that is 0 length

var ErrInvalidTopicMultilevel = errors.New("Invalid Topic; multi-level wildcard must be last level")

ErrInvalidTopicMultilevel is the error returned when a topic string is passed in that has the multi level wildcard in any position but the last

var ErrNotConnected = errors.New("Not Connected")

ErrNotConnected is the error returned from function calls that are made when the client is not connected to a broker

func DefaultConnectionLostHandler Uses

func DefaultConnectionLostHandler(client Client, reason error)

DefaultConnectionLostHandler is a definition of a function that simply reports to the DEBUG log the reason for the client losing a connection.

type Client Uses

type Client interface {
    // IsConnected returns a bool signifying whether
    // the client is connected or not.
    IsConnected() bool
    // IsConnectionOpen return a bool signifying wether the client has an active
    // connection to mqtt broker, i.e not in disconnected or reconnect mode
    IsConnectionOpen() bool
    // Connect will create a connection to the message broker, by default
    // it will attempt to connect at v3.1.1 and auto retry at v3.1 if that
    // fails
    Connect() Token
    // Disconnect will end the connection with the server, but not before waiting
    // the specified number of milliseconds to wait for existing work to be
    // completed.
    Disconnect(quiesce uint)
    // Publish will publish a message with the specified QoS and content
    // to the specified topic.
    // Returns a token to track delivery of the message to the broker
    Publish(topic string, qos byte, retained bool, payload interface{}) Token
    // Subscribe starts a new subscription. Provide a MessageHandler to be executed when
    // a message is published on the topic provided, or nil for the default handler
    Subscribe(topic string, qos byte, callback MessageHandler) Token
    // SubscribeMultiple starts a new subscription for multiple topics. Provide a MessageHandler to
    // be executed when a message is published on one of the topics provided, or nil for the
    // default handler
    SubscribeMultiple(filters map[string]byte, callback MessageHandler) Token
    // Unsubscribe will end the subscription from each of the topics provided.
    // Messages published to those topics from other clients will no longer be
    // received.
    Unsubscribe(topics ...string) Token
    // AddRoute allows you to add a handler for messages on a specific topic
    // without making a subscription. For example having a different handler
    // for parts of a wildcard subscription
    AddRoute(topic string, callback MessageHandler)
    // OptionsReader returns a ClientOptionsReader which is a copy of the clientoptions
    // in use by the client.
    OptionsReader() ClientOptionsReader
}

Client is the interface definition for a Client as used by this library, the interface is primarily to allow mocking tests.

It is an MQTT v3.1.1 client for communicating with an MQTT server using non-blocking methods that allow work to be done in the background. An application may connect to an MQTT server using:

A plain TCP socket
A secure SSL/TLS socket
A websocket

To enable ensured message delivery at Quality of Service (QoS) levels described in the MQTT spec, a message persistence mechanism must be used. This is done by providing a type which implements the Store interface. For convenience, FileStore and MemoryStore are provided implementations that should be sufficient for most use cases. More information can be found in their respective documentation. Numerous connection options may be specified by configuring a and then supplying a ClientOptions type.

func NewClient Uses

func NewClient(o *ClientOptions) Client

NewClient will create an MQTT v3.1.1 client with all of the options specified in the provided ClientOptions. The client must have the Connect method called on it before it may be used. This is to make sure resources (such as a net connection) are created before the application is actually ready.

type ClientOptions Uses

type ClientOptions struct {
    Servers             []*url.URL
    ClientID            string
    Username            string
    Password            string
    CredentialsProvider CredentialsProvider
    CleanSession        bool
    Order               bool
    WillEnabled         bool
    WillTopic           string
    WillPayload         []byte
    WillQos             byte
    WillRetained        bool
    ProtocolVersion     uint

    TLSConfig             *tls.Config
    KeepAlive             int64
    PingTimeout           time.Duration
    ConnectTimeout        time.Duration
    MaxReconnectInterval  time.Duration
    AutoReconnect         bool
    Store                 Store
    DefaultPublishHandler MessageHandler
    OnConnect             OnConnectHandler
    OnConnectionLost      ConnectionLostHandler
    WriteTimeout          time.Duration
    MessageChannelDepth   uint
    ResumeSubs            bool
    HTTPHeaders           http.Header
    // contains filtered or unexported fields
}

ClientOptions contains configurable options for an Client.

func NewClientOptions Uses

func NewClientOptions() *ClientOptions

NewClientOptions will create a new ClientClientOptions type with some default values.

Port: 1883
CleanSession: True
Order: True
KeepAlive: 30 (seconds)
ConnectTimeout: 30 (seconds)
MaxReconnectInterval 10 (minutes)
AutoReconnect: True

func (*ClientOptions) AddBroker Uses

func (o *ClientOptions) AddBroker(server string) *ClientOptions

AddBroker adds a broker URI to the list of brokers to be used. The format should be scheme://host:port Where "scheme" is one of "tcp", "ssl", or "ws", "host" is the ip-address (or hostname) and "port" is the port on which the broker is accepting connections.

Default values for hostname is "127.0.0.1", for schema is "tcp://".

An example broker URI would look like: tcp://foobar.com:1883

func (*ClientOptions) SetAutoReconnect Uses

func (o *ClientOptions) SetAutoReconnect(a bool) *ClientOptions

SetAutoReconnect sets whether the automatic reconnection logic should be used when the connection is lost, even if disabled the ConnectionLostHandler is still called

func (*ClientOptions) SetBinaryWill Uses

func (o *ClientOptions) SetBinaryWill(topic string, payload []byte, qos byte, retained bool) *ClientOptions

SetBinaryWill accepts a []byte will message to be set. When the client connects, it will give this will message to the broker, which will then publish the provided payload (the will) to any clients that are subscribed to the provided topic.

func (*ClientOptions) SetCleanSession Uses

func (o *ClientOptions) SetCleanSession(clean bool) *ClientOptions

SetCleanSession will set the "clean session" flag in the connect message when this client connects to an MQTT broker. By setting this flag, you are indicating that no messages saved by the broker for this client should be delivered. Any messages that were going to be sent by this client before diconnecting previously but didn't will not be sent upon connecting to the broker.

func (*ClientOptions) SetClientID Uses

func (o *ClientOptions) SetClientID(id string) *ClientOptions

SetClientID will set the client id to be used by this client when connecting to the MQTT broker. According to the MQTT v3.1 specification, a client id mus be no longer than 23 characters.

func (*ClientOptions) SetConnectTimeout Uses

func (o *ClientOptions) SetConnectTimeout(t time.Duration) *ClientOptions

SetConnectTimeout limits how long the client will wait when trying to open a connection to an MQTT server before timeing out and erroring the attempt. A duration of 0 never times out. Default 30 seconds. Currently only operational on TCP/TLS connections.

func (*ClientOptions) SetConnectionLostHandler Uses

func (o *ClientOptions) SetConnectionLostHandler(onLost ConnectionLostHandler) *ClientOptions

SetConnectionLostHandler will set the OnConnectionLost callback to be executed in the case where the client unexpectedly loses connection with the MQTT broker.

func (*ClientOptions) SetCredentialsProvider Uses

func (o *ClientOptions) SetCredentialsProvider(p CredentialsProvider) *ClientOptions

SetCredentialsProvider will set a method to be called by this client when connecting to the MQTT broker that provide the current username and password. Note: without the use of SSL/TLS, this information will be sent in plaintext accross the wire.

func (*ClientOptions) SetDefaultPublishHandler Uses

func (o *ClientOptions) SetDefaultPublishHandler(defaultHandler MessageHandler) *ClientOptions

SetDefaultPublishHandler sets the MessageHandler that will be called when a message is received that does not match any known subscriptions.

func (*ClientOptions) SetHTTPHeaders Uses

func (o *ClientOptions) SetHTTPHeaders(h http.Header) *ClientOptions

SetHTTPHeaders sets the additional HTTP headers that will be sent in the WebSocket opening handshake.

func (*ClientOptions) SetKeepAlive Uses

func (o *ClientOptions) SetKeepAlive(k time.Duration) *ClientOptions

SetKeepAlive will set the amount of time (in seconds) that the client should wait before sending a PING request to the broker. This will allow the client to know that a connection has not been lost with the server.

func (*ClientOptions) SetMaxReconnectInterval Uses

func (o *ClientOptions) SetMaxReconnectInterval(t time.Duration) *ClientOptions

SetMaxReconnectInterval sets the maximum time that will be waited between reconnection attempts when connection is lost

func (*ClientOptions) SetMessageChannelDepth Uses

func (o *ClientOptions) SetMessageChannelDepth(s uint) *ClientOptions

SetMessageChannelDepth sets the size of the internal queue that holds messages while the client is temporairily offline, allowing the application to publish when the client is reconnecting. This setting is only valid if AutoReconnect is set to true, it is otherwise ignored.

func (*ClientOptions) SetOnConnectHandler Uses

func (o *ClientOptions) SetOnConnectHandler(onConn OnConnectHandler) *ClientOptions

SetOnConnectHandler sets the function to be called when the client is connected. Both at initial connection time and upon automatic reconnect.

func (*ClientOptions) SetOrderMatters Uses

func (o *ClientOptions) SetOrderMatters(order bool) *ClientOptions

SetOrderMatters will set the message routing to guarantee order within each QoS level. By default, this value is true. If set to false, this flag indicates that messages can be delivered asynchronously from the client to the application and possibly arrive out of order.

func (*ClientOptions) SetPassword Uses

func (o *ClientOptions) SetPassword(p string) *ClientOptions

SetPassword will set the password to be used by this client when connecting to the MQTT broker. Note: without the use of SSL/TLS, this information will be sent in plaintext accross the wire.

func (*ClientOptions) SetPingTimeout Uses

func (o *ClientOptions) SetPingTimeout(k time.Duration) *ClientOptions

SetPingTimeout will set the amount of time (in seconds) that the client will wait after sending a PING request to the broker, before deciding that the connection has been lost. Default is 10 seconds.

func (*ClientOptions) SetProtocolVersion Uses

func (o *ClientOptions) SetProtocolVersion(pv uint) *ClientOptions

SetProtocolVersion sets the MQTT version to be used to connect to the broker. Legitimate values are currently 3 - MQTT 3.1 or 4 - MQTT 3.1.1

func (*ClientOptions) SetResumeSubs Uses

func (o *ClientOptions) SetResumeSubs(resume bool) *ClientOptions

SetResumeSubs will enable resuming of stored (un)subscribe messages when connecting but not reconnecting if CleanSession is false. Otherwise these messages are discarded.

func (*ClientOptions) SetStore Uses

func (o *ClientOptions) SetStore(s Store) *ClientOptions

SetStore will set the implementation of the Store interface used to provide message persistence in cases where QoS levels QoS_ONE or QoS_TWO are used. If no store is provided, then the client will use MemoryStore by default.

func (*ClientOptions) SetTLSConfig Uses

func (o *ClientOptions) SetTLSConfig(t *tls.Config) *ClientOptions

SetTLSConfig will set an SSL/TLS configuration to be used when connecting to an MQTT broker. Please read the official Go documentation for more information.

func (*ClientOptions) SetUsername Uses

func (o *ClientOptions) SetUsername(u string) *ClientOptions

SetUsername will set the username to be used by this client when connecting to the MQTT broker. Note: without the use of SSL/TLS, this information will be sent in plaintext accross the wire.

func (*ClientOptions) SetWill Uses

func (o *ClientOptions) SetWill(topic string, payload string, qos byte, retained bool) *ClientOptions

SetWill accepts a string will message to be set. When the client connects, it will give this will message to the broker, which will then publish the provided payload (the will) to any clients that are subscribed to the provided topic.

func (*ClientOptions) SetWriteTimeout Uses

func (o *ClientOptions) SetWriteTimeout(t time.Duration) *ClientOptions

SetWriteTimeout puts a limit on how long a mqtt publish should block until it unblocks with a timeout error. A duration of 0 never times out. Default 30 seconds

func (*ClientOptions) UnsetWill Uses

func (o *ClientOptions) UnsetWill() *ClientOptions

UnsetWill will cause any set will message to be disregarded.

type ClientOptionsReader Uses

type ClientOptionsReader struct {
    // contains filtered or unexported fields
}

ClientOptionsReader provides an interface for reading ClientOptions after the client has been initialized.

func (*ClientOptionsReader) AutoReconnect Uses

func (r *ClientOptionsReader) AutoReconnect() bool

func (*ClientOptionsReader) CleanSession Uses

func (r *ClientOptionsReader) CleanSession() bool

CleanSession returns whether Cleansession is set

func (*ClientOptionsReader) ClientID Uses

func (r *ClientOptionsReader) ClientID() string

ClientID returns the set client id

func (*ClientOptionsReader) ConnectTimeout Uses

func (r *ClientOptionsReader) ConnectTimeout() time.Duration

func (*ClientOptionsReader) HTTPHeaders Uses

func (r *ClientOptionsReader) HTTPHeaders() http.Header

func (*ClientOptionsReader) KeepAlive Uses

func (r *ClientOptionsReader) KeepAlive() time.Duration

func (*ClientOptionsReader) MaxReconnectInterval Uses

func (r *ClientOptionsReader) MaxReconnectInterval() time.Duration

func (*ClientOptionsReader) MessageChannelDepth Uses

func (r *ClientOptionsReader) MessageChannelDepth() uint

func (*ClientOptionsReader) Order Uses

func (r *ClientOptionsReader) Order() bool

func (*ClientOptionsReader) Password Uses

func (r *ClientOptionsReader) Password() string

Password returns the set password

func (*ClientOptionsReader) PingTimeout Uses

func (r *ClientOptionsReader) PingTimeout() time.Duration

func (*ClientOptionsReader) ProtocolVersion Uses

func (r *ClientOptionsReader) ProtocolVersion() uint

func (*ClientOptionsReader) ResumeSubs Uses

func (r *ClientOptionsReader) ResumeSubs() bool

ResumeSubs returns true if resuming stored (un)sub is enabled

func (*ClientOptionsReader) Servers Uses

func (r *ClientOptionsReader) Servers() []*url.URL

Servers returns a slice of the servers defined in the clientoptions

func (*ClientOptionsReader) TLSConfig Uses

func (r *ClientOptionsReader) TLSConfig() *tls.Config

func (*ClientOptionsReader) Username Uses

func (r *ClientOptionsReader) Username() string

Username returns the set username

func (*ClientOptionsReader) WillEnabled Uses

func (r *ClientOptionsReader) WillEnabled() bool

func (*ClientOptionsReader) WillPayload Uses

func (r *ClientOptionsReader) WillPayload() []byte

func (*ClientOptionsReader) WillQos Uses

func (r *ClientOptionsReader) WillQos() byte

func (*ClientOptionsReader) WillRetained Uses

func (r *ClientOptionsReader) WillRetained() bool

func (*ClientOptionsReader) WillTopic Uses

func (r *ClientOptionsReader) WillTopic() string

func (*ClientOptionsReader) WriteTimeout Uses

func (r *ClientOptionsReader) WriteTimeout() time.Duration

type ConnectToken Uses

type ConnectToken struct {
    // contains filtered or unexported fields
}

ConnectToken is an extension of Token containing the extra fields required to provide information about calls to Connect()

func (*ConnectToken) Error Uses

func (b *ConnectToken) Error() error

func (*ConnectToken) ReturnCode Uses

func (c *ConnectToken) ReturnCode() byte

ReturnCode returns the acknowlegement code in the connack sent in response to a Connect()

func (*ConnectToken) SessionPresent Uses

func (c *ConnectToken) SessionPresent() bool

SessionPresent returns a bool representing the value of the session present field in the connack sent in response to a Connect()

func (*ConnectToken) Wait Uses

func (b *ConnectToken) Wait() bool

Wait will wait indefinitely for the Token to complete, ie the Publish to be sent and confirmed receipt from the broker

func (*ConnectToken) WaitTimeout Uses

func (b *ConnectToken) WaitTimeout(d time.Duration) bool

WaitTimeout takes a time.Duration to wait for the flow associated with the Token to complete, returns true if it returned before the timeout or returns false if the timeout occurred. In the case of a timeout the Token does not have an error set in case the caller wishes to wait again

type ConnectionLostHandler Uses

type ConnectionLostHandler func(Client, error)

ConnectionLostHandler is a callback type which can be set to be executed upon an unintended disconnection from the MQTT broker. Disconnects caused by calling Disconnect or ForceDisconnect will not cause an OnConnectionLost callback to execute.

type CredentialsProvider Uses

type CredentialsProvider func() (username string, password string)

CredentialsProvider allows the username and password to be updated before reconnecting. It should return the current username and password.

type DisconnectToken Uses

type DisconnectToken struct {
    // contains filtered or unexported fields
}

DisconnectToken is an extension of Token containing the extra fields required to provide information about calls to Disconnect()

func (*DisconnectToken) Error Uses

func (b *DisconnectToken) Error() error

func (*DisconnectToken) Wait Uses

func (b *DisconnectToken) Wait() bool

Wait will wait indefinitely for the Token to complete, ie the Publish to be sent and confirmed receipt from the broker

func (*DisconnectToken) WaitTimeout Uses

func (b *DisconnectToken) WaitTimeout(d time.Duration) bool

WaitTimeout takes a time.Duration to wait for the flow associated with the Token to complete, returns true if it returned before the timeout or returns false if the timeout occurred. In the case of a timeout the Token does not have an error set in case the caller wishes to wait again

type DummyToken Uses

type DummyToken struct {
    // contains filtered or unexported fields
}

func (*DummyToken) Error Uses

func (d *DummyToken) Error() error

func (*DummyToken) Wait Uses

func (d *DummyToken) Wait() bool

func (*DummyToken) WaitTimeout Uses

func (d *DummyToken) WaitTimeout(t time.Duration) bool

type FileStore Uses

type FileStore struct {
    sync.RWMutex
    // contains filtered or unexported fields
}

FileStore implements the store interface using the filesystem to provide true persistence, even across client failure. This is designed to use a single directory per running client. If you are running multiple clients on the same filesystem, you will need to be careful to specify unique store directories for each.

func NewFileStore Uses

func NewFileStore(directory string) *FileStore

NewFileStore will create a new FileStore which stores its messages in the directory provided.

func (*FileStore) All Uses

func (store *FileStore) All() []string

All will provide a list of all of the keys associated with messages currenly residing in the FileStore.

func (*FileStore) Close Uses

func (store *FileStore) Close()

Close will disallow the FileStore from being used.

func (*FileStore) Del Uses

func (store *FileStore) Del(key string)

Del will remove the persisted message associated with the provided key from the FileStore.

func (*FileStore) Get Uses

func (store *FileStore) Get(key string) packets.ControlPacket

Get will retrieve a message from the store, the one associated with the provided key value.

func (*FileStore) Open Uses

func (store *FileStore) Open()

Open will allow the FileStore to be used.

func (*FileStore) Put Uses

func (store *FileStore) Put(key string, m packets.ControlPacket)

Put will put a message into the store, associated with the provided key value.

func (*FileStore) Reset Uses

func (store *FileStore) Reset()

Reset will remove all persisted messages from the FileStore.

type Logger Uses

type Logger interface {
    Println(v ...interface{})
    Printf(format string, v ...interface{})
}

Logger interface allows implementations to provide to this package any object that implements the methods defined in it.

var (
    ERROR    Logger = NOOPLogger{}
    CRITICAL Logger = NOOPLogger{}
    WARN     Logger = NOOPLogger{}
    DEBUG    Logger = NOOPLogger{}
)

Internal levels of library output that are initialised to not print anything but can be overridden by programmer

type MId Uses

type MId uint16

MId is 16 bit message id as specified by the MQTT spec. In general, these values should not be depended upon by the client application.

type MemoryStore Uses

type MemoryStore struct {
    sync.RWMutex
    // contains filtered or unexported fields
}

MemoryStore implements the store interface to provide a "persistence" mechanism wholly stored in memory. This is only useful for as long as the client instance exists.

func NewMemoryStore Uses

func NewMemoryStore() *MemoryStore

NewMemoryStore returns a pointer to a new instance of MemoryStore, the instance is not initialized and ready to use until Open() has been called on it.

func (*MemoryStore) All Uses

func (store *MemoryStore) All() []string

All returns a slice of strings containing all the keys currently in the MemoryStore.

func (*MemoryStore) Close Uses

func (store *MemoryStore) Close()

Close will disallow modifications to the state of the store.

func (*MemoryStore) Del Uses

func (store *MemoryStore) Del(key string)

Del takes a key, searches the MemoryStore and if the key is found deletes the Message pointer associated with it.

func (*MemoryStore) Get Uses

func (store *MemoryStore) Get(key string) packets.ControlPacket

Get takes a key and looks in the store for a matching Message returning either the Message pointer or nil.

func (*MemoryStore) Open Uses

func (store *MemoryStore) Open()

Open initializes a MemoryStore instance.

func (*MemoryStore) Put Uses

func (store *MemoryStore) Put(key string, message packets.ControlPacket)

Put takes a key and a pointer to a Message and stores the message.

func (*MemoryStore) Reset Uses

func (store *MemoryStore) Reset()

Reset eliminates all persisted message data in the store.

type Message Uses

type Message interface {
    Duplicate() bool
    Qos() byte
    Retained() bool
    Topic() string
    MessageID() uint16
    Payload() []byte
    Ack()
}

Message defines the externals that a message implementation must support these are received messages that are passed to the callbacks, not internal messages

type MessageHandler Uses

type MessageHandler func(Client, Message)

MessageHandler is a callback type which can be set to be executed upon the arrival of messages published to topics to which the client is subscribed.

type NOOPLogger Uses

type NOOPLogger struct{}

NOOPLogger implements the logger that does not perform any operation by default. This allows us to efficiently discard the unwanted messages.

func (NOOPLogger) Printf Uses

func (NOOPLogger) Printf(format string, v ...interface{})

func (NOOPLogger) Println Uses

func (NOOPLogger) Println(v ...interface{})

type OnConnectHandler Uses

type OnConnectHandler func(Client)

OnConnectHandler is a callback that is called when the client state changes from unconnected/disconnected to connected. Both at initial connection and on reconnection

type PacketAndToken Uses

type PacketAndToken struct {
    // contains filtered or unexported fields
}

PacketAndToken is a struct that contains both a ControlPacket and a Token. This struct is passed via channels between the client interface code and the underlying code responsible for sending and receiving MQTT messages.

type PublishToken Uses

type PublishToken struct {
    // contains filtered or unexported fields
}

PublishToken is an extension of Token containing the extra fields required to provide information about calls to Publish()

func (*PublishToken) Error Uses

func (b *PublishToken) Error() error

func (*PublishToken) MessageID Uses

func (p *PublishToken) MessageID() uint16

MessageID returns the MQTT message ID that was assigned to the Publish packet when it was sent to the broker

func (*PublishToken) Wait Uses

func (b *PublishToken) Wait() bool

Wait will wait indefinitely for the Token to complete, ie the Publish to be sent and confirmed receipt from the broker

func (*PublishToken) WaitTimeout Uses

func (b *PublishToken) WaitTimeout(d time.Duration) bool

WaitTimeout takes a time.Duration to wait for the flow associated with the Token to complete, returns true if it returned before the timeout or returns false if the timeout occurred. In the case of a timeout the Token does not have an error set in case the caller wishes to wait again

type Store Uses

type Store interface {
    Open()
    Put(key string, message packets.ControlPacket)
    Get(key string) packets.ControlPacket
    All() []string
    Del(key string)
    Close()
    Reset()
}

Store is an interface which can be used to provide implementations for message persistence. Because we may have to store distinct messages with the same message ID, we need a unique key for each message. This is possible by prepending "i." or "o." to each message id

type SubscribeToken Uses

type SubscribeToken struct {
    // contains filtered or unexported fields
}

SubscribeToken is an extension of Token containing the extra fields required to provide information about calls to Subscribe()

func (*SubscribeToken) Error Uses

func (b *SubscribeToken) Error() error

func (*SubscribeToken) Result Uses

func (s *SubscribeToken) Result() map[string]byte

Result returns a map of topics that were subscribed to along with the matching return code from the broker. This is either the Qos value of the subscription or an error code.

func (*SubscribeToken) Wait Uses

func (b *SubscribeToken) Wait() bool

Wait will wait indefinitely for the Token to complete, ie the Publish to be sent and confirmed receipt from the broker

func (*SubscribeToken) WaitTimeout Uses

func (b *SubscribeToken) WaitTimeout(d time.Duration) bool

WaitTimeout takes a time.Duration to wait for the flow associated with the Token to complete, returns true if it returned before the timeout or returns false if the timeout occurred. In the case of a timeout the Token does not have an error set in case the caller wishes to wait again

type Token Uses

type Token interface {
    Wait() bool
    WaitTimeout(time.Duration) bool
    Error() error
}

Token defines the interface for the tokens used to indicate when actions have completed.

type TokenErrorSetter Uses

type TokenErrorSetter interface {
    // contains filtered or unexported methods
}

type UnsubscribeToken Uses

type UnsubscribeToken struct {
    // contains filtered or unexported fields
}

UnsubscribeToken is an extension of Token containing the extra fields required to provide information about calls to Unsubscribe()

func (*UnsubscribeToken) Error Uses

func (b *UnsubscribeToken) Error() error

func (*UnsubscribeToken) Wait Uses

func (b *UnsubscribeToken) Wait() bool

Wait will wait indefinitely for the Token to complete, ie the Publish to be sent and confirmed receipt from the broker

func (*UnsubscribeToken) WaitTimeout Uses

func (b *UnsubscribeToken) WaitTimeout(d time.Duration) bool

WaitTimeout takes a time.Duration to wait for the flow associated with the Token to complete, returns true if it returned before the timeout or returns false if the timeout occurred. In the case of a timeout the Token does not have an error set in case the caller wishes to wait again

Directories

PathSynopsis
packets

Package mqtt imports 20 packages (graph) and is imported by 214 packages. Updated 2019-04-18. Refresh now. Tools for package owners.