rsmp 0.1.19 → 0.1.21

data/lib/rsmp/notifier.rb

@@ -0,0 +1,24 @@
+# Distributes messages to listeners
+
+module RSMP
+  module Notifier
+
+    def initialize_distributor
+      @listeners = []
+    end
+
+    def add_listener listener
+      raise ArgumentError unless listener
+      @listeners << listener unless @listeners.include? listener
+    end
+
+    def remove_listener listener
+      raise ArgumentError unless listener
+      @listeners.delete listener
+    end
+
+    def notify item
+      @listeners.each { |listener| listener.notify item }
+    end
+  end
+end

data/lib/rsmp/proxy.rb

@@ -1,22 +1,40 @@
-# Base class for a connection to a remote site or supervisor.
+# Logging class for a connection to a remote site or supervisor.
 
 module RSMP  
-  class Proxy < Base
+  class Proxy
+    include Logging
     include Wait
+    include Notifier
 
-    attr_reader :state, :archive, :connection_info, :sxl, :task
+    attr_reader :state, :archive, :connection_info, :sxl, :task, :collector
 
     def initialize options
-      super options
+      initialize_logging options
       @settings = options[:settings]
       @task = options[:task]
       @socket = options[:socket]
       @ip = options[:ip]
       @connection_info = options[:info]
       @sxl = nil
+      initialize_distributor
+
+      prepare_collection options[:settings]['collect']
+
       clear
     end
 
+    def prepare_collection num
+      if num
+        @collector = RSMP::Collector.new self, num: num, ingoing: true, outgoing: true
+        add_listener @collector
+      end
+    end
+
+    def collect task, options, &block
+      probe = RSMP::Collector.new self, options
+      probe.collect task, &block
+    end
+
     def run
       start
       @reader.wait if @reader
@@ -213,6 +231,7 @@ module RSMP
       message.direction = :out
       expect_acknowledgement message
       @protocol.write_lines message.json
+      notify message: message
       log_send message, reason
     rescue EOFError, IOError
       buffer_message message
@@ -243,6 +262,7 @@ module RSMP
       attributes = Message.parse_attributes json
       message = Message.build attributes, json
       message.validate sxl
+      notify message: message
       expect_version_message(message) unless @version_determined
       process_message message
       process_deferred
@@ -342,7 +362,7 @@ module RSMP
     def wait_for_state state, timeout
       states = [state].flatten
       return if states.include?(@state)
-      wait_for(@state_condition,timeout) do |s|
+      wait_for(@state_condition,timeout) do
         states.include?(@state)
       end
       @state

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 = []

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
@@ -55,6 +56,11 @@ 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
@@ -132,38 +138,33 @@ module RSMP
       @supervisor.site_ids_changed
     end
 
-    def fetch_status parent_task, options
-      wait_for_status_responses(parent_task,options) do |m_id|
-        request_status options.merge(m_id: m_id)
-      end
-    end
+    def request_status component, status_list, options={}
+      raise NotReady unless ready?
+      m_id = options[:m_id] || RSMP::Message.make_m_id
 
-    # Convert from a short ruby hash:
-    # {:S0001=>[:signalgroupstatus, :cyclecounter, :basecyclecounter, :stage]}
-    # to an rsmp-style list:
-    # [{"sCI"=>"S0001", "n"=>"signalgroupstatus"}, {"sCI"=>"S0001", "n"=>"cyclecounter"}, {"sCI"=>"S0001", "n"=>"basecyclecounter"}, {"sCI"=>"S0001", "n"=>"stage"}]
-    #
-    # If the input is already an array, just return it
-    def convert_status_list list
-      return list.clone if list.is_a? Array
-      list.map do |status_code_id,names|
-        names.map do |name|
-          { 'sCI' => status_code_id.to_s, 'n' => name.to_s }
-        end
-      end.flatten
-    end
+      # 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') }
 
-    def request_status options
-      raise NotReady unless ready?
       message = RSMP::StatusRequest.new({
           "ntsOId" => '',
           "xNId" => '',
-          "cId" => options[:component],
-          "sS" => convert_status_list(options[:status_list]),
-          "mId" => options[:m_id]
+          "cId" => component,
+          "sS" => request_list,
+          "mId" => m_id
       })
-      send_message message
-      message
+      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
@@ -173,15 +174,31 @@ module RSMP
 
     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') }
+
       message = RSMP::StatusSubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => convert_status_list(status_list),
-          'mId'=>options[:m_id]
+          "sS" => subscribe_list,
+          'mId' => m_id
       })
-      send_message message
-      return message
+      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
@@ -190,7 +207,7 @@ module RSMP
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => convert_status_list(status_list)
+          "sS" => status_list
       })
       send_message message
       message
@@ -201,36 +218,6 @@ module RSMP
       acknowledge message
     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 wait_for_alarm options={}
-      raise ArgumentError.new("component argument is missing") unless options[:component]
-      matching_alarm = nil
-      item = @archive.capture(@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 send_alarm_acknowledgement component, alarm_code
       message = RSMP::AlarmAcknowledged.new({
           "ntsOId" => '',
@@ -245,33 +232,28 @@ module RSMP
       message
     end
 
-    def wait_for_alarm_acknowledgement_response options
-      raise ArgumentError.new("component argument is missing") unless options[:component]
-      item = @archive.capture(@task,options.merge(
-        num: 1,
-        type: ['AlarmAcknowledgedResponse','MessageNotAck'],
-        with_message: true
-      )) do |item|
-        if item[:message].type == 'MessageNotAck'
-          next item[:message].attribute('oMId') == options[:message].m_id
-        elsif item[:message].type == 'AlarmAcknowledgedResponse'
-          next item[:message].attribute('cId') == options[:message].attribute('cId')
-        end
-      end
-      item[:message] if item
-    end
-
-    def send_command component, args, options={}
+    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" => args,
-          "mId" => options[:m_id]
+          "arg" => command_list,
+          "mId" => m_id
       })
-      send_message message
-      message
+      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
     end
 
     def set_watchdog_interval interval

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