paho-mqtt 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16c0a069f566b0c91b896cbcc0a4b3ca2eb694f6
-  data.tar.gz: bd03230d51b7bc37be071caac903ce8537073b6b
+  metadata.gz: 81783208a50d429eede136e757bddf982ed2fd83
+  data.tar.gz: 4d1c34982623e35713e8af79da00cc6bf14d91eb
 SHA512:
-  metadata.gz: 0c3a8a75de74ef2df07b3e6df1abcf694e07dd425e589169a8c7696e8131b55aba92b41daf6525e60ef3210347f33139ea399eb8092877dedc40c6f986b022e5
-  data.tar.gz: 53e67740ea1e52c1a0e73517079d1b7b0ce1f15802ea22f9a880a00ba2e514b7e715e7a06b293931e1a561cbd2beb2dd8439dee906a6fdfbc183c13f0ce7f87c
+  metadata.gz: 02f36654df8e3f0ae3a3e47f64708ca0f770076766c7e593755d8d55dc14950e40b1eab91631f4aab7815e83653f83e2ca05dd02f8565820a3d2b089a2652cee
+  data.tar.gz: 50456a5604f7318622cd1809b8859db2845c7c5a0b7b4bae15d09333d957248c40cced139c7c54ac6efff9efda6985aad4c84b50de33880491ad4a369a247ff4

data/lib/paho-mqtt.rb

@@ -1,8 +1,27 @@
+# Copyright (c) 2016-2017 Pierre Goudet <p-goudet@ruby-dev.jp>
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# and Eclipse Distribution License v1.0 which accompany this distribution.
+#
+# The Eclipse Public License is available at
+#    https://eclipse.org/org/documents/epl-v10.php.
+# and the Eclipse Distribution License is available at
+#   https://eclipse.org/org/documents/edl-v10.php.
+#
+# Contributors:
+#    Pierre Goudet - initial committer
+
 require "paho_mqtt/version"
 require "paho_mqtt/client"
 require "paho_mqtt/packet"
+require 'logger'
 
 module PahoMqtt
+  extend self
+
+  attr_accessor :logger
+
   # Default connection setup
   DEFAULT_SSL_PORT = 8883
   DEFAULT_PORT = 1883
@@ -47,15 +66,67 @@ module PahoMqtt
     nil
   ]
 
+  CONNACK_ERROR_MESSAGE = {
+    0x02 => "Client Identifier is correct but not allowed by remote server.",
+    0x03 => "Connection established but MQTT service unvailable on remote server.",
+    0x04 => "User name or user password is malformed.",
+    0x05 => "Client is not authorized to connect to the server."
+  }
+
+  CLIENT_ATTR_DEFAULTS = {
+      :host => "",
+      :port => nil,
+      :mqtt_version => '3.1.1',
+      :clean_session => true,
+      :persistent => false,
+      :blocking => false,
+      :client_id => nil,
+      :username => nil,
+      :password => nil,
+      :ssl => false,
+      :will_topic => nil,
+      :will_payload => nil,
+      :will_qos => 0,
+      :will_retain => false,
+      :keep_alive => 60,
+      :ack_timeout => 5,
+      :on_connack => nil,
+      :on_suback => nil,
+      :on_unsuback => nil,
+      :on_puback => nil,
+      :on_pubrel => nil,
+      :on_pubrec => nil,
+      :on_pubcomp => nil,
+      :on_message => nil,
+  }
+    
   Thread.abort_on_exception = true
 
+  def logger=(logger_path)
+    file = File.open(logger_path, "a+")
+    log_file = Logger.new(file)
+    log_file.level = Logger::DEBUG
+    @action_manager.logger = log_file
+  end
+
+  def logger
+    @logger
+  end
+
+  def logger?
+    @logger.is_a?(Logger)
+  end
+
   class Exception < ::Exception
   end
 
   class ProtocolViolation < PahoMqtt::Exception
   end
 
-  class ParameterException < PahoMqtt::Exception
+  class WritingException < PahoMqtt::Exception
+  end
+
+  class ReadingException < PahoMqtt::Exception
   end
 
   class PacketException < PahoMqtt::Exception

data/lib/paho_mqtt/client.rb

@@ -1,12 +1,26 @@
-require 'openssl'
-require 'socket'
-require 'logger'
+# Copyright (c) 2016-2017 Pierre Goudet <p-goudet@ruby-dev.jp>
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# and Eclipse Distribution License v1.0 which accompany this distribution.
+#
+# The Eclipse Public License is available at
+#    https://eclipse.org/org/documents/epl-v10.php.
+# and the Eclipse Distribution License is available at
+#   https://eclipse.org/org/documents/edl-v10.php.
+#
+# Contributors:
+#    Pierre Goudet - initial committer
+
+require 'paho_mqtt/handler'
+require 'paho_mqtt/connection_helper'
+require 'paho_mqtt/sender'
+require 'paho_mqtt/publisher'
+require 'paho_mqtt/subscriber'
+require 'paho_mqtt/ssl_helper'
 
 module PahoMqtt
-  class Client    
-    # Log file
-    attr_accessor :logger
-    
+  class Client
     # Connection related attributes:
     attr_accessor :host
     attr_accessor :port
@@ -18,7 +32,7 @@ module PahoMqtt
     attr_accessor :username
     attr_accessor :password
     attr_accessor :ssl
-    
+
     # Last will attributes:
     attr_accessor :will_topic
     attr_accessor :will_payload
@@ -29,100 +43,45 @@ module PahoMqtt
     attr_accessor :keep_alive
     attr_accessor :ack_timeout
 
-    #Callback attributes
-    attr_accessor :on_message
-    attr_accessor :on_connack
-    attr_accessor :on_suback
-    attr_accessor :on_unsuback
-    attr_accessor :on_puback
-    attr_accessor :on_pubrel
-    attr_accessor :on_pubrec
-    attr_accessor :on_pubcomp
-
     #Read Only attribute
-    attr_reader :registered_callback
-    attr_reader :subscribed_topics
     attr_reader :connection_state
+    attr_reader :ssl_context
 
-    ATTR_DEFAULTS = {
-      :logger => nil,
-      :host => "",
-      :port => nil,
-      :mqtt_version => '3.1.1',
-      :clean_session => true,
-      :persistent => false,
-      :blocking => false,
-      :client_id => nil,
-      :username => nil,
-      :password => nil,
-      :ssl => false,
-      :will_topic => nil,
-      :will_payload => nil,
-      :will_qos => 0,
-      :will_retain => false,
-      :keep_alive => 60,
-      :ack_timeout => 5,
-      :on_connack => nil,
-      :on_suback => nil,
-      :on_unsuback => nil,
-      :on_puback => nil,
-      :on_pubrel => nil,
-      :on_pubrec => nil,
-      :on_pubcomp => nil,
-      :on_message => nil,
-    }
-    
     def initialize(*args)
+      @last_ping_resp = Time.now
+      @last_packet_id = 0
+      @ssl_context = nil
+      @sender = nil
+      @handler = Handler.new
+      @connection_helper = nil
+      @connection_state = MQTT_CS_DISCONNECT
+      @connection_state_mutex = Mutex.new
+      @mqtt_thread = nil
+      @reconnect_thread = nil
+      @id_mutex = Mutex.new
+
       if args.last.is_a?(Hash)
         attr = args.pop
       else
         attr = {}
       end
 
-      ATTR_DEFAULTS.merge(attr).each_pair do |k,v|
+      CLIENT_ATTR_DEFAULTS.merge(attr).each_pair do |k,v|
         self.send("#{k}=", v)
       end
 
       if @port.nil?
         @port
         if @ssl
-          @port = PahoMqtt::DEFAULT_SSL_PORT
+          @port = DEFAULT_SSL_PORT
         else
-          @port = PahoMqtt::DEFAULT_PORT
+          @port = DEFAULT_PORT
         end
       end
 
       if  @client_id.nil? || @client_id == ""
         @client_id = generate_client_id
       end
-
-      @last_ping_req = Time.now
-      @last_ping_resp = Time.now
-      @last_packet_id = 0
-      @socket = nil
-      @ssl_context = nil
-      @writing_mutex = Mutex.new
-      @writing_queue = []
-      @connection_state = MQTT_CS_DISCONNECT
-      @connection_state_mutex = Mutex.new
-      @subscribed_mutex = Mutex.new
-      @subscribed_topics = []
-      @registered_callback = []
-      @waiting_suback = []
-      @suback_mutex = Mutex.new
-      @waiting_unsuback = []
-      @unsuback_mutex = Mutex.new
-      @mqtt_thread = nil
-      @reconnect_thread = nil
-
-      @puback_mutex = Mutex.new
-      @pubrec_mutex = Mutex.new
-      @pubrel_mutex = Mutex.new
-      @pubcomp_mutex = Mutex.new
-      @waiting_puback = []
-      @waiting_pubrec = []
-      @waiting_pubrel = []
-      @waiting_pubcomp = []
     end
 
     def generate_client_id(prefix='paho_ruby', lenght=16)
@@ -130,25 +89,11 @@ module PahoMqtt
       @client_id = prefix << Array.new(lenght) { charset.sample }.join
     end
 
-    def ssl_context
-      @ssl_context ||= OpenSSL::SSL::SSLContext.new
-    end
-
     def config_ssl_context(cert_path, key_path, ca_path=nil)
       @ssl ||= true
-      @ssl_context = ssl_context
-      self.cert = cert_path
-      self.key = key_path
-      self.root_ca = ca_path
+      @ssl_context = SSLHelper.config_ssl_context(cert_path, key_path, ca_path)
     end
     
-    def config_will(topic, payload="", retain=false, qos=0)
-      @will_topic = topic
-      @will_payload = payload
-      @will_retain = retain
-      @will_qos = qos
-    end
-
     def connect(host=@host, port=@port, keep_alive=@keep_alive, persistent=@persistent, blocking=@blocking)
       @persistent = persistent
       @blocking = blocking
@@ -158,11 +103,19 @@ module PahoMqtt
       @connection_state_mutex.synchronize {
         @connection_state = MQTT_CS_NEW
       }
-      setup_connection
-      connect_async(host, port, keep_alive) unless @blocking
+      @mqtt_thread.kill unless @mqtt_thread.nil? 
+      init_connection
+      @connection_helper.send_connect(session_params)
+      begin
+        @connection_state = @connection_helper.do_connect(reconnect?)
+      rescue LowVersionException
+        downgrade_version
+      end
+      build_pubsub
+      daemon_mode unless @blocking || !connected?
     end
 
-    def connect_async(host, port=1883, keep_alive)
+    def daemon_mode
       @mqtt_thread = Thread.new do
         @reconnect_thread.kill unless @reconnect_thread.nil? || !@reconnect_thread.alive?
         while connected? do
@@ -174,20 +127,34 @@ module PahoMqtt
     def connected?
       @connection_state == MQTT_CS_CONNECTED
     end
-    
+
+    def reconnect?
+      Thread.current == @reconnect_thread
+    end
+
     def loop_write(max_packet=MAX_WRITING)
-      @writing_mutex.synchronize {
-        cnt = 0
-        while !@writing_queue.empty? && cnt < max_packet do
-          send_packet(@writing_queue.shift)
-          cnt += 1
+      begin
+        @sender.writing_loop(max_packet)
+      rescue WritingException
+        if check_persistence
+          reconnect
+        else
+          raise WritingException
         end
-      }
+      end
     end
 
     def loop_read(max_packet=MAX_READ)
       max_packet.times do
-        receive_packet
+        begin
+          @handler.receive_packet
+        rescue ReadingException
+          if check_persistence
+            reconnect
+          else
+            raise ReadingException
+          end
+        end
       end
     end
 
@@ -199,19 +166,17 @@ module PahoMqtt
     end
 
     def loop_misc
-      check_keep_alive
-      check_ack_alive(@waiting_puback, @puback_mutex, MAX_PUBACK)
-      check_ack_alive(@waiting_pubrec, @pubrec_mutex, MAX_PUBREC)
-      check_ack_alive(@waiting_pubrel, @pubrel_mutex, MAX_PUBREL)
-      check_ack_alive(@waiting_pubcomp, @pubcomp_mutex, MAX_PUBCOMP)
-      check_ack_alive(@waiting_suback, @suback_mutex, @waiting_suback.length)
-      check_ack_alive(@waiting_unsuback, @unsuback_mutex, @waiting_unsuback.length)
+      if @connection_helper.check_keep_alive(@persistent, @handler.last_ping_resp, @keep_alive) == MQTT_CS_DISCONNECT
+        reconnect if check_persistence
+      end
+      @publisher.check_waiting_publisher
+      @subscriber.check_waiting_subscriber
     end
 
     def reconnect(retry_time=RECONNECT_RETRY_TIME, retry_tempo=RECONNECT_RETRY_TEMPO)
       @reconnect_thread = Thread.new do
         retry_time.times do
-          @logger.debug("New reconnect atempt...") if @logger.is_a?(Logger)
+          PahoMqtt.logger.debug("New reconnect atempt...") if PahoMqtt.logger?
           connect
           if connected?
             break
@@ -220,7 +185,7 @@ module PahoMqtt
           end
         end
         unless connected?
-        @logger.error("Reconnection atempt counter is over.(#{RECONNECT_RETRY_TIME} times)") if @logger.is_a?(Logger)
+          PahoMqtt.logger.error("Reconnection atempt counter is over.(#{RECONNECT_RETRY_TIME} times)") if PahoMqtt.logger?
           disconnect(false)
           exit
         end
@@ -228,38 +193,8 @@ module PahoMqtt
     end
 
     def disconnect(explicit=true)
-      @logger.debug("Disconnecting from #{@host}") if @logger.is_a?(Logger)
-
-      if explicit
-        send_disconnect
-        @mqtt_thread.kill if @mqtt_thread && @mqtt_thread.alive?
-        @mqtt_thread.kill if @mqtt_thread.alive?
-        @last_packet_id = 0
-
-        @writing_mutex.synchronize {
-          @writing_queue = []
-        }
-
-        @puback_mutex.synchronize {
-          @waiting_puback = []
-        }
-
-        @pubrec_mutex.synchronize {
-          @waiting_pubrec = []
-        }
-
-        @pubrel_mutex.synchronize {
-          @waiting_pubrel = []
-        }
-
-        @pubcomp_mutex.synchronize {
-          @waiting_pubcomp = []
-        }
-      end
-
-      @socket.close unless @socket.nil? || @socket.closed?
-      @socket = nil
-
+      @last_packet_id = 0 if explicit
+      @connection_helper.do_disconnect(@publisher, explicit, @mqtt_thread)
       @connection_state_mutex.synchronize {
         @connection_state = MQTT_CS_DISCONNECT
       }
@@ -268,656 +203,195 @@ module PahoMqtt
 
     def publish(topic, payload="", retain=false, qos=0)
       if topic == "" || !topic.is_a?(String)
-        @logger.error("Publish topics is invalid, not a string or empty.") if @logger.is_a?(Logger)
-        raise ParameterException
+        PahoMqtt.logger.error("Publish topics is invalid, not a string or empty.") if PahoMqtt.logger?
+        raise ArgumentError
       end
-      send_publish(topic, payload, retain, qos)
+      id = next_packet_id
+      @publisher.send_publish(topic, payload, retain, qos, id)
+      MQTT_ERR_SUCCESS
     end
 
     def subscribe(*topics)
-      unless valid_topics?(topics) == MQTT_ERR_FAIL
-        send_subscribe(topics)
-      else
-        @logger.error("Subscribe topics need one topic or a list of topics.") if @logger.is_a?(Logger)
+      begin
+        id = next_packet_id
+        unless @subscriber.send_subscribe(topics, id) == PahoMqtt::MQTT_ERR_SUCCESS
+          reconnect if check_persistence
+        end
+        MQTT_ERR_SUCCESS
+      rescue ProtocolViolation
+        PahoMqtt.logger.error("Subscribe topics need one topic or a list of topics.") if PahoMqtt.logger?
         disconnect(false)
         raise ProtocolViolation
       end
     end
 
     def unsubscribe(*topics)
-      unless valid_topics?(topics) == MQTT_ERR_FAIL
-        send_unsubscribe(topics)
-      else
-        @logger.error("Unsubscribe need at least one topics.") if @logger.is_a?(Logger)
+      begin
+        id = next_packet_id
+        unless @subscriber.send_unsubscribe(topics, id) == MQTT_ERR_SUCCESS
+          reconnect if check_persistence
+        end
+        MQTT_ERR_SUCCESS
+      rescue ProtocolViolation
+        PahoMqtt.logger.error("Unsubscribe need at least one topics.") if PahoMqtt.logger?
         disconnect(false)
         raise ProtocolViolation
       end
     end
 
     def ping_host
-      send_pingreq
+      @sender.send_pingreq
     end
 
     def add_topic_callback(topic, callback=nil, &block)
-      if topic.nil?
-        @logger.error("The topics where the callback is trying to be registered have been found nil.") if @logger.is_a?(Logger)
-        raise ParameterException
-      end
-      remove_topic_callback(topic)
-
-      if block_given?
-        @registered_callback.push([topic, block])
-      elsif !(callback.nil?) && callback.class == Proc
-        @registered_callback.push([topic, callback])
-      end
-      MQTT_ERR_SUCCESS
+      @handler.register_topic_callback(topic, callback, &block)
     end
 
     def remove_topic_callback(topic)
-      if topic.nil?
-        @logger.error("The topics where the callback is trying to be unregistered have been found nil.") if @logger.is_a?(Logger)
-        raise ParameterException
-      end
-      @registered_callback.delete_if {|pair| pair.first == topic}
-      MQTT_ERR_SUCCESS
+      @handler.clear_topic_callback(topic)
     end
     
     def on_connack(&block)
-      @on_connack = block if block_given?
-      @on_connack
+      @handler.on_connack = block if block_given?
+      @handler.on_connack
     end
 
     def on_suback(&block)
-      @on_suback = block if block_given?
-      @on_suback
+      @handler.on_suback = block if block_given?
+      @handler.on_suback
     end
 
     def on_unsuback(&block)
-      @on_unsuback = block if block_given?
-      @on_unsuback
+      @handler.on_unsuback = block if block_given?
+      @handler.on_unsuback
     end
 
     def on_puback(&block)
-      @on_puback = block if block_given?
-      @on_puback
+      @handler.on_puback = block if block_given?
+      @handler.on_puback
     end
 
     def on_pubrec(&block)
-      @on_pubrec = block if block_given?
-      @on_pubrec
+      @handler.on_pubrec = block if block_given?
+      @handler.on_pubrec
     end
 
     def on_pubrel(&block)
-      @on_pubrel = block if block_given?
-      @on_pubrel
+      @handler.on_pubrel = block if block_given?
+      @handler.on_pubrel
     end
 
     def on_pubcomp(&block)
-      @on_pubcomp = block if block_given?
-      @on_pubcomp
+      @handler.on_pubcomp = block if block_given?
+      @handler.on_pubcomp
     end
 
     def on_message(&block)
-      @on_message = block if block_given?
-      @on_message
-    end
-
-    private
-
-    def next_packet_id
-      @last_packet_id = ( @last_packet_id || 0 ).next
-    end
-
-    def config_subscription
-      unless @subscribed_topics == []
-        new_id = next_packet_id
-        packet = PahoMqtt::Packet::Subscribe.new(
-          :id => new_id,
-          :topics => @subscribed_topics
-        )
-        @subscribed_mutex.synchronize {
-          @subscribed_topics = []
-        }
-        @suback_mutex.synchronize {
-          @waiting_suback.push({ :id => new_id, :packet => packet, :timestamp => Time.now })
-        }
-        send_packet(packet)
-      end
-      MQTT_ERR_SUCCESS
-    end
-
-    def config_all_message_queue
-      config_message_queue(@waiting_puback, @puback_mutex, MAX_PUBACK)
-      config_message_queue(@waiting_pubrec, @pubrec_mutex, MAX_PUBREC)
-      config_message_queue(@waiting_pubrel, @pubrel_mutex, MAX_PUBREL)
-      config_message_queue(@waiting_pubcomp, @pubcomp_mutex, MAX_PUBCOMP)
-    end
-
-    def config_message_queue(queue, mutex, max_packet)
-      mutex.synchronize {
-        cnt = 0 
-        queue.each do |pck|
-          pck[:packet].dup ||= true
-          if cnt <= max_packet
-            append_to_writing(pck[:packet])
-            cnt += 1
-          end
-        end
-      }
-    end
-
-    def config_socket
-      unless @socket.nil?
-        @socket.close unless @socket.closed?
-        @socket = nil
-      end
-
-      unless @host.nil? || @port < 0
-        begin
-          tcp_socket = TCPSocket.new(@host, @port)
-        rescue ::Exception => exp
-          @logger.warn("Could not open a socket with #{@host} on port #{@port}") if @logger.is_a?(Logger)
-        end
-      end
-
-      if @ssl
-        unless @ssl_context.nil?
-          @socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, @ssl_context)
-          @socket.sync_close = true
-          @socket.connect
-        else
-          @logger.error("The ssl context was found as nil while the socket's opening.") if @logger.is_a?(Logger)
-          raise Exception
-        end
-      else
-        @socket = tcp_socket
-      end
+      @handler.on_message = block if block_given?
+      @handler.on_message
     end
 
-    def cert=(cert_path)
-      ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
+    def on_connack=(callback)
+      @handler.on_connack = callback if callback.is_a?(Proc)
     end
 
-    def key=(key_path)
-      ssl_context.key = OpenSSL::PKey::RSA.new(File.read(key_path))
+    def on_suback=(callback)
+      @handler.on_suback = callback if callback.is_a?(Proc)
     end
 
-    def root_ca=(ca_path)
-      ssl_context.ca_file = ca_path
-      unless @ca_path.nil?
-        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      end
+    def on_unsuback=(callback)
+      @handler.on_unsuback = callback if callback.is_a?(Proc)
     end
 
-    def setup_connection
-      @mqtt_thread.kill unless @mqtt_thread.nil? 
-      if @host.nil? || @host == ""
-        @logger.error("The host was found as nil while the connection setup.") if @logger.is_a?(Logger)
-        raise ParameterException
-      end
-
-      if @port.to_i <= 0
-        @logger.error("The port value is invalid (<= 0). Could not setup the connection.") if @logger.is_a?(Logger)
-        raise ParameterException
-      end
-
-       @socket.close unless @socket.nil? || @socket.closed?
-       @socket = nil
-
-       @last_ping_req = Time.now
-       @last_ping_resp = Time.now
-
-       @logger.debug("Atempt to connect to host: #{@host}") if @logger.is_a?(Logger)
-       config_socket
-
-       unless @socket.nil?
-         send_connect
-
-         # Waiting a Connack packet for "ack_timeout" second from the remote
-         connect_timeout = Time.now + @ack_timeout
-         while (Time.now <= connect_timeout) && (!connected?) do
-           receive_packet
-           sleep 0.0001
-         end
-       end
-
-       unless connected?
-         @logger.warn("Connection failed. Couldn't recieve a Connack packet from: #{@host}, socket is \"#{@socket}\".") if @logger.is_a?(Logger)
-         unless Thread.current == @reconnect_thread
-           raise Exception.new("Connection failed. Check log for more details.")
-         end
-       else
-         config_subscription if Thread.current == @reconnect_thread
-       end
+    def on_puback=(callback)
+      @handler.on_puback = callback if callback.is_a?(Proc)
     end
 
-    def check_keep_alive
-      if @keep_alive >= 0 && connected?
-        now = Time.now
-        timeout_req = (@last_ping_req + (@keep_alive * 0.7).ceil)
-
-        if timeout_req <= now && @persistent
-          send_pingreq
-          @last_ping_req = now
-        end
-
-        timeout_resp = @last_ping_resp + (@keep_alive * 1.1).ceil
-        if timeout_resp <= now
-          @logger.debug("No activity period over timeout, disconnecting from #{@host}") if @logger.is_a?(Logger)
-          disconnect(false)
-          reconnect if @persistent
-        end
-      end
+    def on_pubrec=(callback)
+      @handler.on_pubrec = callback if callback.is_a?(Proc)
     end
 
-    def check_ack_alive(queue, mutex, max_packet)
-      mutex.synchronize {
-        now = Time.now
-        cnt = 0
-        queue.each do |pck|
-          if now >= pck[:timestamp] + @ack_timeout
-            pck[:packet].dup ||= true unless pck[:packet].class == PahoMqtt::Packet::Subscribe || pck[:packet].class == PahoMqtt::Packet::Unsubscribe
-            unless cnt > max_packet
-              append_to_writing(pck[:packet]) 
-              pck[:timestamp] = now
-              cnt += 1
-            end
-          end
-        end
-      }
+    def on_pubrel=(callback)
+      @handler.on_pubrel = callback if callback.is_a?(Proc)
     end
 
-    def receive_packet
-      begin
-        result = IO.select([@socket], [], [], SELECT_TIMEOUT) unless @socket.nil? || @socket.closed?
-        unless result.nil?
-          packet = PahoMqtt::Packet::Base.read(@socket)
-          unless packet.nil?
-            handle_packet packet
-            @last_ping_resp = Time.now
-          end
-        end
-      rescue ::Exception => exp
-        disconnect(false)
-        if @persistent
-          reconnect
-        else
-          @logger.error("The packet reading have failed.") if @logger.is_a?(Logger)
-          raise(exp)
-        end
-      end
+    def on_pubcomp=(callback)
+      @handler.on_pubcomp = callback if callback.is_a?(Proc)
     end
 
-    def handle_packet(packet)      
-      @logger.info("New packet #{packet.class} recieved.") if @logger.is_a?(Logger)
-      if packet.class == PahoMqtt::Packet::Connack
-        handle_connack(packet)
-      elsif packet.class == PahoMqtt::Packet::Suback
-        handle_suback(packet)
-      elsif packet.class == PahoMqtt::Packet::Unsuback
-        handle_unsuback(packet)
-      elsif packet.class == PahoMqtt::Packet::Publish
-        handle_publish(packet)
-      elsif packet.class == PahoMqtt::Packet::Puback
-        handle_puback(packet)
-      elsif packet.class == PahoMqtt::Packet::Pubrec
-        handle_pubrec(packet)
-      elsif packet.class == PahoMqtt::Packet::Pubrel
-        handle_pubrel(packet)
-      elsif packet.class == PahoMqtt::Packet::Pubcomp
-        handle_pubcomp(packet)
-      elsif packet.class == PahoMqtt::Packet::Pingresp
-        handle_pingresp
-      else
-        @logger.error("The packets header is invalid for packet: #{packet}") if @logger.is_a?(Logger)
-        raise PacketException
-      end
+    def on_message=(callback)
+      @handler.on_message = callback if callback.is_a?(Proc)
     end
 
-    def handle_connack(packet)
-      if packet.return_code == 0x00
-        @logger.debug("Connack receive and connection accepted.") if @logger.is_a?(Logger)
-        if @clean_session && !packet.session_present
-          @logger.debug("New session created for the client") if @logger.is_a?(Logger)
-        elsif !@clean_session && !packet.session_present
-          @logger.debug("No previous session found by server, starting a new one.") if @logger.is_a?(Logger)
-        elsif !@clean_session && packet.session_present
-          @logger.debug("Previous session restored by the server.") if @logger.is_a?(Logger)
-        end
-        @connection_state_mutex.synchronize{
-          @connection_state = MQTT_CS_CONNECTED
-        }
-      else
-        disconnect(false)
-        handle_connack_error(packet.return_code)
-      end
-      config_all_message_queue
-      @writing_mutex.synchronize {
-        @writing_queue.each do |m|
-          send_packet(m)
-        end
-      }
-      @on_connack.call(packet) unless @on_connack.nil?
+    def registered_callback
+      @handler.registered_callback
     end
 
-    def handle_pingresp
-      @last_ping_resp = Time.now
+    def subscribed_topics
+      @subscriber.subscribed_topics
     end
 
-    def handle_suback(packet)
-      adjust_qos = []
-      max_qos = packet.return_codes
-      @suback_mutex.synchronize {
-        adjust_qos, @waiting_suback = @waiting_suback.partition { |pck| pck[:id] == packet.id }
-      }
-      if adjust_qos.length == 1
-        adjust_qos = adjust_qos.first[:packet].topics
-        adjust_qos.each do |t|
-          if [0, 1, 2].include?(max_qos[0])
-            t[1] = max_qos.shift
-          elsif max_qos[0] == 128
-            adjust_qos.delete(t)
-          else
-            @logger.error("The qos value is invalid in subscribe.") if @logger.is_a?(Logger)
-            raise PacketException
-          end
-        end
-      else
-        @logger.error("The packet id is invalid, already used.") if @logger.is_a?(Logger)
-        raise PacketException
-      end
-      @subscribed_mutex.synchronize {
-        @subscribed_topics.concat(adjust_qos)
-      }
-      @on_suback.call(adjust_qos) unless @on_suback.nil?
-    end
 
-    def handle_unsuback(packet)
-      to_unsub = nil
-      @unsuback_mutex.synchronize {
-        to_unsub, @waiting_unsuback = @waiting_unsuback.partition { |pck| pck[:id] == packet.id }
-      }
-      
-      if to_unsub.length == 1
-        to_unsub = to_unsub.first[:packet].topics
-      else
-        @logger.error("The packet id is invalid, already used.") if @logger.is_a?(Logger)
-        raise PacketException
-      end
+    private
 
-      @subscribed_mutex.synchronize {
-        to_unsub.each do |filter|
-          @subscribed_topics.delete_if { |topic| match_filter(topic.first, filter.first) }
-        end
+    def next_packet_id
+      @id_mutex.synchronize {
+        @last_packet_id = ( @last_packet_id || 0 ).next
       }
-      @on_unsuback.call(to_unsub) unless @on_unsuback.nil?
     end
 
-    def handle_publish(packet)
-      case packet.qos
-      when 0
-      when 1
-        send_puback(packet.id)
-      when 2
-        send_pubrec(packet.id)
+    def downgrade_version
+      PahoMqtt.logger.debug("Unable to connect to the server with the version #{@mqtt_version}, trying 3.1") if PahoMqtt.logger?
+      if @mqtt_version != "3.1"
+        @mqtt_version = "3.1"
+        connect(@host, @port, @keep_alive)
       else
-        @logger.error("The packet qos value is invalid in publish.") if @logger.is_a?(Logger)
-        raise PacketException
+        raise "Unsupported MQTT version"
       end
-
-      @on_message.call(packet) unless @on_message.nil?
-      @registered_callback.assoc(packet.topic).last.call(packet) if @registered_callback.any? { |pair| pair.first == packet.topic}
-    end
-
-    def handle_puback(packet)
-      @puback_mutex.synchronize{
-        @waiting_puback.delete_if { |pck| pck[:id] == packet.id }
-      }
-      @on_puback.call(packet) unless @on_puback.nil?
-    end
-
-    def handle_pubrec(packet)
-      @pubrec_mutex.synchronize {
-        @waiting_pubrec.delete_if { |pck| pck[:id] == packet.id }
-      }
-      send_pubrel(packet.id)
-      @on_pubrec.call(packet) unless @on_pubrec.nil?
     end
 
-    def handle_pubrel(packet)
-      @pubrel_mutex.synchronize {
-        @waiting_pubrel.delete_if { |pck| pck[:id] == packet.id }
-      }
-      send_pubcomp(packet.id)
-      @on_pubrel.call(packet) unless @on_pubrel.nil?
-    end
-
-    def handle_pubcomp(packet)
-      @pubcomp_mutex.synchronize {
-        @waiting_pubcomp.delete_if { |pck| pck[:id] == packet.id }
-      }
-      @on_pubcomp.call(packet) unless @on_pubcomp.nil?
-    end
-    
-    def handle_connack_error(return_code)
-      case return_code
-      when 0x01
-        @logger.debug("Unable to connect to the server with the version #{@mqtt_version}, trying 3.1") if @logger.is_a?(Logger)
-        if @mqtt_version != "3.1"
-          @mqtt_version = "3.1"
-          connect(@host, @port, @keep_alive)
-        end
-      when 0x02
-        @logger.warn("Client Identifier is correct but not allowed by remote server.") if @logger.is_a?(Logger)
-        MQTT_ERR_FAIL
-      when 0x03
-        @logger.warn("Connection established but MQTT service unvailable on remote server.") if @logger.is_a?(Logger)
-        MQTT_ERR_FAIL
-      when 0x04
-        @logger.warn("User name or user password is malformed.") if @logger.is_a?(Logger)
-        MQTT_ERR_FAIL
-      when 0x05
-        @logger.warn("Client is not authorized to connect to the server.") if @logger.is_a?(Logger)
-        MQTT_ERR_FAIL
-      end
-    end
-
-    def send_packet(packet)
-      begin
-          @socket.write(packet.to_s) unless @socket.nil? || @socket.closed?
-          @logger.info("A packet #{packet.class} have been sent.") if @logger.is_a?(Logger)
-          @last_ping_req = Time.now
-          MQTT_ERR_SUCCESS
-      rescue ::Exception => exp
-        disconnect(false)
-        if @persistent
-          reconnect
-        else
-          @logger.error("Trying to right a packet on a nil socket.") if @logger.is_a?(Logger)
-          raise(exp)
-        end
-      end
-    end
-    
-    def append_to_writing(packet)
-      @writing_mutex.synchronize {
-        @writing_queue.push(packet)
-      }
-      MQTT_ERR_SUCCESS
-    end
-
-    def send_connect
-      packet = PahoMqtt::Packet::Connect.new(
-        :version => @mqtt_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(packet)
-      MQTT_ERR_SUCCESS
-    end
-
-    def send_disconnect
-      packet = PahoMqtt::Packet::Disconnect.new
-      send_packet(packet)
-      MQTT_ERR_SUCCESS
-    end
-
-    def send_pingreq
-      packet = PahoMqtt::Packet::Pingreq.new
-      @logger.debug("Checking if server is still alive.") if @logger.is_a?(Logger)
-      send_packet(packet)
-      MQTT_ERR_SUCCESS
-    end
-
-    def send_subscribe(topics)
-      unless valid_topics?(topics) == MQTT_ERR_FAIL
-        new_id = next_packet_id
-        packet = PahoMqtt::Packet::Subscribe.new(
-          :id => new_id,
-          :topics => topics
-        )        
-        append_to_writing(packet)
-        @suback_mutex.synchronize {
-          @waiting_suback.push({ :id => new_id, :packet => packet, :timestamp => Time.now })
-        }
-        MQTT_ERR_SUCCESS
+    def build_pubsub
+      if @subscriber.nil?
+        @subscriber = Subscriber.new(@sender)
       else
-        disconnect(false)
-        raise ProtocolViolation
+        @subscriber.sender = @sender
+        @subscriber.config_subscription(next_packet_id)
       end
-    end
-
-    def send_unsubscribe(topics)
-      unless valid_topics?(topics) == MQTT_ERR_FAIL
-        new_id = next_packet_id
-        packet = PahoMqtt::Packet::Unsubscribe.new(
-          :id => new_id,
-          :topics => topics
-        )
-
-        append_to_writing(packet)
-        @unsuback_mutex.synchronize {
-          @waiting_unsuback.push({:id => new_id, :packet => packet, :timestamp => Time.now})
-        }
-        MQTT_ERR_SUCCESS
+      if @publisher.nil?
+        @publisher = Publisher.new(@sender)
       else
-        disconnect(false)
-        raise ProtocolViolation
+        @publisher.sender = @sender
+        @publisher.config_all_message_queue
       end
+      @handler.config_pubsub(@publisher, @subscriber)
+      @sender.flush_waiting_packet(true)
     end
 
-    def send_publish(topic, payload, retain, qos)
-      new_id = next_packet_id
-      packet = PahoMqtt::Packet::Publish.new(
-        :id => new_id,
-        :topic => topic,
-        :payload => payload,
-        :retain => retain,
-        :qos => qos
-      )
-
-      append_to_writing(packet)
-
-      case qos
-      when 1
-        @puback_mutex.synchronize{
-          @waiting_puback.push({:id => new_id, :packet => packet, :timestamp => Time.now})
-        }
-      when 2
-        @pubrec_mutex.synchronize{
-          @waiting_pubrec.push({:id => new_id, :packet => packet, :timestamp => Time.now})
-        }
+    def init_connection
+      unless reconnect?
+        @connection_helper = ConnectionHelper.new(@host, @port, @ssl, @ssl_context, @ack_timeout)
+        @connection_helper.handler = @handler
+        @sender = @connection_helper.sender
       end
-      MQTT_ERR_SUCCESS
+        @connection_helper.setup_connection
     end
 
-    def send_puback(packet_id)
-      packet = PahoMqtt::Packet::Puback.new(
-        :id => packet_id
-      )
-
-      append_to_writing(packet)
-      MQTT_ERR_SUCCESS
-    end
-
-    def send_pubrec(packet_id)
-      packet = PahoMqtt::Packet::Pubrec.new(
-        :id => packet_id
-      )
-
-      append_to_writing(packet)
-      
-      @pubrel_mutex.synchronize{
-        @waiting_pubrel.push({:id => packet_id , :packet => packet, :timestamp => Time.now})
-      }
-      MQTT_ERR_SUCCESS
+    def session_params
+      {:version => @mqtt_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}
     end
-    
-    def send_pubrel(packet_id)
-      packet = PahoMqtt::Packet::Pubrel.new(
-        :id => packet_id
-      )
-
-      append_to_writing(packet)
-      
-      @pubcomp_mutex.synchronize{
-        @waiting_pubcomp.push({:id => packet_id, :packet => packet, :timestamp => Time.now})
-      }
-      MQTT_ERR_SUCCESS
-    end
-
-    def send_pubcomp(packet_id)
-      packet = PahoMqtt::Packet::Pubcomp.new(
-        :id => packet_id
-      )
 
-      append_to_writing(packet)
-      MQTT_ERR_SUCCESS
-    end
-
-    def valid_topics?(topics)
-      unless topics.length == 0
-        topics.map do |topic|
-          return MQTT_ERR_FAIL if topic.first == ""
-        end
-      else
-        MQTT_ERR_FAIL
-      end
-      MQTT_ERR_SUCCESS
-    end
-
-    def match_filter(topics, filters)
-      if topics.is_a?(String) && filters.is_a?(String)
-        topic = topics.split('/')
-        filter = filters.split('/')
-      else
-        @logger.error("Topics and filters are not found as String while matching topics to filter.") if @logger.is_a?(Logger)
-        raise ParameterException
-      end
-      
-      rc = false
-      index = 0
-      
-      while index < [topic.length, filter.length].max do
-        if topic[index].nil? || filter[index].nil?
-          break
-        elsif filter[index] == '#' && index == (filter.length - 1) 
-          rc = true
-          break
-        elsif filter[index] == topic[index] || filter[index] == '+'
-          index = index + 1
-        else
-          break
-        end
-      end
-      rc ||= (index == [topic.length, filter.length].max)
+    def check_persistence
+      disconnect(false)
+      @persistent
     end
   end
 end