class MQTT::Packet::Connect

Class representing an MQTT Connect Packet

Constants

ATTR_DEFAULTS

Default attribute values

Attributes

ack_timeout[RW]
clean_session[RW]

Set to false to keep a persistent session with the server

client_id[RW]

The client identifier string

device_id[RW]

The device_id for authenticating with the server

device_token[RW]

The device_token for authenticating with the server

keep_alive[RW]

Period the server should keep connection open for between pings

protocol_level[RW]

The version number of the protocol

protocol_name[RW]

The name of the protocol

will_payload[RW]

The payload of the Will message

will_qos[RW]

The QoS level to send the Will message as

will_retain[RW]

Set to true to make the Will message retained

will_topic[RW]

The topic name to send the Will message to

Public Class Methods

new(args = {}) click to toggle source

Create a new Client Connect packet

Calls superclass method MQTT::Packet::new
# File lib/qubitro-mqtt/packet.rb, line 448
def initialize(args = {})
  super(ATTR_DEFAULTS.merge(args))
  
  if version == '3.1.0' || version == '3.1'
    self.protocol_name ||= 'MQIsdp'
    self.protocol_level ||= 0x03
  elsif version == '3.1.1'
    self.protocol_name ||= 'MQTT'
    self.protocol_level ||= 0x04
  else
    raise ArgumentError, "Unsupported protocol version: #{version}"
  end
end

Public Instance Methods

encode_body() click to toggle source

Get serialisation of packet's body

# File lib/qubitro-mqtt/packet.rb, line 463
def encode_body
  body = ''
  
  if @version == '3.1.0'
    raise 'Client identifier too short while serialising packet' if @client_id.nil? || @client_id.bytesize < 1
    raise 'Client identifier too long when serialising packet' if @client_id.bytesize > 23
  end
  
  body += encode_string(@protocol_name)
  body += encode_bytes(@protocol_level.to_i)
  
  if @keep_alive < 0
    raise 'Invalid keep-alive value: cannot be less than 0'
  end
  
  # Set the Connect flags
  @connect_flags = 0
  @connect_flags |= 0x02 if @clean_session
  @connect_flags |= 0x04 unless @will_topic.nil?
  @connect_flags |= ((@will_qos & 0x03) << 3)
  @connect_flags |= 0x20 if @will_retain
  @connect_flags |= 0x40 unless @device_token.nil?
  @connect_flags |= 0x80 unless @device_id.nil?
  body += encode_bytes(@connect_flags)
  
  body += encode_short(@keep_alive)
  body += encode_string(@client_id)
  unless will_topic.nil?
    body += encode_string(@will_topic)
    # The MQTT v3.1 specification says that the payload is a UTF-8 string
    body += encode_string(@will_payload)
  end
  body += encode_string(@device_id) unless @device_id.nil?
  body += encode_string(@device_token) unless @device_token.nil?
  body
end
inspect() click to toggle source

Returns a human readable string, summarising the properties of the packet

# File lib/qubitro-mqtt/packet.rb, line 534
def inspect
  str = "\#<#{self.class}: " \
        "keep_alive=#{keep_alive}"
  str += ', clean' if clean_session
  str += ", client_id='#{client_id}'"
  str += ", device_id='#{device_id}'" unless device_id.nil?
  str += ', device_token=...' unless device_token.nil?
  str + '>'
end
parse_body(buffer) click to toggle source

Parse the body (variable header and payload) of a Connect packet

Calls superclass method MQTT::Packet#parse_body
# File lib/qubitro-mqtt/packet.rb, line 501
def parse_body(buffer)
  super(buffer)
  @protocol_name = shift_string(buffer)
  @protocol_level = shift_byte(buffer).to_i
  if @protocol_name == 'MQIsdp' && @protocol_level == 3
    @version = '3.1.0'
  elsif @protocol_name == 'MQTT' && @protocol_level == 4
    @version = '3.1.1'
  else
    raise ProtocolException, "Unsupported protocol: #{@protocol_name}/#{@protocol_level}"
  end
  
  @connect_flags = shift_byte(buffer)
  @clean_session = ((@connect_flags & 0x02) >> 1) == 0x01
  @keep_alive = shift_short(buffer)
  @client_id = shift_string(buffer)
  if ((@connect_flags & 0x04) >> 2) == 0x01
    # Last Will and Testament
    @will_qos = ((@connect_flags & 0x18) >> 3)
    @will_retain = ((@connect_flags & 0x20) >> 5) == 0x01
    @will_topic = shift_string(buffer)
    # The MQTT v3.1 specification says that the payload is a UTF-8 string
    @will_payload = shift_string(buffer)
  end
  if ((@connect_flags & 0x80) >> 7) == 0x01 && buffer.bytesize > 0
    @device_id = shift_string(buffer)
  end
  if ((@connect_flags & 0x40) >> 6) == 0x01 && buffer.bytesize > 0 # rubocop: disable Style/GuardClause
    @device_token = shift_string(buffer)
  end
end
protocol_version() click to toggle source

@deprecated Please use {#protocol_level} instead

# File lib/qubitro-mqtt/packet.rb, line 547
def protocol_version
  protocol_level
end
protocol_version=(args) click to toggle source

@deprecated Please use {#protocol_level=} instead

# File lib/qubitro-mqtt/packet.rb, line 552
def protocol_version=(args)
  self.protocol_level = args
end