aws_iot_device 0.1.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 009d07b7885daf8b78adfde14e6003fc57591ce1
-  data.tar.gz: 6f0aa59513a98f56305c6c2f24e21ce60c9e9f7d
+  metadata.gz: 35edf7c0cb543d0095ff0d45af83739cbedb56e0
+  data.tar.gz: 639d254baa0e2cdd31cea8549ff96830992a9a58
 SHA512:
-  metadata.gz: 1898993a9a78e6f6bf148d0daffddbf9b928f8168c34179b3184f1408ca38b646572e9fb0b3cba3cac21a24ebb081320f8eab96d1f7b62837e4611088466aae6
-  data.tar.gz: 2c56a1ca2bb8693d1322bf760c39fb5f0e0b4ef4baeafb77fe5c91fc887616d5e3d87045507e4b26c0028e069c0abcace8a5a44f7c09f923be610826703e3a98
+  metadata.gz: 1b20075b2046770c39c864ec1a25d992d612a20aa816a124fa2d42a1845bea57dc80bd3887cb41ea5b9fb587bb513f729cb6af1a8e06020a1a810a8314ba2f73
+  data.tar.gz: 31f553b11f8641b2e475c869c58b78daf088d1201151770cbc1ceb1cf85300c5b23eef634c62d09623f8f55bff38fd21c9470ea3d653f43f39bf485c0096c8f9

data/.gitignore

@@ -49,3 +49,5 @@ Gemfile.lock
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
 
+.idea
+

data/README.md

@@ -1,30 +1,39 @@
 <a href="https://codeclimate.com/repos/57d10b3aaee68e0a2d0016b7/feed"><img src="https://codeclimate.com/repos/57d10b3aaee68e0a2d0016b7/badges/aad862afb3ada6425b90/gpa.svg" /></a>
 [![Dependency Status](https://gemnasium.com/badges/github.com/RubyDevInc/aws-iot-device-sdk-ruby.svg)](https://gemnasium.com/github.com/RubyDevInc/aws-iot-device-sdk-ruby)
-
+[![Gem Version](https://badge.fury.io/rb/aws_iot_device.svg)](https://badge.fury.io/rb/aws_iot_device)
 
 # AWS IoT Device SDK for Ruby
 
-
-## Requirements
+## Contents
+* [Dependencies](#dependencies)
+* [Overview](#overview)
+* [Installation](#installation)
+* [Usage](#usage)
+  * [Getting started](#getting-started)
+  * [Sample files](#sample-files)
+* [API Description](#api-description)
+  * [Shadow Client](#shadow-client)
+  * [Connection Mode](#connection-mode)
+  * [MQTT Adapter](#mqtt-adapter)
+* [License](#license)
+* [Contact](#contact)
+
+## Dependencies
 Ruby gems:
-- ruby ~> 2.2
-- mqtt ~> 0.4
-- json ~> 1.8
-- facets ~> 3.1
-- timers ~> 4.1
-
-## Introduction
-The AWS IoT SDK for Ruby is a gems which enables to manage device registered as shadow/things on the AWS IoT platform. A shadow is a JSON document that describes the state of a associated thing(app, device, sensor,...). The JSON document is divided in two part, the desired and the reported state of the thing. Three operations could be done on the Shadow: 
-- Get: read the current state of the shadow
-- Update: add, change or remove the attribute value of the shadow
-- Delete: clear all the attribute value of the shadow
+- ruby >= 2.2
+- mqtt >= 0.0.2
+- json >= 2.0
+- facets >= 3.1
+- timers >= 4.1
+- paho-mqtt >= 0.0.2
 
-The client communicates with the AWS IoT platform through the MQTT protocol. An adapter is provided to enable several implementations of the MQTT protocol and thus make the client independent form its back-end library implementation. In the current version, the default settings are using a client based on the ruby-mqtt gems. According to the shadow management, the operations are performed by sending message on the dedicated MQTT topics. The answer could be read on the corresponding MQTT topics, then some treatments could be processed thanks to a system of callback.
+## Overview
+`aws_iot_device` is a gem that enables a remote client to communicate with the AWS IoT platform. The AWS IoT platform allows to register a device as a `thing`. The status of each `thing` is stored in a json format, referred as the `shadow` of a `thing`. The SDK uses the MQTT protocol to control the `thing` registered on the AWS IoT platform. The MQTT protocol is a lightweight protocol used to exchange short messages between a client and a message broker. The message broker is located on the AWS IoT platform, and the client is included in the `aws_iot_device` gem, the default client is the `paho-mqtt`. The `paho-mqtt` client has a MQTT API and a callback system to handle the events trigger by the mqtt packages.
 
 ## Installation
-The gem is still in a beta version. There is two way to install it, from the `gem` command or directly from sources.
-- From RubyGems:
-
+The gem is currentely in its first version, key features are available but any improvements is welcomed.  
+There are two ways to install the gem, from [rubygems](https://rubygems.org/gems/aws_iot_device) or directly from [sources](https://github.com/RubyDevInc/aws-iot-device-sdk-ruby).
+- From RubyGems:  
 The gem may be find on [RubyGems](https://rubygems.org/gems/aws_iot_device) and installed with the following command:
 ```
 gem install aws_iot_device
@@ -33,168 +42,166 @@ gem install aws_iot_device
 - From sources:
 
 The gem could be download and installed manually:
+
 ```
 git clone https://github.com/RubyDevInc/aws-iot-device-sdk-ruby.git
 cd aws-iot-device-sdk-ruby
 bundle install
 ```
+## Usage
+### Getting started
+The following example is a strait-forward way for using shadows. Check at the samples files for more detailed usage.
+```ruby
+require "aws_iot_device"
+
+host = "AWS IoT endpoint"
+port = 8883
+thing = "Thing Name"
+
+root_ca_path = "Path to your CA certificate"
+private_key_path = "Path to your private key"
+certificate_path = "Path to your certificate"
+
+shadow_client = AwsIotDevice::MqttShadowClient::ShadowClient.new
+shadow_client.configure_endpoint(host, port)
+shadow_client.configure_credentials(root_ca_path, private_key_path, certificate_path)
+shadow_client.create_shadow_handler_with_name(thing, true)
+
+shadow_client.connect
+shadow_client.get_shadow do |message|
+  # Do what you want with the get_shadow's answer
+  # ...
+  p ":)"
+end
+sleep 2 #Timer to ensure that the answer is received
 
-## Using the ShadowClient
-Some examples files are provided in the samples directory. They could be run by the following commands:
-```bash
-### If the gem have been install with the `gem` command
-ruby "sample_file".rb -c "path to certificate" -a "path to authority certificate" -k "path to key" -H "aws endpoint URI" -t "thing name"
+shadow_client.disconnect
+```
 
+### Sample files
+Once you have cloned the current repository the several samples files provide test on the API a multiple levels.
+The shadow examples could be run with the following command :
+```
+ruby samples/shadow_client_samples/samples_shadow_client_xxx.rb -c "CERTIFICATE PATH" -k "PRIVATE KEY PATH"  -a "CA CERTIFICATE PATH" -H "AWS IOT ENDPOINT" -t "THING NAME"
+```
 
-### If the gem have been installed from sources  
-# Including the local libraries
-ruby -I lib "sample_file".rb -c "path to certificate" -a "path to authority certificate" -k "path to key" -H "aws endpoint URI" -t "thing name"
+## API Description
+Thank you very much for your interst in the `aws_iot_device` gem. The following part details all the features available with the SDK.
 
-# Or
+### Shadow Client
+The shadow client API provide the key functions to control a thing/shadow on the Aws IoT platform. The methods contain in the API could be seperate in three differents roles, the configuration roles, the communication roles, and the treatements roles.
 
-# With the bundle command 
-bundle exec ruby "sample_file".rb -c "path to certificate" -a "path to authority certificate" -k "path to key" -H "aws endpoint URI" -t "thing name"
+#### Configuration role
+The Shadow client initializer would create the mqtt client used by the shadow client to communicate with the remote host. The parameters available on the initialization depend on the type of the chosen mqtt client. The default mqtt client type is the paho_client, the availables parameters are detailed in `paho-mqtt` gem [page](https://github.com/RubyDevInc/paho.mqtt.ruby#initialization).
+
+The remote host(endpoint) and port could be configured with the following method:
+```
+shaadow_client.configure_endpoint(host, port)
 ```
 
-### Shadow Client
-The ShadowClient class handles the function that would acts on the shadow. It is way the easiest to manipulate the shadow thanks to the different methods of the API. The following example details step by step how to create a ShadowClient, connect it to a shadow and then execute some basic operations on the shadow :
+The encryption configuration could be done with the following method:
+```
+shadow_client.configure_credentials(root_ca_path, private_key_path, certificate_path)
+```
 
-```ruby
-### Credentials and host information needed to connect
-root_ca_path = "PATH_TO_YOUR_ROOT_CA_FILE"
-private_key_path = "PATH_TO_YOUR_PRIVATE_KEY"
-certificate_path = "PATH_TO_YOUR_CERTIFICATE_FILE"
+The thing where the client would connect is done by the following method. The persitent_subscribe attribute is a boolean that would prevent the client to unsubscribe to the mqtt topic after every action. As the susbcription require a short time, for performace issues it might usefull to keep subscribed (default is `false`).
+```
+shadow_client.create_shadow_handler_with_name(thing, persistent_subscribe)
 
-# For exemple for Tokyo area:  host = "xxx.iot.ap-northeast-1.amazonaws.com"
-host = "ENDPOINT_URI_ON_AWS"
+```
 
-port = 8883 #default port of MQTT protocol
-time_out = 5
+Finally, the connect method enable to send a connect request and (re)define some attributes threw a `Hash`. The available parameter are `:host`, `:port`, `:keep_alive`, `:persitent` and `:blocking`. `:persistent` and `:blocking` are detailed in the connection mode [section](#connection-mode)
+```
+shadow_client.connect
+```
 
-### Create and set up a ShadowClient
+#### Communication role
+In the API there are three methods that directely act on the remote shadow. A `timeout` define the time until which the request should be considered as a failure. The default timeout is five second. The `get` and `delete` do not accept a payload where a json format payload is mandatory for the `update` action. 
+```
+timeout = 2
 
-my_shadow_client = AwsIotDevice::MqttShadowClient::ShadowClient.new
-my_shadow_client.configure_endpoint(host, port)
-my_shadow_client.configure_credentials(root_ca_path, private_key_path, certificate_path)
+shadow_client.get_shadow(timeout)
 
-### Conect the ShadoaClient and attach it to existing thing 
-my_shadow_client.connect
-my_shadow_client.create_shadow_handler_with_name("YOUR_THING_NAME", false)
+payload = "{\"state: \": \"desired\": ..... }"
+shadow_client.update_shadow(payload)
 
-callback = Proc.new do |message|
-    puts "Special callback for the topic #{message.topic}"
+shadow_client.delete_shadow
+```
+
+#### Callbacks
+Callbacks are small piece of code that would be executed when the answer of one action is received by the client. The Shadow client API enables to register two kind of callbacks, a generic callback and single usage callback.
+For generic action (get, update, delete), the callback would be executed on every answer of the dedicated generic action. Futhermore, another callback may be executed for a single answer of a dedicated action. The generic callback could be seen as re-usable callback functions when the single usage could be seen as disposable treatment.
+Both kind of callbacks must be registered as a `block`, a `proc` or a `lambda`. The followings lines provide an examples of the different callbacks usage.
+```ruby
+# Register a callback for the get action as a block
+shadow_client.register_get_callback do
+  puts "generic callback for get action"
 end
-### The  three basic AWS Iot operations:
-### time_out is a integer reprensenting the time to keep request alive in second
-my_shadow_client.get_shadow(callback, time_out)
-# or without special callback 
-my_shadow_client.get_shadow(nil, time_out)
 
-my_shadow_client.delete_shadow(callback, time_out)
+# Register a callback for the delete action as a proc
+shadow_client.register_delete_callback(proc { puts "generic callback for delete action"})
 
-### Update need a formated payload:
-payload = '{ "state":{ "desired":{ "attr1":"foo" }}}' 
-my_shadow_client.update_shadow(payload, callback, time_out)
-```
+# Register a callback for the update action as a lambda
+shadow_client.register_update_callback(lambda {|message| puts "genereic callback for update action"})
 
+# Register a callback for the delta events
+shadow_client.register_delta_callback do
+  puts "delta have been catch in a callback"
+end
 
-### Shadows Topics
-The TopicManager class handles the subscribing and plublishing operations for a shadow. Its functions are used by the ShadowClient class during the get, update and delete operations but they also may be called directely.  Publish and Subscribe requests are sent on the reserved MQTT topics of the selected shadow. For each operation, those topics have a similar structure:
-```
-$aws/things/"SHADOW_NAME"/shadow/"ACTION_NAME"
-```
-Depending on the acceptation of the request, the answer would be received either on the accepted or rejected MQTT topics:
-```
-$aws/things/"SHADOW_NAME"/shadow/"ACTION_NAME"/accepted
-$aws/things/"SHADOW_NAME"/shadow/"ACTION_NAME"/rejected
-```
-Another topic is reserved only for some answer of the update action, the delta topic. If the desired attributes and the reported attributes have differents values in the JSON file describing the shadow state, a message would be send on the delta to report those differences. 
+# Send a get request with an associated callback in a block
+shadow_client.get_shadow do
+  puts "get thing"
+end
+
+# Send a delete request with an associated callback in a proc
+shadow_client.delete_shadow(timeout, proc {puts "delete thing"})
+
+# Send a udpate request with an associated callback in a lambda
+shadow_client.update_shadow("{\"state\":{\"desired\":{\"message\":\"Hello\"}}}", timeout, lambda {|message| puts "update thing"})
+
+# Clear out the previously registered callback for each action
+shadow_client.remove_get_callback
+shadow_client.remove_update_callback
+shadow_client.remove_delete_callback
+shadow_client.remove_delta_callback
 ```
-$aws/things/"SHADOW_NAME"/shadow/update/delta"
+
+### Client persitences
+For performance issues, sometimes subscriptions and (re)connection time would better to saved. This could be done with two different persistences, the subscription persistence and the connection persistence. The subscription persistence keeps the shadow_client subscribed to action topics (get/accepted, get/rejected, update/accepted, update/rejected, delete/accepted and delete/rejected). The subscription process require a short time, the persistent subscription avoid to susbscribe before each and so saved the subscription time. The subscription persistence could be set at the initialization of the shadow handler or directely at the shadow client initialization.
+```ruby
+shadow_client = AwsIotDevice::MqttShadowClient::ShadowClient.new({:shadow_name => "Thing name", :persistent_subscribe => true})
+# Or
+shadow_client.create_shadow_handler_with_name(shadow_name, persistent_subscribe)
 ```
-The TopicManager class implements the function to publish and subscribed to those reserved topic
+The default subscription persistence if desactivated, so the client might subscribe/unsubscribe to reserved topics before/after every actions.  
+  
+The connection persistence enables the client to keep the mqtt connection alive until the client explicitly requests to disconnect. The basic client would disconnect from the remote host if no activity has been detected for a preset keep_alive timer. There is two ways to configure the connection persistence, at the initialization of the shadow client or at the connection time.
 ```ruby
-root_ca_path = "PATH_TO_YOUR_ROOT_CA_FILE"
-private_key_path = "PATH_TO_YOUR_PRIVATE_KEY"
-certificate_path = "PATH_TO_YOUR_CERTIFICATE_FILE"
-ssl = true
-
-# For exemple for Tokyo area:  host = "xxx.iot.ap-northeast-1.amazonaws.com"
-host = "ENDPOINT_URI_ON_AWS"
-port = 8883 #default port of MQTT protocol
+shadow_client = AwsIotDevice::MqttShadowClient::ShadowClient.new({:persistent => true})
+# Or
+shadow_client.connect({:persitent => true})
+```
 
-mqtt_manager = AwsIotDevice::MqttShadowClient::MqttManager.new(host,
-                             port,
-                             ssl,
-                             certificate_path,
-                             private_key_path,
-                             root_ca_path)
 
-mqtt_manager.connect
+### MQTT Adapter
+The `aws-iot-device` gem is based on a MQTT client (`paho-mqtt`) that enables the usage of basic MQTT operations.  
+```ruby
+mqtt_client = AwsIoTDevice::MqttShadowClient::MqttManager.new
 
-manager = AwsIotDevice::MqttShadowClient::ShadowTopicManager.new(mqtt_manager)
+mqtt_client.config_endpoint(host, port)
+mqtt_client.config_ssl_context(host, port)
+mqtt_client.connect
 
-### ACTION_NAME among "get", "update", "delete"
-manager.shadow_topic_publish(shadow_name, shadow_action, payload)
+mqtt_client.subscribe(topic, qos, callback)
+mqtt_client.publish(topic, "Hello world!", qos, retain)
 
-### ACTION_NAME among "get", "update", "delete" or "delta"
-### callback is a Proc that would be executed when message is received on the subscribed topic (default is nil) 
-manager.shadow_topic_subscribe("SHADOW_NAME", "SHADOW_ACTION", callback=nil)
-manager.shadow_topic_unsubscribe(shadow_name, shadow_action)
+mqtt_client.unsubscribe(topic)
+mqtt_client.disconnect
 ```
+For the default paho mqtt_client, some callbacks are available for each event related with the MQTT protocol. We recommend to read the `paho-mqtt` [gem page](https://github.com/RubyDevInc/paho.mqtt.ruby#handlers-and-callbacks) for more details about the mqtt callbacks usage.
 
-### Shadow Action Manager
-The ShadowActionManager enable to the client to perform the basic action on the shadow, and then execute a default callback with the answer. A callback defined be the user and send as parameter with the action may also been executed. For each operation a task counter is set to hold the number of task which are waiting answer. The ShadowActionManager class could be initialized with two mode, persistent and not-persistent.  In the not-persistent case, the client will automatically unsubscribe to action topic when its corresponding task counter go back to 0. The persistent mode will keep the client subscribed to the topic even if the task counter is 0. In the current version, subscribe to a topic require 2 second to assert the subscription is completed. The persistent mode enable to run that waiting timer only one for each operation(for the first one).
-```ruby
-### Directly create the ShadowManagerAction
-### SUBSRIBE_MODE is a boolean, 'true'  for persistent mode and (default)'false'  for not-persistent 
-client = AwsIotDevice::MqttShadowClient::ShadowActionManager.new("THING_NAME", "TOPIC_MANGER", "SUBSCRIBE_MODE")
-
-### Or through a ShadowClient  object
-my_shadow_client = AwsIotDevice::MqttShadowClient::ShadowClient.new
-client = my_shadow_client.create_shadow_handler_with_name("THING_NAME", "SUBSCRIBE_MODE")
+## License
+This SDK is distributed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).
 
-### The three basic action: 
-client.shadow_get("YOUR_CALLBACK_OR_NIL", "TIME_OUT")#TIME_OUT is a integer reprensenting the time to keep request alive in second
-client.shadow_update("UPDATE_PAYLOAD", "YOUR_CALLBACK_OR_NIL", "TIME_OUT")
-client.shadow_delete("YOUR_CALLBACK_OR_NIL", "TIME_OUT")
-```
-## The MQTT Manager
-The MqttManager class supports the operations related with the MQTT protocol, it is a customized MQTT client. According to the MQTT protocol, the MqttManager may connect, publish, subscribe and disconnect. It holds a callbacks system which  are triggered by MQTT events, for exemple  when a message is received on a subscribed topic. Currently (September 2016), the callback system only support the message(PUBLISH) event, other events (CONNACK, SUBACK, ...) should be supported in the future version.  It is possible to perform the previous AWS Iot operation through the MqttManager,  by  simply typing the desired topics in the publish request. The following example details how to sent a AWS Iot get request at the MQTT level.
-```ruby
-### There two way to initiate the object :
-# 1) Send parameter when creating the object and connect
-client = AwsIotDevice::MqttShadowClient::MqttManager.new(host: "YOUR_AWS_ENDPOINT",
-                             port: 8883,
-                             ssl: true,
-                             cert_file: "YOUR_CERT_FILE_PATH",
-                             key_file: "YOUR_KEY_FILE_PATH",
-                             ca_file: "YOUR_ROOT_CA_FILE_PATH")
-
-# 2) A step by step initialization
-client = AwsIotDevice::MqttShadowClient::MqttManager.new()
-client.host =  "YOUR_AWS_ENDPOINT"
-client.ssl = true
-client.port = 8883
-client.cert_file = "YOUR_CERT_FILE_PATH"
-client.key_file = "YOUR_KEY_FILE_PATH"
-client.ca_file = "YOUR_ROOT_CA_FILE_PATH"
-
-### Then send a MQTT connect request
-client.connect()
-
-client.subscribe("THING_TOPIC_GET_ACCEPTED")
-sleep  2 # Assert the subscription is completed
-### An example of AWS Iot get operation
-client.publish("THING_TOPIC_GET",  "")
-sleep  2 # Assert the answer is received to execute the callback
-client.unsubscribe("THING_TOPIC_GET_ACCEPTED")
-
-client.disconnect()
-``` 
-
-## MQTT Adapters modules
-The previously detailed MqttManager class is said to be based on a MQTT client, in this project the MQTT client is implemented as an adapters design pattern named the MqttAdapter.  The adapter design pattern enables the client implementation to be independent from the back-end MQTT library. Thanks to this design pattern, the MqttAdapter can work over several implementations of the MQTT protocol. The default implementation used in the project is the [ruby-mqtt](https://github.com/njh/ruby-mqtt) module, where some new features have been added. The adapters defined the method that should be accessible to higher level classes (ex. MqttManager). 
-
-### Ruby MQTT Adapter
-The [ruby-mqtt](https://github.com/njh/ruby-mqtt) gem provides a client which does the basic MQTT operation(connect, subscribe, publish ....) by reading the packets directly from the sockets.  It adapts the method of the [ruby-mqtt](https://github.com/njh/ruby-mqtt) gem in order to match with the definition in the MqttAdapter. Inspired by the [Paho](http://www.eclipse.org/paho/) library, a system of (infinite)loop in background is added to this class. This loop system enables a not blocking and  automated message reading.  Also, a callback system is enabled to make some treatment when message are received on a subscribed MQTT topic. If no specific callback is registered for the topic a default callback is executed.
+## Contact

data/aws_iot_device.gemspec

@@ -9,10 +9,10 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Pierre Goudet"]
   spec.email         = ["p-goudet@ruby-dev.jp"]
 
-  spec.summary       = %q{A gem use to communicates with the Aws Iot platform through the MQTT protocol}
-  spec.description   = %q{A gem use to communicates with the Aws Iot platform through the MQTT protocol}
+  spec.summary       = %q{The ruby version of the AWS IoT Device SDK. It enables to connect to AWS IoT platform and manage Things.}
+  spec.description   = %q{The gem is using the MQTT protocol to execute the command defined by the AWS IoT platform. A default MQTT client is included in the gem, however an adapter system enables to plug another MQTT client.}
   spec.homepage      = "https://github.com/RubyDevInc/aws-iot-device-sdk-ruby"
-  spec.license       = "Apache 2.0"
+  spec.license       = "Apache-2.0"
 
   # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
   # delete this section to allow pushing this gem to any host.
@@ -27,13 +27,13 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "bundler", "~> 1.10", ">= 1.10"
+  spec.add_development_dependency "pry", "~> 0.10.4", ">= 0.10.4"
+  spec.add_development_dependency "rake", "~> 10.0", ">= 1.10" 
+  spec.add_development_dependency "rspec", "~> 3.5.0", ">= 3.5.0"
 
-  spec.add_runtime_dependency "facets", "~> 3.1.0"
-  spec.add_runtime_dependency "json", "~> 1.8.3"
-  spec.add_runtime_dependency "mqtt", "~> 0.4.0"
-  spec.add_runtime_dependency "timers", "~> 4.1.1"
+  spec.add_runtime_dependency "facets", "~> 3.1.0", ">= 3.1.0"
+  spec.add_runtime_dependency "json", "~> 2.0.2", ">= 2.0.2"
+  spec.add_runtime_dependency "paho-mqtt", "~> 1.0.0", ">= 1.0.0"
+  spec.add_runtime_dependency "timers", "~> 4.1.1", ">= 4.1.1"
 end

data/codeclimate.yml

@@ -0,0 +1,6 @@
+languages:
+  Ruby: true
+exclude_paths:
+- "samples/"
+
+

data/lib/aws_iot_device.rb

@@ -3,5 +3,6 @@ require "aws_iot_device/mqtt_adapter"
 require "aws_iot_device/mqtt_shadow_client"
 
 module AwsIotDevice
-  # Your code goes here...
+  class Exception < ::Exception
+  end
 end

data/lib/aws_iot_device/mqtt_adapter.rb

@@ -9,7 +9,7 @@ module AwsIotDevice
     def adapter
       return @adapter if @adapter
       ### Calling the setter method with the default symbol 'RubyMqttAdapter' and return it.
-      self.adapter = :ruby_mqtt_adapter
+      self.adapter = :paho_mqtt_adapter
       @adapter
     end
 
@@ -21,7 +21,6 @@ module AwsIotDevice
           require "aws_iot_device/mqtt_adapter/#{adapter_lib}"
         rescue LoadError
           raise "LoadError: Could find adapters for the lib #{adapter_lib}"
-          exit
         end
         @adapter = MqttAdapter.const_get("#{adapter_lib.to_s.camelcase(:upper)}")
       else

data/lib/aws_iot_device/mqtt_adapter/client.rb

@@ -48,9 +48,9 @@ module AwsIotDevice
       end
 
       def mqtt_loop
-        @adapter.loop
+        @adapter.mqtt_loop
       end
-
+      
       def loop_read
         @adapter.loop_read
       end
@@ -83,30 +83,98 @@ module AwsIotDevice
         @adapter.connected?
       end
 
-      def subscribe(topic)
-        @adapter.subscribe(topic)
+      def subscribe(topic, qos)
+        @adapter.subscribe(topic, qos)
       end
 
+      def subscribe_bunch(*topics)
+        @adapter.subscribe_bunch(topics)
+      end
+      
       def unsubscribe(topic)
         @adapter.unsubscribe(topic)
       end
 
+      def unsubscribe_bunch(*topics)
+        @adapter.unsubscribe_bunch(topics)
+      end
+
       def set_tls_ssl_context(ca_cert, cert=nil, key=nil)
         @adapter.set_tls_ssl_context(ca_cert, cert, key)
       end
 
-      def add_callback_filter_topic(topic, callback)
-        @adapter.add_callback_filter_topic(topic, callback)
+      def add_callback_filter_topic(topic, callback=nil, &block)
+        @adapter.add_callback_filter_topic(topic, callback, &block)
       end
 
       def remove_callback_filter_topic(topic)
         @adapter.remove_callback_filter_topic(topic)
       end
 
+      def on_connack=(callback)
+        @adapter.on_connack = callback
+      end
+      
+      def on_suback=(callback)
+        @adapter.on_suback = callback
+      end
+
+      def on_unsuback=(callback)
+        @adapter.on_unsuback = callback
+      end
+
+      def on_puback=(callback)
+        @adapter.on_puback = callback
+      end
+
+      def on_pubrec=(callback)
+        @adapter.on_pubrec = callback
+      end
+
+      def on_pubrel=(callback)
+        @adapter.on_pubrel = callback
+      end
+
+      def on_pubcomp=(callback)
+        @adapter.on_pubcomp = callback
+      end
+      
       def on_message=(callback)
         @adapter.on_message = callback
       end
+      
+      def on_connack(&block)
+        @adapter.on_connack(&block)
+      end
+      
+      def on_suback(&block)
+        @adapter.on_suback(&block)
+      end
+
+      def on_unsuback(&block)
+        @adapter.on_unsuback(&block)
+      end
+
+      def on_puback(&block)
+        @adapter.on_puback(&block)
+      end
+
+      def on_pubrec(&block)
+        @adapter.on_pubrec(&block)
+      end
 
+      def on_pubrel(&block)
+        @adapter.on_pubrel(&block)
+      end
+
+      def on_pubcomp(&block)
+        @adapter.on_pubcomp(&block)
+      end
+      
+      def on_message(&block)
+        @adapter.on_message(&block)
+      end
+      
       ### The following attributes should exists in every MQTT third party librairy.
       ### They are necessary (or really usefull and common) for the establishement of the connection and/or the basic Mqtt actions.
       ### The setter directely change the third party client value when the getter remote the actual SharedClient instance's attribute value