go-mqtt 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8698ec3fcf903c009cffb7a8c9f4fefc17704577c05b629e7cf2192c2402de94
-  data.tar.gz: 84deb7a3a57332f01b3d24b86b0dbb1bec8425c5586f851e2fb66aeb4b506b63
+  metadata.gz: 4af5bac1776bc58c17da97d092f8443f6de49ec78cb6e1674f413c8c5e8cdf43
+  data.tar.gz: 4131b5ef45dc34c890a5827d3e263a2703bcdad73acfaa5ba0f42da9e977be22
 SHA512:
-  metadata.gz: cbcd90f72f086b3ee8e42daf3aaf4138f556932b5240a625dda5229f25e61eb05a3ec5536a8966acb2408ed52240465ef9ec654e93e07a50b41328cccb6aae6a
-  data.tar.gz: a8cae3bc9bdf70ce094332991eb1468acb07b44eb8b0e82c72d3dbadf7bf0ecc8bd490e74a129b74ba497c5ad8c37c76b91fdef24dd76d38c5e8491266854b40
+  metadata.gz: bea4be741b694732831bc09d394e38bd84c2c51b0043a48fe5c5b056067b23549bab82d1b21ec6765805b981c12e63ee9531d0031739d5291114af2b348cd242
+  data.tar.gz: 69103699feef84a19de26d6b75ce44eddd7c5d08b9e8a47df1d1652557e9a122ba7f257b04b968f5e2db43e92c02996e9f9bcb9bcfe6d98883493e2d5cc9e7b5

data/lib/mqtt/client.rb

@@ -1,145 +1,100 @@
+# frozen_string_literal: true
+
 autoload :OpenSSL, 'openssl'
 autoload :URI, 'uri'
 autoload :CGI, 'cgi'
+autoload :Logger, 'logger'
 
 # Client class for talking to an MQTT server
 module MQTT
   class Client
-    # Hostname of the remote server
-    attr_accessor :host
-
-    # Port number of the remote server
-    attr_accessor :port
-
-    # The version number of the MQTT protocol to use (default 3.1.1)
-    attr_accessor :version
-
-    # Set to true to enable SSL/TLS encrypted communication
-    #
-    # Set to a symbol to use a specific variant of SSL/TLS.
-    # Allowed values include:
-    #
-    # @example Using TLS 1.0
-    #    client = Client.new('mqtt.example.com', :ssl => :TLSv1)
-    # @see OpenSSL::SSL::SSLContext::METHODS
-    attr_accessor :ssl
-
-    # Set to false to skip tls hostname verification
-    attr_accessor :verify_host
-
-    # Time (in seconds) between pings to remote server (default is 15 seconds)
-    attr_accessor :keep_alive
-
-    # Set the 'Clean Session' flag when connecting? (default is true)
-    attr_accessor :clean_session
-
-    # Client Identifier
-    attr_accessor :client_id
-
-    # Number of seconds to wait for acknowledgement packets (default is 5 seconds)
-    attr_accessor :ack_timeout
-
-    # Number of seconds to connect to the server (default is 90 seconds)
-    attr_accessor :connect_timeout
-
-    # Username to authenticate to the server with
-    attr_accessor :username
-
-    # Password to authenticate to the server with
-    attr_accessor :password
-
-    # The topic that the Will message is published to
-    attr_accessor :will_topic
-
-    # Contents of message that is sent by server when client disconnect
-    attr_accessor :will_payload
-
-    # The QoS level of the will message sent by the server
-    attr_accessor :will_qos
-
-    # If the Will message should be retain by the server after it is sent
-    attr_accessor :will_retain
-
-    # Last ping response time
+    # Connection-related attributes
+    attr_accessor :host          # Hostname of the remote server
+    attr_accessor :port          # Port number of the remote server
+    attr_accessor :version       # MQTT protocol version (default 3.1.1)
+    attr_accessor :ssl           # SSL/TLS encryption flag and version
+    attr_accessor :verify_host   # Whether to verify SSL hostname
+    attr_accessor :keep_alive    # Keep-alive timer in seconds (default 15)
+    attr_accessor :logger        # Logger instance for debug output
+
+    # Authentication and session attributes
+    attr_accessor :clean_session # Whether to start a clean session
+    attr_accessor :client_id     # Unique client identifier
+    attr_accessor :username      # Username for authentication
+    attr_accessor :password      # Password for authentication
+    attr_accessor :ack_timeout   # Timeout for acknowledgments (default 5s)
+    attr_accessor :connect_timeout # Connection timeout (default 90s)
+    attr_accessor :max_retries # Maximum number of reconnection attempts (default 30)
+    attr_accessor :retry_interval # Base interval for retry backoff (default 5s)
+
+    # Will message attributes
+    attr_accessor :will_topic    # Topic for will message
+    attr_accessor :will_payload  # Content of will message
+    attr_accessor :will_qos      # QoS level for will message
+    attr_accessor :will_retain   # Whether to retain will message
+
+    # Last ping response timestamp
     attr_reader :last_ping_response
 
     # Timeout between select polls (in seconds)
-    SELECT_TIMEOUT = 0.5
+    SELECT_TIMEOUT = 1
 
     # Default attribute values
     ATTR_DEFAULTS = {
-      :host => nil,
-      :port => nil,
-      :version => '3.1.1',
-      :keep_alive => 15,
-      :clean_session => true,
-      :client_id => nil,
-      :ack_timeout => 5,
-      :connect_timeout => 90,
-      :username => nil,
-      :password => nil,
-      :will_topic => nil,
-      :will_payload => nil,
-      :will_qos => 0,
-      :will_retain => false,
-      :ssl => false,
-      :verify_host => true
+      host: nil,
+      port: nil,
+      version: '3.1.1',
+      keep_alive: 15,
+      clean_session: true,
+      client_id: nil,
+      ack_timeout: 5,
+      connect_timeout: 30,
+      username: nil,
+      password: nil,
+      will_topic: nil,
+      will_payload: nil,
+      will_qos: 0,
+      will_retain: false,
+      ssl: false,
+      verify_host: true,
+      max_retries: 30,
+      retry_interval: 5,
+      logger: Logger.new($stdout).tap { |l| l.level = Logger::WARN }
     }
 
     # Create and connect a new MQTT Client
-    #
-    # Accepts the same arguments as creating a new client.
-    # If a block is given, then it will be executed before disconnecting again.
-    #
-    # Example:
-    #  MQTT::Client.connect('myserver.example.com') do |client|
-    #    # do stuff here
-    #  end
-    #
+    # If a block is given, execute it and then disconnect
     def self.connect(*args, &block)
       client = MQTT::Client.new(*args)
       client.connect(&block)
       client
+    rescue StandardError => e
+      @logger.error("Failed to connect: #{e.message}")
+      raise e
     end
 
-    # Generate a random client identifier
-    # (using the characters 0-9 and a-z)
+    # Generate a random client identifier with given prefix and length
     def self.generate_client_id(prefix = 'ruby', length = 16)
       str = prefix.dup
       length.times do
         num = rand(36)
-        # Adjust based on number or letter.
-        num += num < 10 ? 48 : 87
-        str += num.chr
+        str << (num < 10 ? (48 + num).chr : (87 + num).chr)
       end
       str
     end
 
-    # Create a new MQTT Client instance
-    #
-    # Accepts one of the following:
-    # - a URI that uses the MQTT scheme
-    # - a hostname and port
-    # - a Hash containing attributes to be set on the new instance
-    #
-    # If no arguments are given then the method will look for a URI
-    # in the MQTT_SERVER environment variable.
-    #
-    # Examples:
-    #  client = MQTT::Client.new
-    #  client = MQTT::Client.new('mqtt://myserver.example.com')
-    #  client = MQTT::Client.new('mqtt://user:pass@myserver.example.com')
-    #  client = MQTT::Client.new('myserver.example.com')
-    #  client = MQTT::Client.new('myserver.example.com', 18830)
-    #  client = MQTT::Client.new(:host => 'myserver.example.com')
-    #  client = MQTT::Client.new(:host => 'myserver.example.com', :keep_alive => 30)
-    #
+    # Initialize a new MQTT Client instance
+    # Accepts:
+    # - URI with MQTT scheme
+    # - hostname and port
+    # - Hash of attributes
     def initialize(*args)
       attributes = args.last.is_a?(Hash) ? args.pop : {}
 
       # Set server URI from environment if present
       attributes.merge!(parse_uri(ENV['MQTT_SERVER'])) if args.length.zero? && ENV['MQTT_SERVER']
 
+      # Parse the first argument as URI or hostname
       if args.length >= 1
         case args[0]
         when URI
@@ -151,79 +106,76 @@ module MQTT
         end
       end
 
+      # Set port from second argument if provided
       if args.length >= 2
         attributes[:port] = args[1] unless args[1].nil?
       end
 
       raise ArgumentError, 'Unsupported number of arguments' if args.length >= 3
 
-      # Merge arguments with default values for attributes
+      # Initialize attributes with defaults
       ATTR_DEFAULTS.merge(attributes).each_pair do |k, v|
         send("#{k}=", v)
       end
 
-      # Set a default port number
+      # Set default port based on SSL
       if @port.nil?
         @port = @ssl ? MQTT::DEFAULT_SSL_PORT : MQTT::DEFAULT_PORT
       end
 
+      # Load SSL libraries if needed
       if @ssl
         require 'openssl'
         require 'mqtt/openssl_fix'
       end
 
-      # Initialise private instance variables
+      # Initialize internal state variables
+      @subscriptions = {} # Track active subscriptions
+      @subscriptions_mutex = Mutex.new
       @last_ping_request = current_time
       @last_ping_response = current_time
       @socket = nil
       @read_queue = Queue.new
-      @pubacks = {}
-      @pubrecs = {}  # For QoS 2 PUBREC packets
-      @pubrels = {}  # For QoS 2 PUBREL packets
-      @pubcomps = {} # For QoS 2 PUBCOMP packets
+      @pubacks = {}       # For QoS 1 acknowledgments
+      @pubrecs = {}       # For QoS 2 PUBREC packets
+      @pubrels = {}       # For QoS 2 PUBREL packets
+      @pubcomps = {}      # For QoS 2 PUBCOMP packets
       @read_thread = nil
       @write_semaphore = Mutex.new
       @pubacks_semaphore = Mutex.new
       @message_id = 0
     end
 
-    # Get the OpenSSL context, that is used if SSL/TLS is enabled
+    # Get the SSL context for secure connections
     def ssl_context
       @ssl_context ||= OpenSSL::SSL::SSLContext.new
     end
 
-    # Set a path to a file containing a PEM-format client certificate
+    # SSL certificate handling methods
     def cert_file=(path)
       self.cert = File.read(path)
     end
 
-    # PEM-format client certificate
     def cert=(cert)
       ssl_context.cert = OpenSSL::X509::Certificate.new(cert)
     end
 
-    # Set a path to a file containing a PEM-format client private key
     def key_file=(*args)
       path, passphrase = args.flatten
       ssl_context.key = OpenSSL::PKey.read(File.binread(path), passphrase)
     end
 
-    # Set to a PEM-format client private key
     def key=(*args)
       cert, passphrase = args.flatten
       ssl_context.key = OpenSSL::PKey.read(cert, passphrase)
     end
 
-    # Set a path to a file containing a PEM-format CA certificate and enable peer verification
     def ca_file=(path)
       ssl_context.ca_file = path
       ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER unless path.nil?
     end
 
-    # Set the Will for the client
-    #
-    # The will is a message that will be delivered by the server when the client dies.
-    # The Will must be set before establishing a connection to the server
+    # Set up a will message (last testament)
     def set_will(topic, payload, retain = false, qos = 0)
       self.will_topic = topic
       self.will_payload = payload
@@ -231,71 +183,36 @@ module MQTT
       self.will_qos = qos
     end
 
-    # Connect to the MQTT server
-    # If a block is given, then yield to that block and then disconnect again.
+    # Connect to the MQTT server with automatic reconnection
     def connect(clientid = nil)
       @client_id = clientid unless clientid.nil?
 
+      # Validate client ID
       if @client_id.nil? || @client_id.empty?
         raise 'Must provide a client_id if clean_session is set to false' unless @clean_session
-
-        # Empty client id is not allowed for version 3.1.0
         @client_id = MQTT::Client.generate_client_id if @version == '3.1.0'
       end
 
       raise 'No MQTT server host set when attempting to connect' if @host.nil?
 
-      unless connected?
-        # Create network socket
-        tcp_socket = open_tcp_socket
-
-        if @ssl
-          # Set the protocol version
-          ssl_context.ssl_version = @ssl if @ssl.is_a?(Symbol)
-
-          @socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
-          @socket.sync_close = true
+      # Return early if already connected
+      return if connected?
 
-          # Set hostname on secure socket for Server Name Indication (SNI)
-          @socket.hostname = @host if @socket.respond_to?(:hostname=)
+      # Establish network connection
+      tcp_socket = open_tcp_socket
 
-          @socket.connect
+      @socket = @ssl ? setup_ssl_connection(tcp_socket) : tcp_socket
+      establish_mqtt_connection
 
-          @socket.post_connection_check(@host) if @verify_host
-        else
-          @socket = tcp_socket
-        end
-
-        # Construct a connect packet
-        packet = MQTT::Packet::Connect.new(
-          :version => @version,
-          :clean_session => @clean_session,
-          :keep_alive => @keep_alive,
-          :client_id => @client_id,
-          :username => @username,
-          :password => @password,
-          :will_topic => @will_topic,
-          :will_payload => @will_payload,
-          :will_qos => @will_qos,
-          :will_retain => @will_retain
-        )
-
-        # Send packet
-        send_packet(packet)
-
-        # Receive response
-        receive_connack
-
-        # Start packet reading thread
-        @read_thread = Thread.new(Thread.current) do |parent|
-          Thread.current[:parent] = parent
-          receive_packet while connected?
-        end
+      # Start packet reading thread with retry logic
+      @read_thread&.kill if @read_thread&.alive?
+      @read_thread = Thread.new(Thread.current) do |parent|
+        Thread.current[:parent] = parent
+        receive_packet while connected?
       end
 
       return unless block_given?
 
-      # If a block is given, then yield and disconnect
       begin
         yield(self)
       ensure
@@ -303,31 +220,36 @@ module MQTT
       end
     end
 
-    # Disconnect from the MQTT server.
-    # If you don't want to say goodbye to the server, set send_msg to false.
+    # Gracefully disconnect from the MQTT server
     def disconnect(send_msg = true)
-      # Stop reading packets from the socket first
-      @read_thread.kill if @read_thread && @read_thread.alive?
+      @read_thread&.kill if @read_thread&.alive?
       @read_thread = nil
 
       return unless connected?
 
-      # Close the socket if it is open
       if send_msg
-        packet = MQTT::Packet::Disconnect.new
-        send_packet(packet)
+        begin
+          packet = MQTT::Packet::Disconnect.new
+          send_packet(packet)
+        rescue StandardError
+          # Ignore errors when sending disconnect packet
+        end
+      end
+
+      begin
+        @socket&.close
+      ensure
+        handle_close
+        @socket = nil
       end
-      @socket.close unless @socket.nil?
-      handle_close
-      @socket = nil
     end
 
-    # Checks whether the client is connected to the server.
+    # Check if client is currently connected
     def connected?
       !@socket.nil? && !@socket.closed?
     end
 
-    # Publish a message on a particular topic to the MQTT server.
+    # Publish a message with specified QoS
     def publish(topic, payload = '', retain = false, qos = 0)
       raise ArgumentError, 'Topic name cannot be nil' if topic.nil?
       raise ArgumentError, 'Topic name cannot be empty' if topic.empty?
@@ -341,19 +263,20 @@ module MQTT
         :payload => payload
       )
 
+      # Handle different QoS levels
       case qos
-      when 0
+      when 0  # At most once
         send_packet(packet)
-      when 1
+      when 1  # At least once
         queue = wait_for_puback(packet.id)
         send_packet(packet)
         wait_for_ack(queue, packet.id, @pubacks)
-      when 2
+      when 2  # Exactly once
         queue = wait_for_pubrec(packet.id)
         send_packet(packet)
 
         if wait_for_ack(queue, packet.id, @pubrecs)
-          # Send PUBREL
+          # Send PUBREL and wait for PUBCOMP
           pubrel = MQTT::Packet::Pubrel.new(:id => packet.id)
           queue = wait_for_pubcomp(packet.id)
           send_packet(pubrel)
@@ -362,37 +285,42 @@ module MQTT
       end
     end
 
-    # Send a subscribe message for one or more topics on the MQTT server.
-    # The topics parameter should be one of the following:
-    # * String: subscribe to one topic with QoS 0
-    # * Array: subscribe to multiple topics with QoS 0
-    # * Hash: subscribe to multiple topics where the key is the topic and the value is the QoS level
-    #
-    # For example:
-    #   client.subscribe( 'a/b' )
-    #   client.subscribe( 'a/b', 'c/d' )
-    #   client.subscribe( ['a/b',0], ['c/d',1] )
-    #   client.subscribe( 'a/b' => 0, 'c/d' => 1 )
-    #
+    # Subscribe to one or more topics
     def subscribe(*topics)
       packet = MQTT::Packet::Subscribe.new(
         :id => next_packet_id,
         :topics => topics
       )
+
+      # Track subscriptions for reconnection
+      @subscriptions_mutex.synchronize do
+        topics.each do |topic|
+          if topic.is_a?(Hash)
+            topic.each { |t, qos| @subscriptions[t] = qos }
+          else
+            @subscriptions[topic] = 0 # Default QoS 0
+          end
+        end
+      end
+
       send_packet(packet)
     end
 
-    # Return the next message received from the MQTT server.
-    # An optional topic can be given to subscribe to.
-    #
-    # The method either returns the topic and message as an array:
-    #   topic,message = client.get
-    #
-    # Or can be used with a block to keep processing messages:
-    #   client.get('test') do |topic,payload|
-    #     # Do stuff here
-    #   end
-    #
+    # Resubscribe to all active topics (used after reconnection)
+    def resubscribe_all
+      @subscriptions_mutex.synchronize do
+        @subscriptions.each_slice(20) do |slice|
+          subscribe_hash = slice.to_h
+          packet = MQTT::Packet::Subscribe.new(
+            :id => next_packet_id,
+            :topics => subscribe_hash
+          )
+          send_packet(packet)
+        end
+      end
+    end
+
+    # Get next message with optional topic subscription
     def get(topic = nil, options = {})
       if block_given?
         get_packet(topic) do |packet|
@@ -400,39 +328,25 @@ module MQTT
         end
       else
         loop do
-          # Wait for one packet to be available
           packet = get_packet(topic)
           return packet.topic, packet.payload unless packet.retain && options[:omit_retained]
         end
       end
     end
 
-    # Return the next packet object received from the MQTT server.
-    # An optional topic can be given to subscribe to.
-    #
-    # The method either returns a single packet:
-    #   packet = client.get_packet
-    #   puts packet.topic
-    #
-    # Or can be used with a block to keep processing messages:
-    #   client.get_packet('test') do |packet|
-    #     # Do stuff here
-    #     puts packet.topic
-    #   end
-    #
+    # Get next packet with optional topic subscription
     def get_packet(topic = nil)
-      # Subscribe to a topic, if an argument is given
       subscribe(topic) unless topic.nil?
 
       if block_given?
-        # Loop forever!
         loop do
           packet = @read_queue.pop
           yield(packet)
+          # Handle QoS acknowledgments
           case packet.qos
-          when 1
+          when 1  # At least once
             puback_packet(packet)
-          when 2
+          when 2  # Exactly once
             pubrec = MQTT::Packet::Pubrec.new(:id => packet.id)
             send_packet(pubrec)
             # Wait for PUBREL before delivering
@@ -445,7 +359,6 @@ module MQTT
           end
         end
       else
-        # Wait for one packet to be available
         packet = @read_queue.pop
         case packet.qos
         when 1
@@ -453,10 +366,8 @@ module MQTT
         when 2
           pubrec = MQTT::Packet::Pubrec.new(:id => packet.id)
           send_packet(pubrec)
-          # Wait for PUBREL before delivering
           queue = wait_for_pubrel(packet.id)
           if wait_for_ack(queue, packet.id, @pubrels)
-            # Send PUBCOMP
             pubcomp = MQTT::Packet::Pubcomp.new(:id => packet.id)
             send_packet(pubcomp)
           end
@@ -465,24 +376,29 @@ module MQTT
       end
     end
 
-    # Returns true if the incoming message queue is empty.
+    # Queue management methods
     def queue_empty?
       @read_queue.empty?
     end
 
-    # Returns the length of the incoming message queue.
     def queue_length
       @read_queue.length
     end
 
-    # Clear the incoming message queue.
     def clear_queue
       @read_queue.clear
     end
 
-    # Send a unsubscribe message for one or more topics on the MQTT server
+    # Unsubscribe from topics
     def unsubscribe(*topics)
-      topics = topics.first if topics.is_a?(Enumerable) && topics.count == 1
+      # Convert single topic string to array
+      topics = [topics].flatten
+
+      @subscriptions_mutex.synchronize do
+        topics.each do |topic|
+          @subscriptions.delete(topic)
+        end
+      end
 
       packet = MQTT::Packet::Unsubscribe.new(
         :topics => topics,
@@ -491,32 +407,7 @@ module MQTT
       send_packet(packet)
     end
 
-    private
-
-    # Try to read a packet from the server
-    # Also sends keep-alive ping packets.
-    def receive_packet
-      # Poll socket - is there data waiting?
-
-      return unless @socket && !@socket.closed? && @socket.respond_to?(:fileno)
-      result = IO.select([@socket], [], [], SELECT_TIMEOUT)
-      handle_timeouts
-      unless result.nil?
-        # Yes - read in the packet
-        packet = MQTT::Packet.read(@socket)
-        handle_packet packet
-      end
-      keep_alive!
-    # Pass exceptions up to parent thread
-    rescue ::Exception => exp
-      unless @socket.nil?
-        @socket.close
-        @socket = nil
-        handle_close
-      end
-      Thread.current[:parent].raise(exp)
-    end
-
+    # QoS acknowledgment handling
     def wait_for_puback(id)
       @pubacks_semaphore.synchronize do
         @pubacks[id] = Queue.new
@@ -574,43 +465,116 @@ module MQTT
       end
     end
 
+    private
+
+    # Read packets from server with automatic reconnection
+    def receive_packet
+      return unless @socket && !@socket.closed? && @socket.respond_to?(:fileno)
+
+      result = IO.select([@socket], [], [], SELECT_TIMEOUT)
+      handle_timeouts
+
+      unless result.nil?
+        packet = MQTT::Packet.read(@socket)
+        handle_packet packet
+      end
+      keep_alive!
+    rescue MQTT::ProtocolException, Errno::ECONNRESET, MQTT::NotConnectedException, IOError => e
+      handle_connection_error(e)
+    rescue Exception => exp
+      unless @socket.nil?
+        @socket.close
+        @socket = nil
+        handle_close
+      end
+      Thread.current[:parent].raise(exp)
+    end
+
+    def handle_connection_error(error)
+      retry_count = 0
+
+      while retry_count < @max_retries
+        begin
+          retry_count += 1
+
+          @logger.warn("Reconnecting to MQTT server: #{@host}:#{@port} (attempt #{retry_count})")
+
+          @socket.close unless @socket.nil? || @socket.closed?
+          @socket = nil
+
+          # Reconnect
+          tcp_socket = open_tcp_socket
+          @socket = @ssl ? setup_ssl_connection(tcp_socket) : tcp_socket
+          establish_mqtt_connection
+
+          # Reset ping timers after successful reconnection
+          @last_ping_request = current_time
+          @last_ping_response = current_time
+
+          return
+        rescue StandardError => _e
+          delay = if retry_count < 15
+                    @retry_interval * retry_count
+                  else
+                    @retry_interval * retry_count * 10
+                  end
+
+          sleep(delay)
+        end
+      end
+
+      handle_close
+      Thread.current[:parent].raise(error)
+    end
+
+    def keep_alive!
+      return unless @keep_alive > 0 && connected?
+
+      response_timeout = (@keep_alive * 1.5).ceil
+      if current_time >= @last_ping_request + @keep_alive
+        packet = MQTT::Packet::Pingreq.new
+        send_packet(packet)
+        @last_ping_request = current_time
+      elsif current_time > @last_ping_response + response_timeout
+        raise MQTT::ProtocolException, "No Ping Response received for #{response_timeout} seconds"
+      end
+    end
+
     def handle_packet(packet)
       case packet
       when MQTT::Packet::Publish
-        if packet.qos == 2
-          # Send PUBREC
-          pubrec = MQTT::Packet::Pubrec.new(:id => packet.id)
-          send_packet(pubrec)
-
-          # Store the packet for later delivery
-          @read_queue.push(packet)
-        else
-          # QoS 0 or 1
-          @read_queue.push(packet)
-          # Send PUBACK for QoS 1
-          puback_packet(packet) if packet.qos == 1
-        end
-      when MQTT::Packet::Puback
-        @pubacks_semaphore.synchronize do
-          @pubacks[packet.id] << packet if @pubacks[packet.id]
-        end
-      when MQTT::Packet::Pubrec
-        @pubacks_semaphore.synchronize do
-          @pubrecs[packet.id] << packet if @pubrecs[packet.id]
-        end
-      when MQTT::Packet::Pubrel
-        @pubacks_semaphore.synchronize do
-          @pubrels[packet.id] << packet if @pubrels[packet.id]
-        end
-      when MQTT::Packet::Pubcomp
-        @pubacks_semaphore.synchronize do
-          @pubcomps[packet.id] << packet if @pubcomps[packet.id]
-        end
+        handle_publish_packet(packet)
+      when MQTT::Packet::Puback, MQTT::Packet::Pubrec,
+           MQTT::Packet::Pubrel, MQTT::Packet::Pubcomp
+        handle_acknowledgment_packet(packet)
       when MQTT::Packet::Pingresp
         @last_ping_response = current_time
       end
     end
 
+    def handle_publish_packet(packet)
+      if packet.qos == 2
+        pubrec = MQTT::Packet::Pubrec.new(:id => packet.id)
+        send_packet(pubrec)
+        @read_queue.push(packet)
+      else
+        @read_queue.push(packet)
+        puback_packet(packet) if packet.qos == 1
+      end
+    end
+
+    def handle_acknowledgment_packet(packet)
+      @pubacks_semaphore.synchronize do
+        queue = case packet
+                when MQTT::Packet::Puback then @pubacks[packet.id]
+                when MQTT::Packet::Pubrec then @pubrecs[packet.id]
+                when MQTT::Packet::Pubrel then @pubrels[packet.id]
+                when MQTT::Packet::Pubcomp then @pubcomps[packet.id]
+                end
+        queue&.<< packet
+      end
+    end
+
     def handle_timeouts
       @pubacks_semaphore.synchronize do
         @pubacks.each_value { |q| q << :read_timeout }
@@ -640,19 +604,6 @@ module MQTT
       end
     end
 
-    def keep_alive!
-      return unless @keep_alive > 0 && connected?
-
-      response_timeout = (@keep_alive * 1.5).ceil
-      if current_time >= @last_ping_request + @keep_alive
-        packet = MQTT::Packet::Pingreq.new
-        send_packet(packet)
-        @last_ping_request = current_time
-      elsif current_time > @last_ping_response + response_timeout
-        raise MQTT::ProtocolException, "No Ping Response received for #{response_timeout} seconds"
-      end
-    end
-
     def puback_packet(packet)
       send_packet(MQTT::Packet::Puback.new(:id => packet.id))
     end
@@ -729,27 +680,33 @@ module MQTT
       end
     end
 
-    # ---- Deprecated attributes and methods  ---- #
-    public
-
-    # @deprecated Please use {#host} instead
-    def remote_host
-      host
-    end
-
-    # @deprecated Please use {#host=} instead
-    def remote_host=(args)
-      self.host = args
-    end
-
-    # @deprecated Please use {#port} instead
-    def remote_port
-      port
-    end
+    def setup_ssl_connection(tcp_socket)
+      ssl_context.ssl_version = @ssl if @ssl.is_a?(Symbol)
+      socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+      socket.sync_close = true
+      socket.hostname = @host if socket.respond_to?(:hostname=)
+      socket.connect
+      socket.post_connection_check(@host) if @verify_host
+      socket
+    end
+
+    def establish_mqtt_connection
+      packet = MQTT::Packet::Connect.new(
+        :version => @version,
+        :clean_session => @clean_session,
+        :keep_alive => @keep_alive,
+        :client_id => @client_id,
+        :username => @username,
+        :password => @password,
+        :will_topic => @will_topic,
+        :will_payload => @will_payload,
+        :will_qos => @will_qos,
+        :will_retain => @will_retain
+      )
 
-    # @deprecated Please use {#port=} instead
-    def remote_port=(args)
-      self.port = args
+      send_packet(packet)
+      receive_connack
+      resubscribe_all
     end
   end
 end

data/lib/mqtt/version.rb

@@ -1,4 +1,4 @@
 module MQTT
   # The version number of the MQTT gem
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/mqtt_client_spec.rb

@@ -288,26 +288,6 @@ describe MQTT::Client do
     end
   end
 
-  describe "deprecated attributes" do
-    it "should allow getting and setting the host name using the remote_host method" do
-      client.remote_host = 'remote-host.example.com'
-      expect(client.host).to eq('remote-host.example.com')
-      expect(client.remote_host).to eq('remote-host.example.com')
-      client.host = 'foo.example.org'
-      expect(client.host).to eq('foo.example.org')
-      expect(client.remote_host).to eq('foo.example.org')
-    end
-
-    it "should allow getting and setting the port using the remote_port method" do
-      client.remote_port = 9999
-      expect(client.port).to eq(9999)
-      expect(client.remote_port).to eq(9999)
-      client.port = 1234
-      expect(client.port).to eq(1234)
-      expect(client.remote_port).to eq(1234)
-    end
-  end
-
   describe "when calling the 'connect' method on a client" do
     before(:each) do
       allow(TCPSocket).to receive(:new).and_return(socket)
@@ -321,6 +301,8 @@ describe MQTT::Client do
     end
 
     it "should not create a new TCP Socket if connected" do
+      allow(socket).to receive(:closed?).and_return(false)
+      client.instance_variable_set('@socket', socket)
       allow(client).to receive(:connected?).and_return(true)
       expect(TCPSocket).to receive(:new).never
       client.connect('myclient')
@@ -964,6 +946,9 @@ describe MQTT::Client do
   describe "when calling the 'unsubscribe' method" do
     before(:each) do
       client.instance_variable_set('@socket', socket)
+      # Initialize the subscriptions hash
+      client.instance_variable_set('@subscriptions', {})
+      client.instance_variable_set('@subscriptions_mutex', Mutex.new)
     end
 
     it "should write a valid UNSUBSCRIBE packet to the socket if given a single topic String" do
@@ -982,63 +967,6 @@ describe MQTT::Client do
     end
   end
 
-  describe "when calling the 'receive_packet' method" do
-    before(:each) do
-      client.instance_variable_set('@socket', socket)
-      allow(IO).to receive(:select).and_return([[socket], [], []])
-      @read_queue = client.instance_variable_get('@read_queue')
-      @parent_thread = Thread.current[:parent] = double('Parent Thread')
-      allow(@parent_thread).to receive(:raise)
-    end
-
-    it "should put PUBLISH messages on to the read queue" do
-      socket.write("\x30\x0e\x00\x05topicpayload")
-      socket.rewind
-      client.send(:receive_packet)
-      expect(@read_queue.size).to eq(1)
-    end
-
-    it "should not put other messages on to the read queue" do
-      socket.write("\x20\x02\x00\x00")
-      socket.rewind
-      client.send(:receive_packet)
-      expect(@read_queue.size).to eq(0)
-    end
-
-    it "should close the socket if there is an MQTT exception" do
-      expect(socket).to receive(:close).once
-      allow(MQTT::Packet).to receive(:read).and_raise(MQTT::Exception)
-      client.send(:receive_packet)
-    end
-
-    it "should close the socket if there is a system call error" do
-      expect(socket).to receive(:close).once
-      allow(MQTT::Packet).to receive(:read).and_raise(Errno::ECONNRESET)
-      client.send(:receive_packet)
-    end
-
-    it "should pass exceptions up to parent thread" do
-      e = MQTT::Exception.new
-      expect(@parent_thread).to receive(:raise).with(e).once
-      allow(MQTT::Packet).to receive(:read).and_raise(e)
-      client.send(:receive_packet)
-    end
-
-    it "should pass a system call error up to parent thread" do
-      e = Errno::ECONNRESET.new
-      expect(@parent_thread).to receive(:raise).with(e).once
-      allow(MQTT::Packet).to receive(:read).and_raise(e)
-      client.send(:receive_packet)
-    end
-
-    it "should update last_ping_response when receiving a Pingresp" do
-      allow(MQTT::Packet).to receive(:read).and_return MQTT::Packet::Pingresp.new
-      client.instance_variable_set '@last_ping_response', Time.at(0)
-      client.send :receive_packet
-      expect(client.last_ping_response).to be_within(1).of now
-    end
-  end
-
   describe "when calling the 'keep_alive!' method" do
     before(:each) do
       client.instance_variable_set('@socket', socket)

data/spec/zz_client_integration_spec.rb

@@ -159,7 +159,22 @@ describe "a client talking to a server" do
       @server.respond_to_pings = false
       @client.keep_alive = keep_alive
       @client.connect
-      sleep(keep_alive * 3)
+
+      # Wait for the first ping to be sent
+      start_time = Time.now
+      while Time.now - start_time < keep_alive + 1
+        sleep 0.1
+        break if @server.pings_received > 0
+      end
+
+      # Ensure we received at least one ping
+      expect(@server.pings_received).to be >= 1
+
+      # Wait for the response timeout
+      sleep((keep_alive * 1.5).ceil + 1)
+
+      # Force a keep_alive check
+      @client.send(:keep_alive!)
     end
 
     context "when keep-alive=1" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: go-mqtt
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Nicholas J Humfrey
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-21 00:00:00.000000000 Z
+date: 2025-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler