paho-mqtt 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f334ef3126b1f0def40579e6f202200d3dacfc3
-  data.tar.gz: 9ef4eb0748507a6b744f82011a9da894f909624e
+  metadata.gz: 16c0a069f566b0c91b896cbcc0a4b3ca2eb694f6
+  data.tar.gz: bd03230d51b7bc37be071caac903ce8537073b6b
 SHA512:
-  metadata.gz: 412649a90228d742ba6812d77924f74559d759199ed1258f9095a9b1e80d759979bc0ceb64065cf11d73a6c4b1b9294102ccd690b7c9ca2d42f695d3c29b86b5
-  data.tar.gz: 3533ef2b3774a816a66827341a14aebd4d70534cf08888881ac619f072b9aa09ab7700cc28ba406a8bcffe0a9f3bdf02e66d8c045289a386d31ef2930b6734a3
+  metadata.gz: 0c3a8a75de74ef2df07b3e6df1abcf694e07dd425e589169a8c7696e8131b55aba92b41daf6525e60ef3210347f33139ea399eb8092877dedc40c6f986b022e5
+  data.tar.gz: 53e67740ea1e52c1a0e73517079d1b7b0ce1f15802ea22f9a880a00ba2e514b7e715e7a06b293931e1a561cbd2beb2dd8439dee906a6fdfbc183c13f0ce7f87c

data/README.md

@@ -1,8 +1,30 @@
 # PahoMqtt
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/PahoMqttRuby`. To experiment with that code, run `bin/console` for an interactive prompt.
+The following file describes the Paho Mqtt client API for the ruby programming language. It enables applications to connect to an MQTT message broker threw the [MQTT](http://mqtt.org/) protocol (versions 3.1.1). MQTT is a lightweight protocol designed for IoT/M2M. A Mqtt client can connect to a message broker in order to publish and received data contained in short messages. The messages are exchanged on topics where the client has to subscribe for receiving message.
 
-TODO: Delete this and the text above, and describe your gem
+## Contents
+* [Installation](#installation)
+* [Usage](#usage)
+  * [Getting started](#getting-started)
+* [Client](#client)
+  * [Initialization](#initialization)
+  * [Client's parameters](#clients-parameter)
+  * [Subscription](#subscription)
+  * [Publishing](#publishing)
+* [Connection configuration](#connection-configuration)
+  * [Unencrypted mode](#unencrypted-mode)
+  * [Encrypted mode](#encrypted-mode)
+  * [Persistence](#persistence)
+  * [Foreground and Daemon](#foreground-and-daemon)
+* [Control loops](#control-loops)
+  * [Reading loop](#reading-loop)
+  * [Writing loop](#writing-loop)
+  * [Miscellaneous loop](#miscellaneous-loop)
+* [Handlers and Callbacks](#handlers-and-callbacks)
+  * [Handlers](#handlers)
+  * [Callbacks](#callbacks)
+* [Mosquitto (message broker)](#mosquitto-message-broker)
+* [Thanks](#thanks)
 
 ## Installation
 
@@ -22,20 +44,277 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Getting started
+The following samples files cover the main features of the client:
+```ruby
+require 'paho-mqtt'
+
+### Create a simple client with default attributes
+client = PahoMqtt::Client.new
+
+### Register a callback on message event to display messages
+message_counter = 0
+client.on_message do |message|
+  puts "Message recieved on topic: #{message.topic}\n>>> #{message.payload}"
+  message_counter += 1
+end
+
+### Register a callback on suback to assert the subcription
+waiting_suback = true
+client.on_suback do
+  waiting_suback = false
+  puts "Subscribed"
+end
+
+### Register a callback for puback event when receiving a puback
+waiting_puback = true
+client.on_puback do
+  waiting_puback = false
+  puts "Message Acknowledged"
+end
+
+### Connect to the eclipse test server on port 1883 (Unencrypted mode)
+client.connect('iot.eclipse.org', 1883)
+
+### Subscribe to a topic
+client.subscribe(['/paho/ruby/test', 2])
+
+### Waiting for the suback answer and excute the previously set on_suback callback
+while waiting_suback do
+  sleep 0.001
+end
+
+### Publlish a message on the topic "/paho/ruby/test" with "retain == false" and "qos == 1"
+client.publish("/paho/ruby/test", "Hello there!", false, 1)
+
+while waiting_puback do
+  sleep 0.001
+end
+
+### Waiting to assert that the message is displayed by on_message callback
+sleep 1
+
+### Calling an explicit disconnect
+client.disconnect
+```
+
+## Client
+### Initialization
+The client may be initialized without paramaeters or with a hash of parameters. The list of client's accessor is details in the next parts. A client id would be generated if not provided, a default port would be also set (8883 if ssl set, else 1883).
+```ruby
+client = PahoMqtt::Client.new
+# Or
+client = PahoMqtt::Client.new({host: "iot.eclispe.org", port: 1883, ssl: false})
+```
+
+### Client's parameters
+The client has many accessors which help to configure the client depending on user's need. The different accessors could be splited in four roles, connection setup, last will setup, time-out setup and callback setup.
+Connection setup:
+```
+* host          : The endpoint where the client would try to connect (defaut "")
+* port          : The port on the remote host where the socket would try to connect (default 1883)
+* mqtt_version  : The version of MQTT protocol used to communication (default 3.1.1)
+* clean_session : If set to false, ask the message broker to try to restore the previous session (default true)
+* persistent    : Keep the client connected even after keep alive timer run out, automatically try to reconnect on failure (default false)
+* client_id     : The identifier of the client (default nil)
+* username      : The username if the server require authentication (default nil)
+* password      : The password of the user if authentication required (default nil)
+* ssl           : Requiring the encryption for the communication (default false)
+```
 
-## Development
+Last Will:
+```
+* will_topic   : The topic where to publish the last will (default nil)
+* will_payload : The message of the last will (default "")
+* will_qos     : The qos of the last will (default 0)
+* will_retain  : The retain status of the last will (default false)
+```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Timers:
+```
+* keep_alive  : The reference timer after which the client should decide to keep the connection alive or not
+* ack_timeout : The timer after which a non-acknowledged packet is considered as a failure
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+The description of the callback accessor is detailed in the section dedicated to the callbacks. The client also have three read only attributes which provide information on the client state.
+```
+* registered_callback : The list of topics where callback have been registred which the associated callback
+* subscribed_topics   : The list of the topics where the client is currentely receiving publish.
+* connection_state    : The current state of the connection between the message broker and the client
+```
 
-## Contributing
+### Subscription
+In order to read a message sent on a topic, the client should subscribe to this topic. The client enables to subscribe to several topics in the same subscribe request. The subscription could also be done by using a wild-card, see more details on [MQTT protocol specifications](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html). Each topic is subscribed with a maximum qos level, only message with a qos level lower or equal to this value would be forwarded to the client. The subscribe command accepts one or several pair, each pair is composed by the topic (or wild-card) and the maximum qos level.  
+```ruby
+### Subscribe to two topics with maximum qos associated
+client.subscribe(["/foo/bar", 1], ["/foo/foo/", 2])
+```
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/PahoMqttRuby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+The subscription is persistent, in case of an unexpected disconnecting, the current subscription state is saved and a new subscribe request is sent to the message broker.
 
+### Publishing
+User data could be sent to the message broker with the publish operation. A publish operation requires a topic, and payload (user data), two other parameters may be configured, retain and qos. The retain flag tell to the message broker to keep the current publish packet, see the [MQTT protocol specifications](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html) for more details about retain. The qos enable different levels of control on the transmission of publish package. The PahoMqtt client supports the three levels of qos (0, 1 and 2), see the [MQTT protocol specifications](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html) for qos level details. The default retain value is False and the qos level is 0.
+```ruby
+### Publish to the topics "/foo/bar", with qos = 1 and no retain
+client.publish("/foo/bar", "Hello Wourld!", false, 1)
+```
+
+## Connection configuration
+### Unencrypted mode
+The most simple connection way is the unencrypted mode. All data would be sent clearly to the message broker, also it might not be safe for sensitive data. The connect method may set up or override some parameters of the client, the host, the port, the keep_alive timer, the persistence mode and blocking mode.
+```ruby
+### Simply connect to the message broker with default value or pre-set value
+client.connect
+# Or
+### Connect to the message broker with all parameter
+client.connect("iot.eclipse.org", 1883, client.keep_alive, client.persistent, client.blocking)
+```
+
+### Encrypted mode
+The client supports the encrypted connection threw tls-ssl socket. In order to use encrypted mode, the ssl flag of the client should be set to True.   
+``` ruby
+### Set the encryption mode to True
+client.ssl = true
+### Configure the user SSL key and the certificate
+client.config_ssl_context(certificate_path, key_path)
+client.connect("test.mosquitto.org", 8883)
+### Or if rootCA is needed
+client.config_ssl_context(certificate_path, key_path, rootCA_path)
+client.connect("test.mosquitto.org", 8884)
+```
+
+### Persistence
+The client holds a keep_alive timer is the reference time that the connection should be held. The timer is reset every time a new valid packet is received from the message broker. The persistence flag, when set to True, enables the client to be more independent from the keep_alive timer. Just before the keep_alive run out, the client sends a ping request to tell to the message broker that the connection should be kept. The persistent mode also enables the client to automatically reconnect to the message broker after an unexpected failure.  
+When the client's persistence flag is set to False, it just simply disconnects when the keep_alive timer runs out.  
+
+```ruby
+### This will connect to the message broker, keep connected and automatically reconnect on failure
+client.connect('iot.eclipse.org', 1883, client.keep_alive, true, client.blocking)
+#Or
+### This only connect to the message broker, disconnect after keep_alive or on failure
+client.connect('iot.eclipse.org', 1883, client.keep_alive, false, client.blocking)
+```
 
-## License
+### Foreground and Daemon
+The client could be connected to the message broker using the main thread in foreground or as a daemon in a separate thread. The default mode is daemon mode, the daemon would run in the background the read/write operation as well as the control of the timers. If the client is connected using the main thread, all control operations are left to the user, using the different control loops. There are four different loop roles is detailed in the next part.
+
+```ruby
+### Connect to the message broker executing the mqtt_loop (socket reading/writing) in the background
+client.connect('iot.eclipse.org', 1883, client.keep_alive, client.persistence, true)
+#Or
+### This only connect to the message broker, nothing more
+client.connect('iot.eclipse.org', 1883, client.keep_alive, client.persistence, false)
+```
+
+## Control loops
+/!\ The control loops should not be used in a daemon mode.  
+They are automatically run in separate thread and execute the necessary operations for reading, writing and checking the connection state.
+
+### Reading loop
+The reading loop provides access to the socket in a reading mode. Periodically, the socket would be inspected to try to find a mqtt packet. The read loop accepts a parameter, which is the number of loop's turn. The default value is five turns.  
+The default value is defined in the PahoMqtt module as the constant PahoMqtt::MAX_READ, another module constant could be modified to control the socket inspection period. The referring constant is SELECT_TIMEOUT (PahoMqtt::SELECT_TIMEOUT) and its default value is 0.  
+```ruby
+### Trying to read 'max_packet' packets from the client socket
+client.loop_read(max_packet)
+```
+
+### Writing loop
+The writing loop send the packets which have previously been stacked by MQTT operations. This loop also accepts a parameter, which is the maximum packets number that could be written as the MAX_WRITING constant (PahoMqtt::MAX_WRITING). The writing loop exit if the maximum number of packet have been sent or if the waiting packet queue is empty.
+```ruby
+### Writing 'max_packet' packets to the client socket
+client.loop_write(max_packet)
+```
+
+### Miscellaneous loop
+The misc loop performs different control operations, modifying the packets states and the connection state. The misc loop parses the different queue of packet that are waiting for an acknowledgement. If the ack_timeout of a packet had run out, the packet is re-sent. The size of the different waiting queues is defined as module constants. This loop also asserts that the connection is still available by checking the keep_alive timer.
+```ruby
+### Perfom control operations on packets queues and connection
+client.loop_misc
+```
+
+## Handlers and Callbacks
+### Handlers
+When a packet is received and inspected, an appropriate handler is called. The handler performs different control operation such as update the connection state, update the subscribed topics, and send publish control packets. Each packet has a specific handler, except the pingreq/pingresp packet. Before returning the handler executes a callback, if the user has configured one for this type of packet. The publish handler may execute sequentially two callbacks. One callback for the reception of a generic publish packet and another one, if the user has configured a callback for the topic where the publish packet has been received.  
+
+### Callbacks
+The callbacks could be defined in a three different ways, as block, as Proc or as Lambda. The callback has access to the packet which triggered it.  
+```ruby
+### Register a callback trigger on the reception of a CONNACK packet
+client.on_connack = proc { puts "Successfully Connected" }
+
+### Register a callback trigger on the reception of PUBLISH packet
+client.on_message do |packet|
+  puts "New message received on topic: #{packet.topic}\n>>>#{packet.payload}"
+end
+```
+
+A callback could be configured for every specific topics. The list of topics where a callbacks have been registered could be read at any time, threw the registered_callback variable. The following example details how to manage callbacks for specific topics.  
+```ruby
+### Add a callback for every message received on /foo/bar
+specific_callback = lambda { |packet| puts "Specific callback for #{packet.topic}" }
+client.add_topic_callback("/foo/bar", specific_callback)
+# Or
+client.add_topic_callback("/foo/bar") do |packet|
+  puts "Specific callback for #{packet.topic}"
+end
+
+### To remove a callback form a topic
+client.remove_topic_callback("/foo/bar")
+```
+
+## Mosquitto (message broker)
+Mosquitto is a message broker support by Eclipse, which is quite easy-going. In order to run spec or samples files, a message broker is needed. Mosquitto enable to run locally a message broker, it could be configured with the mosquitto.conf files.
+### Install mosquitto
+#### OSX (homebrew)
+```
+$ brew install mosquitto
+```
+### Run mosquitto
+#### Default mode
+The default mode of mosquitto is unencrypted, listening on the port 1883.
+```
+ $ mosquitto
+```
+
+#### Encrypted mode
+In order to successfully pass the spec, or for testing in encrypted mode, some configurations are needed on mosquitto. Private keys and certificates should be set on both client side and server side. The [mosquitto-tls](https://mosquitto.org/man/mosquitto-tls-7.html) page might help you create all the required credentials. Once the credentials are created, the mosquitto's config files should be updated as following.
+
+```
+$ cp mosquitto.conf samples-mosquitto.conf
+$ nano mosquitto.conf
+```
+
+The following file enables the broker to support the unencrypted mode (default) on port 1883, and the encrypted mode on port 8883. Update the path variable with the file's location on your environment. 
+```
+### mosquitto.conf
+# =================================================================
+# General configuration
+# =================================================================
+.
+.
+.
+# =================================================================
+# Extra listeners
+# =================================================================
+.
+.
+listener 8883
+.
+.
+cafile   "Path to the certificate authorithy certificate file"
+certfile "Path to the server certificate file"
+keyfile  "Path to the server private keys file"
+.
+.
+.
+```
+Finally run the server with the updated configuration file.
+
+```
+$ mosquitto -c mosquitto.conf
+```
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+See [Mosquitto message broker page](https://mosquitto.org/) for more details.
 
+## Thanks
+Special thanks to [Nicholas Humfrey](https://github.com/njh) for providing a great help with the packet serializer/deserializer.

data/lib/paho-mqtt.rb

@@ -1,9 +1,8 @@
-require "paho.mqtt/version"
-require "paho.mqtt/paho_client"
-require "paho.mqtt/packet_manager"
+require "paho_mqtt/version"
+require "paho_mqtt/client"
+require "paho_mqtt/packet"
 
 module PahoMqtt
-
   # Default connection setup
   DEFAULT_SSL_PORT = 8883
   DEFAULT_PORT = 1883
@@ -13,24 +12,43 @@ module PahoMqtt
   RECONNECT_RETRY_TEMPO = 5
 
   # MAX size of queue
+  MAX_READ = 10
   MAX_PUBACK = 20
   MAX_PUBREC = 20
   MAX_PUBREL = 20
   MAX_PUBCOMP = 20
   MAX_WRITING = MAX_PUBACK + MAX_PUBREC + MAX_PUBREL  + MAX_PUBCOMP 
-    
+
   # Connection states values
   MQTT_CS_NEW = 0
   MQTT_CS_CONNECTED = 1
   MQTT_CS_DISCONNECT = 2
-  MQTT_CS_CONNECT_ASYNC = 3
-  
+
   # Error values
   MQTT_ERR_SUCCESS = 0
   MQTT_ERR_FAIL = 1
 
+  PACKET_TYPES = [
+    nil,
+    PahoMqtt::Packet::Connect,
+    PahoMqtt::Packet::Connack,
+    PahoMqtt::Packet::Publish,
+    PahoMqtt::Packet::Puback,
+    PahoMqtt::Packet::Pubrec,
+    PahoMqtt::Packet::Pubrel,
+    PahoMqtt::Packet::Pubcomp,
+    PahoMqtt::Packet::Subscribe,
+    PahoMqtt::Packet::Suback,
+    PahoMqtt::Packet::Unsubscribe,
+    PahoMqtt::Packet::Unsuback,
+    PahoMqtt::Packet::Pingreq,
+    PahoMqtt::Packet::Pingresp,
+    PahoMqtt::Packet::Disconnect,
+    nil
+  ]
+
   Thread.abort_on_exception = true
-  
+
   class Exception < ::Exception
   end
 

data/lib/{paho.mqtt/paho_client.rb → paho_mqtt/client.rb}

@@ -12,6 +12,8 @@ module PahoMqtt
     attr_accessor :port
     attr_accessor :mqtt_version
     attr_accessor :clean_session
+    attr_accessor :persistent
+    attr_accessor :blocking
     attr_accessor :client_id
     attr_accessor :username
     attr_accessor :password
@@ -23,10 +25,9 @@ module PahoMqtt
     attr_accessor :will_qos
     attr_accessor :will_retain
 
-    # Setting attributes:
+    # Timeout attributes:
     attr_accessor :keep_alive
     attr_accessor :ack_timeout
-    attr_accessor :persistent
 
     #Callback attributes
     attr_accessor :on_message
@@ -50,6 +51,7 @@ module PahoMqtt
       :mqtt_version => '3.1.1',
       :clean_session => true,
       :persistent => false,
+      :blocking => false,
       :client_id => nil,
       :username => nil,
       :password => nil,
@@ -82,7 +84,12 @@ module PahoMqtt
       end
 
       if @port.nil?
-        @port = @ssl ? PahoMqtt::DEFAULT_SSL_PORT : PahoMqtt::DEFAULT_PORT
+        @port
+        if @ssl
+          @port = PahoMqtt::DEFAULT_SSL_PORT
+        else
+          @port = PahoMqtt::DEFAULT_PORT
+        end
       end
 
       if  @client_id.nil? || @client_id == ""
@@ -123,6 +130,10 @@ 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
@@ -130,25 +141,6 @@ module PahoMqtt
       self.key = key_path
       self.root_ca = ca_path
     end
-
-    def ssl_context
-      @ssl_context ||= OpenSSL::SSL::SSLContext.new
-    end
-
-    def cert=(cert_path)
-      ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
-    end
-
-    def key=(key_path, passphrase=nil)
-      ssl_context.key = OpenSSL::PKey::RSA.new(File.read(key_path), passphrase)
-    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
-    end
     
     def config_will(topic, payload="", retain=false, qos=0)
       @will_topic = topic
@@ -157,25 +149,31 @@ module PahoMqtt
       @will_qos = qos
     end
 
-    def connect(host=@host, port=@port, keep_alive=@keep_alive, persistent=@persistent)
+    def connect(host=@host, port=@port, keep_alive=@keep_alive, persistent=@persistent, blocking=@blocking)
       @persistent = persistent
-      @connection_state_mutex.synchronize {
-        @connection_state = MQTT_CS_NEW
-      }
-      connect_async(host, port, keep_alive)
-    end
-
-    def connect_async(host, port=1883, keep_alive)
+      @blocking = blocking
       @host = host
       @port = port.to_i
       @keep_alive = keep_alive
-
       @connection_state_mutex.synchronize {
-        @connection_state = MQTT_CS_CONNECT_ASYNC
+        @connection_state = MQTT_CS_NEW
       }
       setup_connection
+      connect_async(host, port, keep_alive) unless @blocking
     end
 
+    def connect_async(host, port=1883, keep_alive)
+      @mqtt_thread = Thread.new do
+        @reconnect_thread.kill unless @reconnect_thread.nil? || !@reconnect_thread.alive?
+        while connected? do
+          mqtt_loop
+        end
+      end
+    end
+
+    def connected?
+      @connection_state == MQTT_CS_CONNECTED
+    end
     
     def loop_write(max_packet=MAX_WRITING)
       @writing_mutex.synchronize {
@@ -187,12 +185,12 @@ module PahoMqtt
       }
     end
 
-    def loop_read(max_packet=5)
+    def loop_read(max_packet=MAX_READ)
       max_packet.times do
         receive_packet
       end
     end
-    
+
     def mqtt_loop
       loop_read
       loop_write
@@ -210,20 +208,19 @@ module PahoMqtt
       check_ack_alive(@waiting_unsuback, @unsuback_mutex, @waiting_unsuback.length)
     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)
-          setup_connection
-          if @connection_state == MQTT_CS_CONNECTED
+          connect
+          if connected?
             break
           else
             sleep retry_tempo
           end
         end
-        if @connection_state != MQTT_CS_CONNECTED
-          @logger.error("Reconnection atempt counter is over.(#{RECONNECT_RETRY_TIME} times)") if @logger.is_a?(Logger)
+        unless connected?
+        @logger.error("Reconnection atempt counter is over.(#{RECONNECT_RETRY_TIME} times)") if @logger.is_a?(Logger)
           disconnect(false)
           exit
         end
@@ -260,7 +257,7 @@ module PahoMqtt
         }
       end
 
-      @socket.close unless @socket.nil?
+      @socket.close unless @socket.nil? || @socket.closed?
       @socket = nil
 
       @connection_state_mutex.synchronize {
@@ -268,7 +265,7 @@ module PahoMqtt
       }
       MQTT_ERR_SUCCESS
     end
-    
+
     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)
@@ -278,7 +275,7 @@ module PahoMqtt
     end
 
     def subscribe(*topics)
-      unless topics.length == 0
+      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)
@@ -288,7 +285,7 @@ module PahoMqtt
     end
 
     def unsubscribe(*topics)
-      unless topics.length == 0
+      unless valid_topics?(topics) == MQTT_ERR_FAIL
         send_unsubscribe(topics)
       else
         @logger.error("Unsubscribe need at least one topics.") if @logger.is_a?(Logger)
@@ -300,7 +297,7 @@ module PahoMqtt
     def ping_host
       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)
@@ -411,7 +408,7 @@ module PahoMqtt
 
     def config_socket
       unless @socket.nil?
-        @socket.close
+        @socket.close unless @socket.closed?
         @socket = nil
       end
 
@@ -437,6 +434,21 @@ module PahoMqtt
       end
     end
 
+    def cert=(cert_path)
+      ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
+    end
+
+    def key=(key_path)
+      ssl_context.key = OpenSSL::PKey::RSA.new(File.read(key_path))
+    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
+    end
+
     def setup_connection
       @mqtt_thread.kill unless @mqtt_thread.nil? 
       if @host.nil? || @host == ""
@@ -449,44 +461,38 @@ module PahoMqtt
         raise ParameterException
       end
 
-       @socket.close unless @socket.nil?
+       @socket.close unless @socket.nil? || @socket.closed?
        @socket = nil
 
-      @last_ping_req = Time.now
-      @last_ping_resp = Time.now
+       @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
+       @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) && (@connection_state != MQTT_CS_CONNECTED) do
-          receive_packet
-          sleep 0.0001
-        end
-      end
+       unless @socket.nil?
+         send_connect
 
-      if @connection_state != MQTT_CS_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
-        @mqtt_thread = Thread.new do
-          @reconnect_thread.kill unless @reconnect_thread.nil? || !@reconnect_thread.alive?
-          while @connection_state == MQTT_CS_CONNECTED do
-            mqtt_loop
-          end
-        end
-      end
+         # 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
     end
 
     def check_keep_alive
-      if @keep_alive >= 0 && @connection_state == MQTT_CS_CONNECTED
+      if @keep_alive >= 0 && connected?
         now = Time.now
         timeout_req = (@last_ping_req + (@keep_alive * 0.7).ceil)
 
@@ -497,7 +503,7 @@ module PahoMqtt
 
         timeout_resp = @last_ping_resp + (@keep_alive * 1.1).ceil
         if timeout_resp <= now
-          @logger.debug("No activity over timeout, trying to reconnect to #{@host}") if @logger.is_a?(Logger)
+          @logger.debug("No activity period over timeout, disconnecting from #{@host}") if @logger.is_a?(Logger)
           disconnect(false)
           reconnect if @persistent
         end
@@ -523,9 +529,9 @@ module PahoMqtt
 
     def receive_packet
       begin
-        result = IO.select([@socket], [], [], SELECT_TIMEOUT) unless @socket.nil?
+        result = IO.select([@socket], [], [], SELECT_TIMEOUT) unless @socket.nil? || @socket.closed?
         unless result.nil?
-          packet = PahoMqtt::Packet.read(@socket)
+          packet = PahoMqtt::Packet::Base.read(@socket)
           unless packet.nil?
             handle_packet packet
             @last_ping_resp = Time.now
@@ -591,7 +597,7 @@ module PahoMqtt
           send_packet(m)
         end
       }
-      @on_connack.call unless @on_connack.nil?
+      @on_connack.call(packet) unless @on_connack.nil?
     end
 
     def handle_pingresp
@@ -623,7 +629,7 @@ module PahoMqtt
       @subscribed_mutex.synchronize {
         @subscribed_topics.concat(adjust_qos)
       }
-      @on_suback.call unless @on_suback.nil?
+      @on_suback.call(adjust_qos) unless @on_suback.nil?
     end
 
     def handle_unsuback(packet)
@@ -641,10 +647,10 @@ module PahoMqtt
 
       @subscribed_mutex.synchronize {
         to_unsub.each do |filter|
-          @subscribed_topics.delete_if { |topic| match_filter(topic.first, filter) }
+          @subscribed_topics.delete_if { |topic| match_filter(topic.first, filter.first) }
         end
       }
-      @on_unsuback.call unless @on_unsuback.nil?
+      @on_unsuback.call(to_unsub) unless @on_unsuback.nil?
     end
 
     def handle_publish(packet)
@@ -660,14 +666,14 @@ module PahoMqtt
       end
 
       @on_message.call(packet) unless @on_message.nil?
-      @registered_callback.assoc(packet.topic).last.call if @registered_callback.any? { |pair| pair.first == packet.topic}
+      @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 unless @on_puback.nil?
+      @on_puback.call(packet) unless @on_puback.nil?
     end
 
     def handle_pubrec(packet)
@@ -675,7 +681,7 @@ module PahoMqtt
         @waiting_pubrec.delete_if { |pck| pck[:id] == packet.id }
       }
       send_pubrel(packet.id)
-      @on_pubrec.call unless @on_pubrec.nil?
+      @on_pubrec.call(packet) unless @on_pubrec.nil?
     end
 
     def handle_pubrel(packet)
@@ -683,14 +689,14 @@ module PahoMqtt
         @waiting_pubrel.delete_if { |pck| pck[:id] == packet.id }
       }
       send_pubcomp(packet.id)
-      @on_pubrel.call unless @on_pubrel.nil?
+      @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 unless @on_pubcomp.nil?
+      @on_pubcomp.call(packet) unless @on_pubcomp.nil?
     end
     
     def handle_connack_error(return_code)
@@ -715,15 +721,24 @@ module PahoMqtt
         MQTT_ERR_FAIL
       end
     end
-    
+
     def send_packet(packet)
-      @socket.write(packet.to_s)
-      @logger.info("A packet #{packet.class} have been sent.") if @logger.is_a?(Logger)
-      @last_ping_req = Time.now
-      MQTT_ERR_SUCCESS
+      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)
@@ -762,23 +777,25 @@ module PahoMqtt
     end
 
     def send_subscribe(topics)
-      unless topics.length == 0
+      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 })
         }
-      end        
-      MQTT_ERR_SUCCESS
+        MQTT_ERR_SUCCESS
+      else
+        disconnect(false)
+        raise ProtocolViolation
+      end
     end
 
     def send_unsubscribe(topics)
-      unless topics.length == 0
+      unless valid_topics?(topics) == MQTT_ERR_FAIL
         new_id = next_packet_id
         packet = PahoMqtt::Packet::Unsubscribe.new(
           :id => new_id,
@@ -789,8 +806,11 @@ module PahoMqtt
         @unsuback_mutex.synchronize {
           @waiting_unsuback.push({:id => new_id, :packet => packet, :timestamp => Time.now})
         }
+        MQTT_ERR_SUCCESS
+      else
+        disconnect(false)
+        raise ProtocolViolation
       end
-      MQTT_ERR_SUCCESS
     end
 
     def send_publish(topic, payload, retain, qos)
@@ -862,6 +882,17 @@ module PahoMqtt
       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('/')