rsmp 0.1.11 → 0.1.21

data/lib/rsmp/site.rb

@@ -4,12 +4,12 @@
 
 module RSMP
   class Site < Node
-    include SiteBase
+    include Components
 
     attr_reader :rsmp_versions, :site_settings, :logger, :proxies
 
     def initialize options={}
-      initialize_site
+      initialize_components
       handle_site_settings options
       super options
       @proxies = []
@@ -27,6 +27,7 @@ module RSMP
           { 'ip' => '127.0.0.1', 'port' => 12111 }
         ],
         'rsmp_versions' => ['3.1.1','3.1.2','3.1.3','3.1.4'],
+        'sxl' => 'traffic_light_controller',
         'sxl_version' => '1.0.7',
         'timer_interval' => 0.1,
         'watchdog_interval' => 1,
@@ -39,6 +40,9 @@ module RSMP
         'site_ready_timeout' => 1,
         'reconnect_interval' => 0.1,
         'send_after_connect' => true,
+        'components' => {
+          'C1' => {}
+        }
       }
       if options[:site_settings]
         converted = options[:site_settings].map { |k,v| [k.to_s,v] }.to_h   #convert symbol keys to string keys
@@ -66,7 +70,7 @@ module RSMP
       end
     end
 
-    def build_connector settings
+    def build_proxy settings
       SupervisorProxy.new settings
     end
 
@@ -77,7 +81,7 @@ module RSMP
     end
 
     def connect_to_supervisor task, supervisor_settings
-      proxy = build_connector({
+      proxy = build_proxy({
         site: self,
         task: @task,
         settings: @site_settings, 
@@ -106,7 +110,9 @@ module RSMP
           if @site_settings["reconnect_interval"] != :no
             # sleep until waken by reconnect() or the reconnect interval passed
             proxy.set_state :wait_for_reconnect
-            task.with_timeout(@site_settings["reconnect_interval"]) { @sleep_condition.wait }
+            task.with_timeout(@site_settings["reconnect_interval"]) do
+              @sleep_condition.wait
+            end
           else
             proxy.set_state :cannot_connect
             break
@@ -137,5 +143,6 @@ module RSMP
         proxy.stop
       end
     end
+
   end
 end

data/lib/rsmp/site_proxy.rb

@@ -2,13 +2,14 @@
 
 module RSMP  
   class SiteProxy < Proxy
-    include SiteBase
+    include Components
+    include SiteProxyWait
 
     attr_reader :supervisor, :site_id
 
     def initialize options
       super options
-      initialize_site
+      initialize_components
       @supervisor = options[:supervisor]
       @settings = @supervisor.supervisor_settings.clone
       @site_id = nil
@@ -23,6 +24,11 @@ module RSMP
       start_reader
     end
 
+    def stop
+      log "Closing connection to site", level: :info
+      super
+    end
+
     def connection_complete
       super
       log "Connection to site #{@site_id} established", level: :info
@@ -50,11 +56,20 @@ module RSMP
       end
     end
 
+    def process_command_response message
+      log "Received #{message.type}", message: message, level: :log
+      acknowledge message
+    end
+
+    def process_deferred
+      supervisor.process_deferred
+    end
+
     def version_accepted message
       log "Received Version message for site #{@site_id} using RSMP #{@rsmp_version}", message: message, level: :log
       start_timer
       acknowledge message
-      send_version @site_id, @rsmp_version
+      send_version @site_id, @settings['rsmp_versions']
       @version_determined = true
 
       if @settings['sites']
@@ -81,7 +96,7 @@ module RSMP
       component = @components[c_id]
       if component == nil
         if @site_settings == nil || @site_settings['components'] == nil
-          component = build_component c_id
+          component = build_component(id:c_id, type:nil)
           @components[c_id] = component
           log "Adding component #{c_id} to site #{@site_id}", level: :info
         else
@@ -123,16 +138,33 @@ module RSMP
       @supervisor.site_ids_changed
     end
 
-    def request_status component, status_list, timeout=nil
-      raise NotReady unless @state == :ready
+    def request_status component, status_list, options={}
+      raise NotReady unless ready?
+      m_id = options[:m_id] || RSMP::Message.make_m_id
+
+      # additional items can be used when verifying the response,
+      # but must to remove from the request
+      request_list = status_list.map { |item| item.slice('sCI','n') }
+
       message = RSMP::StatusRequest.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => status_list
+          "sS" => request_list,
+          "mId" => m_id
       })
-      send_message message
-      return message, wait_for_status_response(message: message, timeout: timeout)
+      if options[:collect]
+        result = nil
+        task = @task.async do |task|
+          collect_options = options[:collect].merge status_list: status_list
+          collect_status_responses task, collect_options, m_id
+        end
+        send_message message
+        return message, task.wait
+      else
+        send_message message
+        message
+      end
     end
 
     def process_status_response message
@@ -140,36 +172,37 @@ module RSMP
       acknowledge message
     end
 
-    def wait_for_status_response options
-      raise ArgumentError unless options[:message]
-      item = @archive.capture(@task, options.merge(
-        type: ['StatusResponse','MessageNotAck'],
-        with_message: true,
-        num: 1
-      )) do |item|
-        if item[:message].type == 'MessageNotAck'
-          next item[:message].attribute('oMId') == options[:message].m_id
-        elsif item[:message].type == 'StatusResponse'
-          next item[:message].attribute('cId') == options[:message].attribute('cId')
-        end
-      end
-      item[:message] if item
-    end
+    def subscribe_to_status component, status_list, options={}
+      raise NotReady unless ready?
+      m_id = options[:m_id] || RSMP::Message.make_m_id
+      
+      # additional items can be used when verifying the response,
+      # but must to remove from the subscribe message
+      subscribe_list = status_list.map { |item| item.slice('sCI','n','uRt') }
 
-    def subscribe_to_status component, status_list, timeout
-      raise NotReady unless @state == :ready
       message = RSMP::StatusSubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => status_list
+          "sS" => subscribe_list,
+          'mId' => m_id
       })
-      send_message message
-      return message, wait_for_status_update(component: component, timeout: timeout)
+      if options[:collect]
+        result = nil
+        task = @task.async do |task|
+          collect_options = options[:collect].merge status_list: status_list
+          collect_status_updates task, collect_options, m_id
+        end
+        send_message message
+        return message, task.wait
+      else
+        send_message message
+        message
+      end
     end
 
     def unsubscribe_to_status component, status_list
-      raise NotReady unless @state == :ready
+      raise NotReady unless ready?
       message = RSMP::StatusUnsubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
@@ -185,48 +218,42 @@ module RSMP
       acknowledge message
     end
 
-    def wait_for_status_update options={}
-      raise ArgumentError unless options[:component]
-      item = @archive.capture(@task,options.merge(type: "StatusUpdate", with_message: true, num: 1)) do |item|
-        # TODO check components
-        found = false
-        sS = item[:message].attributes['sS']
-        sS.each do |status|
-          break if options[:sCI] && options[:sCI] != status['sCI']
-          break if options[:n] && options[:n] != status['n']
-          break if options[:q] && options[:q] != status['q']
-          break if options[:s] && options[:s] != status['s']
-          found = true
-          break
-        end
-        found
-      end
-      item[:message] if item
-    end
-
-    def send_command component, args
-      raise NotReady unless @state == :ready
-      message = RSMP::CommandRequest.new({
+    def send_alarm_acknowledgement component, alarm_code
+      message = RSMP::AlarmAcknowledged.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "arg" => args
+          "aCId" => alarm_code,
+          "xACId" => '',
+          "xNACId" => '',
+          "aSp" => 'Acknowledge'
       })
       send_message message
       message
     end
 
-    def process_command_response message
-      log "Received #{message.type}", message: message, level: :log
-      acknowledge message
-    end
-
-    def wait_for_command_response options
-      raise ArgumentError unless options[:component]
-      item = @archive.capture(@task,options.merge(num: 1, type: "CommandResponse", with_message: true)) do |item|
-         # check component
+    def send_command component, command_list, options={}
+      raise NotReady unless ready?
+      m_id = options[:m_id] || RSMP::Message.make_m_id
+      message = RSMP::CommandRequest.new({
+          "ntsOId" => '',
+          "xNId" => '',
+          "cId" => component,
+          "arg" => command_list,
+          "mId" => m_id
+      })
+      if options[:collect]
+        result = nil
+        task = @task.async do |task|
+          collect_options = options[:collect].merge command_list: command_list
+          collect_command_responses task, collect_options, m_id
+        end
+        send_message message
+        return message, task.wait
+      else
+        send_message message
+        message
       end
-      item[:message] if item
     end
 
     def set_watchdog_interval interval
@@ -261,6 +288,5 @@ module RSMP
       site_ids_changed
     end
 
-
   end
-end
+end

data/lib/rsmp/site_proxy_wait.rb

@@ -0,0 +1,181 @@
+# waiting for various types of messages and reponses from remote sites
+module RSMP
+  module SiteProxyWait
+
+    def wait_for_status_updates parent_task, options={}, &send_block
+      send_while_collecting parent_task, send_block do |task, m_id|
+        collect_status_updates_or_responses task, 'StatusUpdate', options, m_id
+      end
+    end
+
+    def wait_for_status_responses parent_task, options={}, &send_block
+      send_while_collecting parent_task, send_block do |task, m_id|
+        collect_status_updates_or_responses task, 'StatusResponse', options, m_id
+      end
+    end
+
+    def wait_for_command_responses parent_task, options={}, &send_block
+      send_while_collecting parent_task, send_block do |task, m_id|
+        collect_command_responses task, options, m_id
+      end
+    end
+
+    def wait_for_alarm options={}
+      matching_alarm = nil
+      item = collect(@task,options.merge(type: "Alarm", with_message: true, num: 1)) do |item|
+        # TODO check components
+        matching_alarm = nil
+        alarm = item[:message]
+        next if options[:aCId] && options[:aCId] != alarm.attribute("aCId")
+        next if options[:aSp] && options[:aSp] != alarm.attribute("aSp")
+        next if options[:aS] && options[:aS] != alarm.attribute("aS")
+        matching_alarm = alarm
+        break
+      end
+      if item
+        { message: item[:message], status: matching_alarm }
+      end
+    end
+
+    def collect_status_updates task, options, m_id
+      collect_status_updates_or_responses task, 'StatusUpdate', options, m_id
+    end
+
+    def collect_status_responses task, options, m_id
+      collect_status_updates_or_responses task, 'StatusResponse', options, m_id
+    end
+
+    def collect_command_responses parent_task, options, m_id
+      task.annotate "wait for command response"
+      want = options[:command_list].clone
+      result = {}
+      item = collect(parent_task,options.merge({
+        type: ['CommandResponse','MessageNotAck'],
+        num: 1
+      })) do |item|
+        message = item[:message]
+        if message.is_a?(MessageNotAck)
+          if message.attribute('oMId') == m_id
+            # set result to an exception, but don't raise it.
+            # this will be returned by the task and stored as the task result
+            # when the parent task call wait() on the task, the exception
+            # will be raised in the parent task, and caught by rspec.
+            # rspec will then show the error and record the test as failed
+            m_id_short = RSMP::Message.shorten_m_id m_id, 8
+            result = RSMP::MessageRejected.new "Command request #{m_id_short} was rejected: #{message.attribute('rea')}"
+            next true   # done, no more messages wanted
+          else
+            false
+          end
+        else
+          found = []
+          # look through querues
+          want.each_with_index do |query,i|
+            # look through items in message
+            item[:message].attributes['rvs'].each do |input|
+              ok = command_match? query, input
+              if ok
+                result[query] = input
+                found << i   # record which queries where matched succesfully
+              end
+            end
+          end
+          # remove queries that where matched
+          found.sort.reverse.each do |i|
+            want.delete_at i
+          end
+          want.empty? # any queries left to match?
+        end
+      end
+      result
+    rescue Async::TimeoutError
+      raise RSMP::TimeoutError.new "Did not receive command response to #{m_id} within #{options[:timeout]}s"
+    end
+
+    def collect_status_updates_or_responses task, type, options, m_id
+      want = options[:status_list]
+      result = {}
+      # wait for a status update
+      item = collect(task,options.merge({
+        type: [type,'MessageNotAck'],
+        num: 1
+      })) do |item|
+        message = item[:message]
+        if message.is_a?(MessageNotAck)
+          if message.attribute('oMId') == m_id
+            # set result to an exception, but don't raise it.
+            # this will be returned by the task and stored as the task result
+            # when the parent task call wait() on the task, the exception
+            # will be raised in the parent task, and caught by rspec.
+            # rspec will then show the error and record the test as failed
+            m_id_short = RSMP::Message.shorten_m_id m_id, 8
+            result = RSMP::MessageRejected.new "Status request #{m_id_short} was rejected: #{message.attribute('rea')}"
+            next true   # done, no more messages wanted
+          end
+          false
+        else
+          found = []
+          # look through querues
+          want.each_with_index do |query,i|
+            # look through status items in message
+            item[:message].attributes['sS'].each do |input|
+              ok = status_match? query, input
+              if ok
+                result[query] = input
+                found << i   # record which queries where matched succesfully
+              end
+            end
+          end
+          # remove queries that where matched
+          found.sort.reverse.each do |i|
+            want.delete_at i
+          end
+          want.empty? # any queries left to match?
+        end
+      end
+      result
+    rescue Async::TimeoutError
+      type_str = {'StatusUpdate'=>'update', 'StatusResponse'=>'response'}[type]
+      raise RSMP::TimeoutError.new "Did not received status #{type_str} in reply to #{m_id} within #{options[:timeout]}s"
+    end
+
+    def status_match? query, item
+      return false if query['sCI'] && query['sCI'] != item['sCI']
+      return false if query['n'] && query['n'] != item['n']
+      return false if query['q'] && query['q'] != item['q']
+      if query['s'].is_a? Regexp
+        return false if query['s'] && item['s'] !~ query['s']
+      else
+        return false if query['s'] && item['s'] != query['s']
+      end
+      true
+    end
+
+    def command_match? query, item
+      return false if query['cCI'] && query['cCI'] != item['cCI']
+      return false if query['n'] && query['n'] != item['n']
+      if query['v'].is_a? Regexp
+        return false if query['v'] && item['v'] !~ query['v']
+      else
+        return false if query['v'] && item['v'] != query['v']
+      end
+      true
+    end
+
+    def send_while_collecting parent_task, send_block, &collect_block
+      m_id = RSMP::Message.make_m_id    # make message id so we can start waiting for it
+
+      # wait for command responses in an async task
+      task = parent_task.async do |task|
+        collect_block.call task, m_id
+      end
+
+       # call block, it should send command request using the given m_id
+      send_block.call m_id
+
+      # wait for the response and return it, raise exception if NotAck received, it it timed out
+      task.wait
+    end
+
+  end
+end