client

type Client struct {

	// The session used by the client to store unacknowledged packets.
	Session Session

	// The Callback is called by the client upon received messages or internal
	// errors. An error can be returned if the callback is not already called
	// with an error to instantly close the client and prevent it from sending
	// any acknowledgments for the specified message. In this case the callback
	// is called again with the error.
	//
	// Note: Execution of the client is stopped before the callback is called and
	// resumed after the callback returns. This means that waiting on a future
	// inside the callback will deadlock the client.
	Callback func(msg *packet.Message, err error) error

	// The logger that is used to log low level information about packets
	// that have been successfully sent and received and details about the
	// automatic keep alive handler.
	Logger func(msg string)
	// contains filtered or unexported fields
}

type Config struct {
	// Dialer can be set to use a custom dialer.
	Dialer Dialer

	// BrokerURL is the url that is used to infer options to open the connection.
	BrokerURL string

	// ClientID can be set to the client's id.
	ClientID string

	// CleanSession can be set to request a clean session.
	CleanSession bool

	// KeepAlive should be time a duration string e.g. "30s".
	KeepAlive string

	// Will message is registered on the broker upon connect if set.
	WillMessage *packet.Message

	// ValidateSubs will cause the client to fail if subscriptions failed.
	ValidateSubs bool

	// ReadLimit defines the maximum size of a packet that can be received.
	ReadLimit int64

	// MaxWriteDelay defines the maximum allowed delay when flushing the
	// underlying buffered writer.
	MaxWriteDelay time.Duration

	// AlwaysAnnounceOnPublish defines when the message callback is called.
	// - QOS 0 and 1: Callback always occurs on reception of Publish.
	// - QOS 2 and AlwaysAnnounceOnPublish == false: Callback occurs on
	//   reception of PubRel and returning and error in the callback will close
	//   the connection before PubComp is sent.
	// - QOS 2 and AlwaysAnnounceOnPublish == true: Callback occurs on reception
	//   of Publish and returning an error in the callback will close the
	//   connection, preventing PubRec being sent, thus ensuring the redelivery
	//   of Publish.
	AlwaysAnnounceOnPublish bool
}

type ConnectFuture interface {
	GenericFuture

	// SessionPresent will return whether a session was present.
	SessionPresent() bool

	// ReturnCode will return the connack code returned by the broker.
	ReturnCode() packet.ConnackCode
}

type Dialer interface {
	Dial(urlString string) (transport.Conn, error)
}

type GenericFuture interface {
	// Wait will wait the given amount of time and return whether the future has
	// been completed, canceled or the request timed out. If no time has been
	// provided the wait will never time out.
	//
	// Note: Wait will not return any Client related errors.
	Wait(timeout time.Duration) error
}

type Service struct {
	// The session used by the client to store unacknowledged packets.
	Session Session

	// The OnlineCallback is called when the service is connected, but before
	// topics are resubscribed.
	//
	// Note: Execution of the service is resumed after the callback returns.
	// This means that waiting on a future inside the callback will deadlock the
	// service.
	OnlineCallback func(resumed bool)

	// The MessageCallback is called when a message is received. If an error is
	// returned the underlying client will be prevented from acknowledging the
	// specified message and closed immediately. The error is logged and a
	// reconnect attempt initiated.
	//
	// Note: Execution of the service is resumed after the callback returns.
	// This means that waiting on a future inside the callback will deadlock the
	// service.
	MessageCallback func(*packet.Message) error

	// The ErrorCallback is called when an error occurred.
	//
	// Note: Execution of the service is resumed after the callback returns.
	// This means that waiting on a future inside the callback will deadlock the
	// service.
	ErrorCallback func(error)

	// The OfflineCallback is called when the service is disconnected.
	//
	// Note: Execution of the service is resumed after the callback returns.
	// This means that waiting on a future inside the callback will deadlock the
	// service.
	OfflineCallback func()

	// The logger that is used to log write low level information like packets
	// that have been successfully sent and received, details about the automatic
	// keep alive handler, reconnection and occurring errors.
	Logger func(msg string)

	// The minimum delay between reconnects.
	//
	// Note: The value must be changed before calling Start.
	MinReconnectDelay time.Duration

	// The maximum delay between reconnects.
	//
	// Note: The value must be changed before calling Start.
	MaxReconnectDelay time.Duration

	// The allowed timeout until a connection attempt is canceled.
	ConnectTimeout time.Duration

	// The allowed timeout until a connection is forcefully closed.
	DisconnectTimeout time.Duration

	// The allowed timeout until a subscribe action is forcefully closed during
	// reconnect.
	ResubscribeTimeout time.Duration

	// Whether to resubscribe all subscriptions after reconnecting. Can be
	// disabled if the broker supports persistent sessions and the client is
	// configured to request one.
	ResubscribeAllSubscriptions bool

	// The time after which the queueing of a command is aborted.
	QueueTimeout time.Duration
	// contains filtered or unexported fields
}

type Session interface {
	// NextID will return the next id for outgoing packets.
	NextID() packet.ID

	// SavePacket will store a packet in the session. An eventual existing
	// packet with the same id gets quietly overwritten.
	SavePacket(session.Direction, packet.Generic) error

	// LookupPacket will retrieve a packet from the session using a packet id.
	LookupPacket(session.Direction, packet.ID) (packet.Generic, error)

	// DeletePacket will remove a packet from the session. The method must not
	// return an error if no packet with the specified id does exist.
	DeletePacket(session.Direction, packet.ID) error

	// AllPackets will return all packets currently saved in the session.
	AllPackets(session.Direction) ([]packet.Generic, error)

	// Reset will completely reset the session.
	Reset() error
}

type SubscribeFuture interface {
	GenericFuture

	// ReturnCodes will return the suback codes returned by the broker.
	ReturnCodes() []packet.QOS
}

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