aws_iot_device 0.1.0

data/lib/aws_iot_device/mqtt_shadow_client.rb

@@ -0,0 +1,6 @@
+require 'aws_iot_device/mqtt_shadow_client/shadow_client'
+
+module AwsIotDevice
+  module MqttShadowClient
+  end
+end

data/lib/aws_iot_device/mqtt_shadow_client/json_payload_parser.rb

@@ -0,0 +1,34 @@
+require 'securerandom'
+require 'timers'
+require 'thread'
+require 'json'
+
+module AwsIotDevice
+  module MqttShadowClient
+    class JSONPayloadParser
+      ### This class acts as Basic JSON parser.
+      ### The answer from AWS is in a JSON format.
+      ### All different key of the JSON file should be defined as hash key
+
+      def initialize
+        @message = {}
+      end
+
+      def set_message(message)
+        @message = JSON.parse(message)
+      end
+
+      def get_attribute_value(key)
+        @message[key]
+      end
+
+      def set_attribute_value(key, value)
+        @message[key] = value
+      end
+
+      def get_json
+        @message.to_json
+      end
+    end
+  end
+end

data/lib/aws_iot_device/mqtt_shadow_client/mqtt_manager.rb

@@ -0,0 +1,135 @@
+require 'thread'
+
+module AwsIotDevice
+  module MqttShadowClient
+    class MqttManager
+
+      attr_reader :client_id
+
+      attr_accessor :connection_timeout_s
+
+      attr_accessor :mqtt_operation_timeout_s
+
+      attr_accessor :host
+
+      attr_accessor :port
+
+      attr_accessor :ssl
+
+      def initialize(*args)
+        @client = create_mqtt_adapter(*args)
+        @mutex_publish = Mutex.new()
+        @mutex_subscribe = Mutex.new()
+        @mutex_unsubscribe = Mutex.new()
+        @ssl_configured = false
+
+        if args.last.is_a?(Hash)
+          attr = args.pop
+          attr.each_pair do |k, v|
+            self.send("#{k}=", v)
+          end
+        end
+
+        if need_ssl_configure?
+          @client.set_tls_ssl_context(@ca_file, @cert, @key)
+          @ssl_configured = true
+        end
+
+        ### Set the on_message's callback
+        @client.on_message = Proc.new do |message|
+          on_message_callback(message)
+        end
+      end
+
+      def cert_file=(path)
+        @cert = path
+      end
+
+      def key_file=(path)
+        @key = path
+      end
+
+      def ca_file=(path)
+        @ca_file = path
+      end
+
+      def client_id
+        @client.client_id
+      end
+
+      def create_mqtt_adapter(*args)
+        @client = MqttAdapter::Client.new(*args)
+      end
+
+      def on_message_callback(message)
+        puts "Received (with no custom callback registred) : "
+        puts "------------------- Topic: #{message.topic}"
+        puts "------------------- Payload: #{message.payload}"
+      end
+
+      def config_endpoint(host, port)
+        if host.nil? || port.nil?
+          raise "config_endpoint error: either host || port is undefined error"
+        end
+        @host = host
+        @port = port
+      end
+
+      def config_ssl_context(ca_file, key, cert)
+        @ca_file = ca_file
+        @key = key
+        @cert = cert
+        @client.set_tls_ssl_context(ca_file, cert, key)
+      end
+
+      def connect(keep_alive_interval=30, &block)
+        if keep_alive_interval.nil? && keep_alive_interval.is_a(Integer)
+          raise "connect error: keep_alive_interval cannot be a not nil Interger"
+        end
+
+        @client.host=(@host)
+        @client.port=(@port)
+        ### Execute a mqtt opration loop in background for time period defined by mqtt_connection_timeout
+        @client.connect(block)
+      end
+
+      def disconnect
+        @client.disconnect
+      end
+
+      def publish(topic, payload="", qos=0, retain=nil)
+        if topic.nil?
+          raise "publish error: topic cannot be nil"
+        end
+        @mutex_publish.synchronize{
+          @client.publish(topic,payload,qos,retain)
+        }
+      end
+
+      def subscribe(topic, qos=0, callback=nil)
+        if topic.nil?
+          raise "subscribe error: topic cannot be nil"
+        end
+        ret = false
+        @mutex_subscribe.synchronize {
+          @client.add_callback_filter_topic(topic, callback)
+          @client.subscribe(topic)
+        }
+      end
+
+      def unsubscribe(topic)
+        if topic.nil?
+          raise "unsubscribe error: topic cannot be nil"
+        end
+        @mutex_unsubscribe.synchronize{
+          @client.remove_callback_filter_topic(topic)
+          @client.unsubscribe(topic)
+        }
+      end
+
+      def need_ssl_configure?
+        !( @ca_file.nil? || @cert.nil? || @key.nil? ) && @ssl
+      end
+    end
+  end
+end

data/lib/aws_iot_device/mqtt_shadow_client/shadow_action_manager.rb

@@ -0,0 +1,235 @@
+require 'securerandom'
+require 'timers'
+require 'thread'
+require 'json'
+require 'aws_iot_device/mqtt_shadow_client/token_creator'
+require 'aws_iot_device/mqtt_shadow_client/json_payload_parser'
+
+module AwsIotDevice
+  module MqttShadowClient
+    class ShadowActionManager
+      ### This the main AWS action manager
+      ### It allows to execute the AWS actions (get, update, delete)
+      ### It allows to manage the time out after an action have been start
+      ### Actions request are send on the general actions topic and answer is retreived from accepted/refused/delta topics
+
+      def initialize(shadow_name, shadow_topic_manager, persistent_subscribe=false)
+        @shadow_name = shadow_name
+        @topic_manager = shadow_topic_manager
+        @payload_parser = JSONPayloadParser.new
+        @is_subscribed = {}
+        @is_subscribed[:get] = false
+        @is_subscribed[:update] = false
+        @is_subscribed[:delete] = false
+        @token_handler = TokenCreator.new(shadow_name, shadow_topic_manager.client_id)
+        @persistent_subscribe = persistent_subscribe
+        @last_stable_version = -1 #Mean no currentely stable
+        @topic_subscribed_callback = {}
+        @topic_subscribed_callback[:get] = nil
+        @topic_subscribed_callback[:update] = nil
+        @topic_subscribed_callback[:delta] = nil
+        @topic_subscribed_task_count = {}
+        @topic_subscribed_task_count[:get] = 0
+        @topic_subscribed_task_count[:update] = 0
+        @topic_subscribed_task_count[:delete] = 0
+        @token_pool = {}
+        @general_action_mutex = Mutex.new
+        @default_callback = Proc.new do |message|
+          do_default_callback(message)
+        end
+      end
+
+      ### The default callback that is called by every actions
+      ### It acknowledge the accepted status if action success
+      ### Call a specific callback for each actions if it defined have been register previously
+      def do_default_callback(message)
+        @general_action_mutex.synchronize(){
+          topic = message.topic
+          action = parse_action(topic)
+          type = parse_type(topic)
+          payload = message.payload
+          @payload_parser.set_message(payload)
+          if %w(get update delete).include?(action)
+            token = @payload_parser.get_attribute_value("clientToken")
+            if @token_pool.has_key?(token)
+              if type.eql?("accepted")
+                new_version = @payload_parser.get_attribute_value("version")
+                if new_version && new_version >= @last_stable_version
+                  type.eql?("delete") ? @last_stable_version = -1 : @last_stable_version = new_version
+                  Thread.new { @topic_subscribed_callback[action.to_sym].call(message) } unless @topic_subscribed_callback[action.to_sym].nil?
+                else
+                  puts "CATCH AN UPDATE BUT OUTDATED/INVALID VERSION (= #{new_version}) FOR TOKEN #{token}\n"
+                end
+              end
+              @token_pool[token].cancel
+              @token_pool.delete(token) 
+              @topic_subscribed_task_count[action.to_sym] -= 1
+              if @topic_subscribed_task_count[action.to_sym] <= 0
+                @topic_subscribed_task_count[action.to_sym] = 0
+                unless @persistent_subscribe
+                  @topic_manager.shadow_topic_unsubscribe(@shadow_name, action)
+                  @is_subscribed[action.to_sym] = false
+                end
+              end
+            end
+          elsif %w(delta).include?(action)
+            new_version = @payload_parser.get_attribute_value("version")
+            if new_version && new_version >= @last_stable_version
+              @last_stable_version = new_version
+              Thread.new { @topic_subscribed_callback[action.to_sym].call(message) } if @topic_subscribed_callback[action.to_sym]
+            else
+              puts "CATCH A DELTA BUT OUTDATED/INVALID VERSION (= #{new_version})\n"
+            end
+          end
+        }
+      end
+
+      ### Should cancel the token after a preset time interval
+      def timeout_manager(action_name, token)
+        @general_action_mutex.synchronize(){
+          if @token_pool.has_key?(token)
+            action = action_name.to_sym
+            @token_pool.delete(token)
+            puts "The #{action_name} request with the token #{token} has timed out!\n"
+            @topic_subscribed_task_count[action] -= 1
+            unless @topic_subscribed_task_count[action] <= 0
+              @topic_subscribed_task_count[action] = 0
+              unless @persistent_subscribe
+                @topic_manager.shadow_topic_unsubscribe(@shadow_name, action)
+                @is_subscribed[action.to_sym] = false
+              end
+            end
+            unless @topic_subscribed_callback[action].blank?
+              puts "Shadow request with token: #{token} has timed out."
+              @topic_subscribed_callback[action].call("REQUEST TIME OUT", "timeout", token)
+            end
+          end
+        }
+      end
+
+      ### Send and publish packet with an empty payload contains in a valid JSON format.
+      ### A unique token is generate and send in the packet in order to trace the action.
+      ### Subscribe to the two get/accepted and get/rejected of the coresponding shadow.
+      ### If the request is accpeted, the answer would be send on the get/accepted topic.
+      ### It contains all the details of the shadow state in JSON document.
+      ### A specific callback in Proc could be send parameter.
+      ### Before exit, the function start a timer count down in the separate thread.
+      ### If the time ran out, the timer_handler function is called and the get action is cancelled using the token.
+      ###
+      ### Parameter:
+      ###   > callback: the Proc to execute when the answer to th get request would be received.
+      ###                It should accept three different paramter:
+      ###                  - payload : the answer content
+      ###                  - response_status : among ['accepted', 'refused', 'delta']
+      ###                  - token : the token assoicate to the get request
+      ###
+      ###   > timeout: the period after which the request should be canceled and timer_handler should be call
+      ###
+      ### Returns :
+      ###   > the token associate to the current action (which also store in @token_pool)
+
+      def shadow_get(callback=nil, timeout=5)
+        current_token = ""
+        json_payload = ""
+        timer = Timers::Group.new
+        @general_action_mutex.synchronize(){
+          @topic_subscribed_callback[:get] = callback
+          @topic_subscribed_task_count[:get] += 1
+          current_token = @token_handler.create_next_token
+          timer.after(timeout){ timeout_manager(:get, current_token) }
+          @payload_parser.set_attribute_value("clientToken",current_token)
+          json_payload = @payload_parser.get_json
+          unless @is_subscribed[:get]
+            @topic_manager.shadow_topic_subscribe(@shadow_name, "get", @default_callback)
+            @is_subscribed[:get] = true
+          end
+          @topic_manager.shadow_topic_publish(@shadow_name, "get", json_payload)
+          @token_pool[current_token] = timer
+          Thread.new{ timer.wait }
+          current_token
+        }
+      end
+
+      def shadow_update(payload, callback, timeout)
+        current_token = Symbol
+        timer = Timers::Group.new
+        json_payload = ""
+        @general_action_mutex.synchronize(){
+          if callback.is_a?(Proc)
+            @topic_subscribed_callback[:update] = callback
+          end
+          @topic_subscribed_task_count[:update] += 1
+          current_token = @token_handler.create_next_token
+          timer.after(timeout){ timeout_manager(:update, current_token) }
+          @payload_parser.set_message(payload)
+          @payload_parser.set_attribute_value("clientToken",current_token)
+          json_payload = @payload_parser.get_json
+          unless @is_subscribed[:update]
+            @topic_manager.shadow_topic_subscribe(@shadow_name, "update", @default_callback)
+            @is_subscribed[:update] = true
+          end
+          @topic_manager.shadow_topic_publish(@shadow_name, "update", json_payload)
+          @token_pool[current_token] = timer
+          Thread.new{ timer.wait }
+          current_token
+        }
+      end
+
+      def shadow_delete(callback, timeout)
+        current_token = Symbol
+        timer = Timers::Group.new
+        json_payload = ""
+        @general_action_mutex.synchronize(){
+          if callback.is_a?(Proc)
+            @topic_subscribed_callback[:delete] = callback
+          end
+          @topic_subscribed_task_count[:delete] += 1
+          current_token = @token_handler.create_next_token
+          timer.after(timeout){ timeout_manager(:delete, current_token) }
+          @payload_parser.set_attribute_value("clientToken",current_token)
+          json_payload = @payload_parser.get_json
+          unless @is_subscribed[:delete]
+            @topic_manager.shadow_topic_subscribe(@shadow_name, "delete", @default_callback)
+            @is_subscribed[:delete] = true
+          end
+          @topic_manager.shadow_topic_publish(@shadow_name, "delete", json_payload)
+          @token_pool[current_token] = timer
+          Thread.new{ timer.wait }
+          current_token
+        }
+      end
+
+      def register_shadow_delta_callback(callback)
+        @general_action_mutex.synchronize(){
+          @topic_subscribed_callback[:delta] = callback
+          @topic_manager.shadow_topic_subscribe(@shadow_name, "delta", @default_callback)
+        }
+      end
+
+      def remove_shadow_delta_callback
+        @general_action_mutex.synchronize(){
+          @topic_subscribe_callback.delete[:delta]
+          @topic_manager.shadow_topic_unsubscribe(@shadow_name, "delta")
+        }
+      end
+
+      private
+
+      def parse_shadow_name(topic)
+        topic.split('/')[2]
+      end
+
+      def parse_action(topic)
+        if topic.split('/')[5] == "delta"
+          topic.split('/')[5]
+        else
+          topic.split('/')[4]
+        end
+      end
+
+      def parse_type(topic)
+        topic.split('/')[5]
+      end
+    end
+  end
+end

data/lib/aws_iot_device/mqtt_shadow_client/shadow_client.rb

@@ -0,0 +1,60 @@
+require 'aws_iot_device/mqtt_shadow_client/mqtt_manager'
+require 'aws_iot_device/mqtt_shadow_client/shadow_topic_manager'
+require 'aws_iot_device/mqtt_shadow_client/shadow_action_manager'
+
+module AwsIotDevice
+  module MqttShadowClient
+    class ShadowClient
+      attr_accessor :action_manager
+
+      def initialize
+        @mqtt_client = MqttManager.new
+      end
+
+      def connect
+        @mqtt_client.connect
+      end
+
+      def topic_manager
+        @topic_manager = ShadowTopicManager.new(@mqtt_client)
+      end
+
+      def create_shadow_handler_with_name(shadow_name, is_persistent_subscribe=false)
+        topic_manager
+        @action_manager = ShadowActionManager.new(shadow_name, @topic_manager, is_persistent_subscribe)
+      end
+
+      def get_shadow(callback=nil, timeout=5)
+        @action_manager.shadow_get(callback, timeout)
+      end
+
+      def update_shadow(payload, callback=nil, timeout=5)
+        @action_manager.shadow_update(payload, callback, timeout)
+      end
+
+      def delete_shadow(callback=nil, timeout=5)
+        @action_manager.shadow_delete(callback, timeout)
+      end
+
+      def register_delta_callback(callback)
+        @action_manager.register_shadow_delta_callback(callback)
+      end
+
+      def remove_shadow_delta_callback
+        @action_manager.remove_shadow_delta_callback
+      end
+
+      def disconnect
+        @mqtt_client.disconnect
+      end
+
+      def configure_endpoint(host,port)
+        @mqtt_client.config_endpoint(host,port)
+      end
+
+      def configure_credentials(ca_file, key, cert)
+        @mqtt_client.config_ssl_context(ca_file, key, cert)
+      end
+    end
+  end
+end