aws_iot_device 0.1.5 → 1.0.0

data/lib/aws_iot_device/mqtt_shadow_client/shadow_action_manager.rb

@@ -9,19 +9,21 @@ 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
+      ### It enables the AWS IoT actions (get, update, delete)
+      ### It enables the time control the time out after an action have been start
+      ### Actions requests 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)
+      attr_accessor :logger
+
+      def initialize(shadow_name, mqtt_client, persistent_subscribe=false)
         @shadow_name = shadow_name
-        @topic_manager = shadow_topic_manager
+        @topic_manager = ShadowTopicManager.new(mqtt_client, shadow_name)
         @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)
+        @token_handler = TokenCreator.new(shadow_name, mqtt_client.client_id)
         @persistent_subscribe = persistent_subscribe
         @last_stable_version = -1 #Mean no currentely stable
         @topic_subscribed_callback = {}
@@ -33,78 +35,11 @@ module AwsIotDevice
         @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
-        }
+        @token_callback = {}
+        @task_count_mutex = Mutex.new
+        @token_mutex = Mutex.new
+        @parser_mutex = Mutex.new
+        set_basic_callback
       end
 
       ### Send and publish packet with an empty payload contains in a valid JSON format.
@@ -128,92 +63,240 @@ module AwsIotDevice
       ### 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
-        }
+      def shadow_get(timeout=5, callback=nil, &block)
+        shadow_action(:get, "", timeout, callback, &block)
+      end
+
+      def shadow_update(payload, timeout=5, callback=nil, &block)
+        shadow_action(:update, payload, timeout, callback, &block)
+      end
+
+      def shadow_delete(timeout=5, callback=nil, &block)
+        shadow_action(:delete, "", timeout, callback, &block)
+      end
+
+      def register_get_callback(callback, &block)
+        register_action_callback(:get, callback, &block)
+      end
+
+      def register_update_callback(callback, &block)
+        register_action_callback(:update, callback, &block)
+      end
+
+      def register_delete_callback(callback, &block)
+        register_action_callback(:delete, callback, &block)
+      end
+
+      def register_shadow_delta_callback(callback, &block)
+        if callback.is_a?(Proc)
+          @topic_subscribed_callback[:delta] = callback
+        elsif block_given?
+          @topic_subscribed_callback[:delta] = block
+        end
+        @topic_manager.shadow_topic_subscribe("delta", @default_callback)
+      end
+
+      def remove_get_callback
+        remove_action_callback(:get)
+      end
+
+      def remove_update_callback
+        remove_action_callback(:update)
+      end
+
+      def remove_delete_callback
+        remove_action_callback(:delete)
       end
 
-      def shadow_update(payload, callback, timeout)
+      def remove_shadow_delta_callback
+        @topic_subscribe_callback.delete[:delta]
+        @topic_manager.shadow_topic_unsubscribe("delta")
+      end
+
+      def logger?
+        !@logger.nil? && @logger.is_a?(Logger)
+      end
+
+      private
+
+      def shadow_action(action, payload="", timeout=5, callback=nil, &block)
         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
+        @token_mutex.synchronize(){
           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)
+        }
+        timer.after(timeout){ timeout_manager(action, current_token) }
+        @parser_mutex.synchronize {
+          @payload_parser.set_message(payload) unless 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
         }
+        handle_subscription(action, timeout) unless @is_subscribed[action]
+        @topic_manager.shadow_topic_publish(action.to_s, json_payload)
+        @task_count_mutex.synchronize {
+          @topic_subscribed_task_count[action] += 1
+        }
+        @token_pool[current_token] = timer
+        register_token_callback(current_token, callback, &block)
+        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
+      ### Should cancel the token after a preset time interval
+      def timeout_manager(action_name, token)
+        if @token_pool.has_key?(token)
+          action = action_name.to_sym
+          @token_pool.delete(token)
+          @token_callback.delete(token)
+          @logger.warn("The #{action_name} request with the token #{token} has timed out!\n") if logger?
+          @task_count_mutex.synchronize {
+            @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(action)
+                @is_subscribed[action.to_sym] = false
+              end
+            end
+          }
+        end
+      end
+
+      def set_basic_callback
+        @default_callback = proc { |message| do_message_callback(message) }
+
+        @topic_manager.on_suback = lambda do |topics|
+          action = @topic_manager.retrieve_action(topics[0])
+          @is_subscribed[action] ||= true unless action.nil?
+        end
+
+        @topic_manager.on_unsuback = lambda do |topics|
+          action = @topic_manager.retrieve_action(topics[0])
+          @is_subscribed[action] = false if action.nil?
+        end
+      end
+
+      def register_token_callback(token, callback, &block)
+        if callback.is_a?(Proc)
+          @token_callback[token] = callback
+        elsif block_given?
+          @token_callback[token] = block
+        end
+      end
+
+      def remove_token_callback(token)
+        @token_callback.delete(token)
+      end
+
+      def register_action_callback(action, callback, &block)
+        if callback.is_a?(Proc)
+          @topic_subscribed_callback[action] = callback
+        elsif block_given?
+          @topic_subscribed_callback[action] = block
+        end
+      end
+
+      def remove_action_callback(action)
+        @topic_subscribed_callback[action] = nil
+      end
+
+      def decresase_task_count(action)
+        @topic_subscribed_task_count[action] -= 1
+        if @topic_subscribed_task_count[action] <= 0
+          @topic_subscribed_task_count[action] = 0
+          unless @persistent_subscribe
+            @topic_manager.shadow_topic_unsubscribe(action.to_s)
+            @is_subscribed[action] = false
           end
-          @topic_manager.shadow_topic_publish(@shadow_name, "delete", json_payload)
-          @token_pool[current_token] = timer
-          Thread.new{ timer.wait }
-          current_token
-        }
+        end
       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)
+      ### 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_message_callback(message)
+        topic = message.topic
+        action = parse_action(topic)
+        type = parse_type(topic)
+        payload = message.payload
+        token = nil
+        new_version = -1
+        @parser_mutex.synchronize() {
+          @payload_parser.set_message(payload)
+          new_version = @payload_parser.get_attribute_value("version")
+          token = @payload_parser.get_attribute_value("clientToken")
         }
+        if %w(get update delete).include?(action)
+          if @token_pool.has_key?(token)
+            @token_pool[token].cancel
+            @token_pool.delete(token)
+            if type.eql?("accepted")
+              do_accepted(message, action.to_sym, token, type, new_version)
+            else
+              do_rejected(token, action, new_version)
+            end
+            @task_count_mutex.synchronize {
+              decresase_task_count(action.to_sym)
+            }
+          end
+        elsif %w(delta).include?(action)
+          do_delta(message, new_version)
+        end
       end
 
-      def remove_shadow_delta_callback
-        @general_action_mutex.synchronize(){
-          @topic_subscribe_callback.delete[:delta]
-          @topic_manager.shadow_topic_unsubscribe(@shadow_name, "delta")
-        }
+      def do_accepted(message, action, token, type, new_version)
+        if new_version && new_version >= @last_stable_version
+          @logger.info("The #{action} action with the token #{token} have been accepted.") if logger?
+          type.eql?("delete") ? @last_stable_version = -1 : @last_stable_version = new_version
+          Thread.new do
+            accepted_tasks(message, action, token)
+          end
+        else
+          @logger.warn("CATCH AN ACCEPTED #{action} BUT OUTDATED/INVALID VERSION (= #{new_version})\n") if logger?
+        end
       end
 
-      private
+      def accepted_tasks(message, action, token)
+        @topic_subscribed_callback[action].call(message)  unless @topic_subscribed_callback[action].nil?
+        @token_callback[token].call(message) if @token_callback.has_key?(token)
+        @token_callback.delete(token)
+      end
+
+      def do_rejected(token, action, new_version)
+        if new_version && new_version >= @last_stable_version
+          @logger.info("The #{action} action with the token #{token} have been rejected.") if logger?
+          @token_callback.delete(token)
+        else
+          @logger.warn("CATCH AN REJECTED #{action} BUT OUTDATED/INVALID VERSION (= #{new_version})\n") if logger?
+        end
+      end
+
+      def do_delta(message, new_version)
+        if new_version && new_version >= @last_stable_version
+          @logger.info("A delta action have been accepted.") if logger?
+          @last_stable_version = new_version
+          Thread.new { @topic_subscribed_callback[:delta].call(message) } unless @topic_subscribed_callback[:delta].nil?
+        else
+          @logger.warn("CATCH A DELTA BUT OUTDATED/INVALID VERSION (= #{new_version})\n") if logger?
+        end
+      end
+
+      def handle_subscription(action, timeout)
+        @topic_manager.shadow_topic_subscribe(action.to_s, @default_callback)
+        if @topic_manager.paho_client?
+          ref = Time.now + timeout
+          while !@is_subscribed[action] && handle_timeout(ref) do
+            sleep 0.0001
+          end
+        else
+          sleep 2
+        end
+      end
+
+      def handle_timeout(ref)
+        Time.now <= ref
+      end
 
       def parse_shadow_name(topic)
         topic.split('/')[2]

data/lib/aws_iot_device/mqtt_shadow_client/shadow_client.rb

@@ -5,56 +5,114 @@ 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
+      def initialize(*args)
+        unless args.last.nil?
+          config_attr(args.last)
+        else
+          @mqtt_client = MqttManager.new
+        end
       end
 
-      def connect
-        @mqtt_client.connect
+      def connect(*args, &block)
+        @mqtt_client.connect(*args)
+        self.logger.info("Connected to the AWS IoT platform") if logger?
+        if block_given?
+          begin
+            yield(self)
+          ensure
+            @mqtt_client.disconnect
+          end
+        end
       end
 
-      def topic_manager
-        @topic_manager = ShadowTopicManager.new(@mqtt_client)
+      def create_shadow_handler_with_name(shadow_name, persistent_subscribe=false)
+        @action_manager = ShadowActionManager.new(shadow_name, @mqtt_client, persistent_subscribe)
       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)
+      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 get_shadow(callback=nil, timeout=5)
-        @action_manager.shadow_get(callback, timeout)
+      def logger
+        @action_manager.logger
       end
 
-      def update_shadow(payload, callback=nil, timeout=5)
-        @action_manager.shadow_update(payload, callback, timeout)
+      def logger?
+        @action_manager.logger?
       end
 
-      def delete_shadow(callback=nil, timeout=5)
-        @action_manager.shadow_delete(callback, timeout)
+      def get_shadow(timeout=5, callback=nil, &block)
+        @action_manager.shadow_get(timeout, callback, &block)
       end
 
-      def register_delta_callback(callback)
-        @action_manager.register_shadow_delta_callback(callback)
+      def update_shadow(payload, timeout=5, callback=nil, &block)
+        @action_manager.shadow_update(payload, timeout, callback, &block)
       end
 
-      def remove_shadow_delta_callback
+      def delete_shadow(timeout=5, callback=nil, &block)
+        @action_manager.shadow_delete(timeout, callback, &block)
+      end
+
+      def register_get_callback(callback=nil, &block)
+        @action_manager.register_get_callback(callback, &block)
+      end
+
+      def register_update_callback(callback=nil, &block)
+        @action_manager.register_update_callback(callback, &block)
+      end
+
+      def register_delete_callback(callback=nil, &block)
+        @action_manager.register_delete_callback(callback, &block)
+      end
+
+      def register_delta_callback(callback=nil, &block)
+        @action_manager.register_shadow_delta_callback(callback, &block)
+      end
+
+      def remove_delta_callback
         @action_manager.remove_shadow_delta_callback
       end
 
+      def remove_get_callback
+        @action_manager.remove_get_callback
+      end
+
+      def remove_update_callback
+        @action_manager.remove_update_callback
+      end
+
+      def remove_delete_callback
+        @action_manager.remove_delete_callback
+      end
+
       def disconnect
         @mqtt_client.disconnect
       end
 
-      def configure_endpoint(host,port)
+      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
+
+
+      private
+
+      def config_attr(args)
+        shadow_attr = args.dup
+        shadow_attr.keep_if {|key| key == :shadow_name || key == :persistent_subscribe || key == :logger }
+        mqtt_attr = args        
+        mqtt_attr.delete_if {|key| key == :shadow_name || key == :persistent_subscribe || key == :logger }
+        @mqtt_client = MqttManager.new(mqtt_attr)
+        shadow_attr[:persistent_subscribe] ||= false
+        @action_manager = create_shadow_handler_with_name(shadow_attr[:shadow_name], shadow_attr[:persistent_subsrcibe]) if shadow_attr.has_key?(:shadow_name)
+      end
     end
   end
 end