rsmp 0.2.2 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55265e42f3956b7af530055680da60f82c84d34d7febd19286bf7c78bd2048f8
-  data.tar.gz: 445498a67e24c6b63cbfceca009ad736e962717eb89e92239bdd7ad4870cf72f
+  metadata.gz: 3e3cdaa079ff62d328eec49b03368afeabc463dd8e805a3ca6cd8d04237deefa
+  data.tar.gz: e4c49d13767b56e0d0efe552406aac32a714b0ff162e680e65716118b88eb280
 SHA512:
-  metadata.gz: '0854ca1835fc15e8ccd10059c3f6f30638daf54677d215799eabae0f87fa4de11c9f825319f10ba92f9d25052fc90927fb54eb9f5df19cb714ba9ead236effbf'
-  data.tar.gz: 5d60090a4de455ca03fcb0fc182977ff938d0c8df9ea0bfb69d1dc985546c6de6ece83296bb25a64cc5f9e3b67d94e7694ec9702e08877bd6d9e05853d700ebd
+  metadata.gz: fa218c2c4404e1a8fdb06c89a60707004adb83ad63b6f9b41a6f8128b8a251112000a6b4f5e6b0cef4109332171172b9c7171e2b7684741d846eafe4f1b573a9
+  data.tar.gz: c221e735fce70db77cd0772c336904d7ac707d2525270bed8c4559c103fec632c5f66717b2cec98f81facfeb8824f0acda1dd924a68d5d99e126c114e9e26536

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rsmp (0.2.2)
+    rsmp (0.3.2)
       async (~> 1.29.1)
       async-io (~> 1.32.1)
       colorize (~> 0.8.1)

data/lib/rsmp/collector.rb

@@ -1,21 +1,20 @@
-# Collects matching ingoing and/or outgoing messages and
-# wakes up the client once the desired amount has been collected.
-# Can listen for ingoing and/or outgoing messages.
-
 module RSMP
-  class Collector < Listener
 
+  # Collects ingoing and/or outgoing messages.
+  # Can filter by message type and wakes up the client once the desired number of messages has been collected.
+  class Collector < Listener
     attr_reader :condition, :messages, :done
 
     def initialize proxy, options={}
       super proxy, options
+      @options = options.clone
       @ingoing = options[:ingoing] == nil ? true  : options[:ingoing]
       @outgoing = options[:outgoing] == nil ? false : options[:outgoing]
-      @messages = []
       @condition = Async::Notification.new
-      @done = false
-      @options = options
-      @num = options[:num]
+      @title = options[:title] || [@options[:type]].flatten.join('/')
+      @options[:timeout] ||= 1
+      @options[:num] ||= 1
+      reset
     end
 
     def inspect
@@ -34,17 +33,9 @@ module RSMP
       @condition.wait
     end
 
-    def collect_for task, duration
-      siphon do
-        task.sleep duration
-      end
-    end
-
     def collect task, options={}, &block
-      @num = options[:num] if options[:num]
-      @options[:timeout] = options[:timeout] if options[:timeout]
+      @options.merge! options
       @block = block
-
       unless @done
         listen do
           task.with_timeout(@options[:timeout]) do
@@ -52,51 +43,105 @@ module RSMP
           end
         end
       end
+      return @error if @error
+      self
+    rescue Async::TimeoutError
+      str = "Did not receive #{@title}"
+      str << " in response to #{options[:m_id]}" if options[:m_id]
+      str << " within #{@options[:timeout]}s"
+      raise RSMP::TimeoutError.new str
+    end
 
-      if @num == 1
-        @messages = @messages.first       # if one message was requested, return it instead of array
-      else
-        @messages = @messages.first @num  # return array, but ensure we never return more than requested
-      end
-      @messages
+    # Get the collected messages.
+    # If one message was requested, return it as a plain object instead of array
+    def result
+      return @messages.first if @options[:num] == 1     
+      @messages.first @options[:num] 
     end
 
+    # Clear all query results
     def reset
-      @message.clear
+      @messages = []
+      @error = nil
       @done = false
     end
 
+    # Check if we receive a NotAck related to initiating request, identified by @m_id.
+    def check_not_ack message
+      return unless @options[:m_id]
+      if message.is_a?(MessageNotAck)
+        if message.attribute('oMId') == @options[:m_id]
+          m_id_short = RSMP::Message.shorten_m_id @options[:m_id], 8
+          @error = RSMP::MessageRejected.new("#{@title} #{m_id_short} was rejected: #{message.attribute('rea')}")
+          complete
+        end
+        false
+      end
+    end
+
+    # Handle message. and return true when we're done collecting
     def notify message
       raise ArgumentError unless message
+      raise RuntimeError.new("can't process message when already done") if @done
+      check_not_ack(message)
       return true if @done
-      return if message.direction == :in && @ingoing == false
-      return if message.direction == :out && @outgoing == false
-      if matches? message
-        @messages << message
-        if @num && @messages.size >= @num
-          @done = true
-          @proxy.remove_listener self
-          @condition.signal
-        end
+      check_match message
+      complete if done?
+      @done
+    end
+
+    # Match message against our collection criteria
+    def check_match message
+      matched = match? message
+      if matched == true
+        keep message
+      elsif matched == false
+        forget message
       end
     end
 
-    def matches? message
-      raise ArgumentError unless message
+    # Have we collected the required number of messages?
+    def done?
+      @options[:num] && @messages.size >= @options[:num]
+    end
+
+    # Called when we're done collecting. Remove ourself as a listener,
+    # se we don't receive message notifications anymore
+    def complete
+      @done = true
+      @proxy.remove_listener self
+      @condition.signal
+    end
+
+    # Store a message in the result array
+    def keep message
+      @messages << message
+    end
+
+    # Remove a message from the result array
+    def forget message
+      @messages.delete message
+    end
 
+    # Check a message against our match criteria
+    # Return true if there's a match
+    def match? message
+      raise ArgumentError unless message
+      return if message.direction == :in && @ingoing == false
+      return if message.direction == :out && @outgoing == false
       if @options[:type]
-        return false if message == nil
+        return if message == nil
         if @options[:type].is_a? Array
-          return false unless @options[:type].include? message.type
+          return unless @options[:type].include? message.type
         else
-          return false unless message.type == @options[:type]
+          return unless message.type == @options[:type]
         end
       end
       if @options[:component]
-        return false if message.attributes['cId'] && message.attributes['cId'] != @options[:component]
+        return if message.attributes['cId'] && message.attributes['cId'] != @options[:component]
       end
       if @block
-        return false if @block.call(message) == false
+        return if @block.call(message) == false
       end
       true
     end

data/lib/rsmp/components.rb

@@ -13,6 +13,7 @@ module RSMP
 
     def setup_components settings
       return unless settings
+      check_main_component settings
       settings.each_pair do |type,components_by_type|
         components_by_type.each_pair do |id,settings|
           @components[id] = build_component(id:id, type:type, settings:settings)
@@ -20,6 +21,15 @@ module RSMP
       end
     end
 
+    def check_main_component settings
+      unless settings['main'] && settings['main'].size >= 1
+        raise ConfigurationError.new("main component must be defined") 
+      end
+      if settings['main'].size > 1
+        raise ConfigurationError.new("only one main component can be defined, found #{settings['main'].keys.join(', ')}") 
+      end
+    end
+
     def add_component component
       @components[component.c_id] = component
     end

data/lib/rsmp/matcher.rb

@@ -0,0 +1,195 @@
+module RSMP
+
+  # Base class for waiting for specific status or command responses, specified by
+  # a list of queries. Queries are defined as an array of hashes, e.g
+  # [
+  #   {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"securityCode", "v"=>"1111"},
+  #   {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"year", "v"=>"2020"},
+  #   {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>/\d+/}
+  #  ]
+  #
+  # Note that queries can contain regex patterns for values, like /\d+/ in the example above.
+  #
+  # When an input messages is received it typically contains several items, eg:
+  # [
+  #   {"cCI"=>"M0104", "n"=>"month", "v"=>"9", "age"=>"recent"},
+  #   {"cCI"=>"M0104", "n"=>"day", "v"=>"29", "age"=>"recent"},
+  #   {"cCI"=>"M0104", "n"=>"hour", "v"=>"17", "age"=>"recent"}
+  # ]
+  #
+  # Each input item is matched against each of the queries.
+  # If a match is found, it's stored in the @results hash, with the query as the key,
+  # and a mesage and status as the key. In the example above, this query:
+  #
+  # {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>/\d+/}
+  #
+  # matches this input:
+  #
+  # {"cCI"=>"M0104", "n"=>"month", "v"=>"9", "age"=>"recent"}
+  # 
+  # And the result is stored as:
+  # {
+  #   {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>/\d+/} =>
+  #     { <StatusResponse message>, {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>"9"} }
+  # }
+  #
+  #
+  class Matcher < Collector
+    attr_reader :queries
+
+    # Initialize with a list a wanted statuses
+    def initialize proxy, want, options={}
+      super proxy, options.merge( ingoing: true, outgoing: false)
+      @queries = {}
+      want.each do |query|
+        @queries[query] = nil
+      end
+    end
+
+    # Get the results, as a hash of queries => results
+    def result
+      @queries
+    end
+
+    # Get messages from results
+    def messages
+      @queries.map { |query,result| result[:message] }.uniq
+    end
+
+    # Get items from results
+    def items
+      @queries.map { |query,result| result[:item] }.uniq
+    end
+
+    # Are there queries left to match?
+    def done?
+      @queries.values.all? { |result| result != nil }
+    end
+
+    # Get a simplified hash of queries, with values set to either true or false,
+    # indicating which queries have been matched.
+    def status
+      @queries.transform_values{ |v| v != nil }
+    end
+
+    # Get a simply array of bools, showing which queries ahve been matched.
+    def summary
+      @queries.values.map { |v| v != nil }
+    end
+
+    # Mark a query as matched, by linking it to the matched item and message
+    def keep query, message, item
+      @queries[query] = { message:message, item:item }
+    end
+
+    # Mark a query as not matched
+    def forget query
+      @queries[query] = nil
+    end
+
+    # Check if a messages matches our criteria.
+    # We iterate through each of the status items or return values in the message
+    # Breaks as soon as where done matching all queries
+    def check_match message
+      return unless match?(message)
+      @queries.keys.each do |query|       # look through queries
+        get_items(message).each do |item|  # look through status items in message
+          break if check_item_match message, query, item
+        end
+      end
+    end
+
+    # Check if an item matches, and mark query as matched/unmatched accordingly.
+    def check_item_match message, query, item
+      matched = match_item? query, item
+      if matched == true
+        keep query, message, item
+        true
+      elsif matched == false
+        forget query
+        true
+      end
+    end
+  end
+
+  # Class for waiting for specific command responses
+  class CommandResponseMatcher < Matcher
+    def initialize proxy, want, options={}
+      super proxy, want, options.merge(
+        type: ['CommandResponse','MessageNotAck'],
+        title:'command response'
+      )
+    end
+
+    # Get items, in our case the return values
+    def get_items message
+      message.attributes['rvs']
+    end
+
+    # Match a return value item against a query
+    def match_item? query, item
+      return nil if query['cCI'] && query['cCI'] != item['cCI']
+      return nil 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
+  end
+
+  # Base class for waiting for status updates or responses
+  class StatusUpdateOrResponseMatcher < Matcher
+    def initialize proxy, want, options={}
+      super proxy, want, options.merge
+    end
+
+    # Get items, in our case status values
+    def get_items message
+      message.attributes['sS']
+    end
+
+    # Match a status value against a query
+    def match_item? query, item
+      return nil if query['sCI'] && query['sCI'] != item['sCI']
+      return nil if query['cO'] && query['cO'] != item['cO']
+      return nil 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
+  end
+
+  # Class for waiting for specific status responses
+  class StatusResponseMatcher < StatusUpdateOrResponseMatcher
+    def initialize proxy, want, options={}
+      super proxy, want, options.merge(
+        type: ['StatusResponse','MessageNotAck'],
+        title: 'status response'
+      )
+    end
+  end
+
+  # Class for waiting for specific status responses
+  class StatusUpdateMatcher < StatusUpdateOrResponseMatcher
+    def initialize proxy, want, options={}
+      super proxy, want, options.merge(
+        type: ['StatusUpdate','MessageNotAck'],
+        title:'status update'
+      )
+    end
+  end
+
+  # Class for waiting for an aggregated status response
+  class AggregatedStatusMatcher < Collector
+    def initialize proxy, options={}
+      required = { type: ['AggregatedStatus','MessageNotAck'], title: 'aggregated status' }
+      super proxy, options.merge(required)
+    end
+  end
+end

data/lib/rsmp/proxy.rb

@@ -59,6 +59,7 @@ module RSMP
     def collect task, options, &block
       collector = RSMP::Collector.new self, options
       collector.collect task, &block
+      collector
     end
 
     def run
@@ -123,7 +124,11 @@ module RSMP
           message = process_packet json
           duration = Time.now - beginning
           ms = (duration*1000).round(4)
-          per_second = (1.0 / duration).round
+          if duration > 0
+            per_second = (1.0 / duration).round
+          else
+            per_second = Float::INFINITY
+          end
           if message
             type = message.type
             m_id = Logger.shorten_message_id(message.m_id)
@@ -202,7 +207,6 @@ module RSMP
     def watchdog_send_timer now
       return unless @watchdog_started  
       return if @site_settings['intervals']['watchdog'] == :never
-      
       if @latest_watchdog_send_at == nil
         send_watchdog now
       else

data/lib/rsmp/site.rb

@@ -41,10 +41,16 @@ module RSMP
         },
         'send_after_connect' => true,
         'components' => {
-          'C1' => {}
+          'main' => {
+            'C1' => {}
+          }
         }
       }
-      
+      # only one main component can be defined, so replace the default if options define one
+      if options.dig(:site_settings,'components','main')
+        defaults['components']['main'] = options[:site_settings]['components']['main']
+      end
+
       @site_settings = defaults.deep_merge options[:site_settings]
       check_sxl_version
       setup_components @site_settings['components']

data/lib/rsmp/site_proxy.rb

@@ -3,7 +3,6 @@
 module RSMP  
   class SiteProxy < Proxy
     include Components
-    include SiteProxyWait
 
     attr_reader :supervisor, :site_id
 
@@ -12,7 +11,7 @@ module RSMP
       initialize_components
       @supervisor = options[:supervisor]
       @settings = @supervisor.supervisor_settings.clone
-      @site_id = nil
+      @site_id = options[:site_id]
     end
 
     def revive options
@@ -43,7 +42,7 @@ module RSMP
 
     def connection_complete
       super
-       sanitized_sxl_version = RSMP::Schemer.sanitize_version(@site_sxl_version)
+      sanitized_sxl_version = RSMP::Schemer.sanitize_version(@site_sxl_version)
       log "Connection to site #{@site_id} established, using core #{@rsmp_version}, #{@sxl} #{sanitized_sxl_version}", level: :info
     end
 
@@ -86,7 +85,6 @@ module RSMP
       acknowledge message
       send_version @site_id, rsmp_versions
       @version_determined = true
-
     end
 
     def validate_ready action
@@ -104,9 +102,8 @@ module RSMP
           "mId" => m_id
       })
       if options[:collect]
-        result = nil
         task = @task.async do |task|
-          wait_for_aggregated_status task, options[:collect], m_id
+          collect_aggregated_status task, options[:collect].merge(m_id: m_id)
         end
         send_message message, validate: options[:validate]
         return message, task.wait
@@ -178,7 +175,7 @@ module RSMP
       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
+      # but must be removed from the request
       request_list = status_list.map { |item| item.slice('sCI','n') }
 
       message = RSMP::StatusRequest.new({
@@ -188,23 +185,8 @@ module RSMP
           "sS" => request_list,
           "mId" => m_id
       })
-      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, validate: options[:validate]
-
-        # task.wait return the result of the task. if the task raised an exception
-        # it will be reraised. but that mechanish does not work if multiple values
-        # are returned. so manually raise if first element is an exception
-        result = task.wait
-        raise result.first if result.first.is_a? Exception
-        return message, *result
-      else
-        send_message message, validate: options[:validate]
-        message
+      send_while_collecting message, options do |task|
+        collect_status_responses task, status_list, options[:collect].merge(m_id: m_id)
       end
     end
 
@@ -213,6 +195,13 @@ module RSMP
       acknowledge message
     end
 
+    def send_while_collecting message, options, &block
+      task = @task.async { |task| yield task } if options[:collect]
+      send_message message, validate: options[:validate]
+      return message, task.wait if task
+      message
+    end
+
     def subscribe_to_status component, status_list, options={}
       validate_ready 'subscribe to status'
       m_id = options[:m_id] || RSMP::Message.make_m_id
@@ -228,23 +217,8 @@ module RSMP
           "sS" => subscribe_list,
           'mId' => m_id
       })
-      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, validate: options[:validate]
-
-        # task.wait return the result of the task. if the task raised an exception
-        # it will be reraised. but that mechanish does not work if multiple values
-        # are returned. so manually raise if first element is an exception
-        result = task.wait
-        raise result.first if result.first.is_a? Exception
-        return message, *result
-      else
-        send_message message, validate: options[:validate]
-        message
+      send_while_collecting message, options do |task|
+         collect_status_updates task, status_list, options[:collect].merge(m_id: m_id)
       end
     end
 
@@ -289,23 +263,8 @@ module RSMP
           "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, validate: options[:validate]
-
-        # task.wait return the result of the task. if the task raised an exception
-        # it will be reraised. but that mechanish does not work if multiple values
-        # are returned. so manually raise if first element is an exception
-        result = task.wait
-        raise result.first if result.first.is_a? Exception
-        return message, *result
-      else
-        send_message message, validate: options[:validate]
-        message
+      send_while_collecting message, options do |task|
+        collect_command_responses task, command_list, options[:collect].merge(m_id: m_id)
       end
     end
 
@@ -381,5 +340,37 @@ module RSMP
       @supervisor.notify_error e, options if @supervisor
     end
 
+    def wait_for_alarm parent_task, options={}
+      matching_alarm = nil
+      message = collect(parent_task,options.merge(type: "Alarm", with_message: true, num: 1)) do |message|
+        # TODO check components
+        matching_alarm = nil
+        alarm = 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: message, status: matching_alarm }
+      end
+    end
+
+    def collect_status_updates task, status_list, options
+      StatusUpdateMatcher.new(self, status_list, options).collect task
+    end
+
+    def collect_status_responses task, status_list, options
+      StatusResponseMatcher.new(self, status_list, options).collect task
+    end
+
+    def collect_command_responses task, command_list, options
+      CommandResponseMatcher.new(self, command_list, options).collect task
+    end
+
+    def collect_aggregated_status task, options
+      AggregatedStatusMatcher.new(self, options).collect task
+    end
   end
 end

data/lib/rsmp/site_proxy_wait.rb

@@ -1,171 +0,0 @@
-# waiting for various types of messages and reponses from remote sites
-module RSMP
-  module SiteProxyWait
-
-    def wait_for_alarm parent_task, options={}
-      matching_alarm = nil
-      message = collect(parent_task,options.merge(type: "Alarm", with_message: true, num: 1)) do |message|
-        # TODO check components
-        matching_alarm = nil
-        alarm = 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: 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 = {}
-      messages = []
-      collect(parent_task,options.merge({
-        type: ['CommandResponse','MessageNotAck'],
-        num: 1
-      })) do |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
-          add = false
-          # look through querues
-          want.each_with_index do |query,i|
-            # look through items in message
-            message.attributes['rvs'].each do |input|
-              matching = command_match? query, input
-              if matching == true
-                result[query] = input
-                add = true
-              elsif matching == false
-                result.delete query
-              end
-            end
-          end
-          messages << message if add
-          result.size == want.size # any queries left to match?
-        end
-      end
-      return result, messages
-    rescue Async::TimeoutError
-      raise RSMP::TimeoutError.new "Did not receive correct 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].clone
-      result = {}
-      messages = []
-      # wait for a status update
-      collect(task,options.merge({
-        type: [type,'MessageNotAck'],
-        num: 1
-      })) do |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 = []
-          add = false
-          # look through querues
-          want.each_with_index do |query,i|
-            # look through status items in message
-            message.attributes['sS'].each do |input|
-              matching = status_match? query, input
-              if matching == true
-                result[query] = input
-                add = true
-              elsif matching == false
-                result.delete query
-              end
-            end
-          end
-          messages << message if add
-          result.size == want.size # any queries left to match?
-        end
-      end
-      return result, messages
-    rescue Async::TimeoutError
-      type_str = {'StatusUpdate'=>'update', 'StatusResponse'=>'response'}[type]
-      raise RSMP::TimeoutError.new "Did not received correct status #{type_str} in reply to #{m_id} within #{options[:timeout]}s"
-    end
-
-    def status_match? query, item
-      return nil if query['sCI'] && query['sCI'] != item['sCI']
-      return nil 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 nil if query['cCI'] && query['cCI'] != item['cCI']
-      return nil 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 wait_for_aggregated_status parent_task, options, m_id
-      collect(parent_task,options.merge({
-        type: ['AggregatedStatus','MessageNotAck'],
-        num: 1
-      })) do |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 "Aggregated status request #{m_id_short} was rejected: #{message.attribute('rea')}"
-            next true   # done, no more messages wanted
-          else
-            false
-          end
-        else
-          true
-        end
-      end
-    end
-
-  end
-end

data/lib/rsmp/supervisor.rb

@@ -175,7 +175,7 @@ module RSMP
         proxy.revive settings
       else
         check_max_sites
-        proxy = build_proxy settings
+        proxy = build_proxy settings.merge(site_id:id)    # keep the id learned by peeking above
         @proxies.push proxy
       end
       proxy.run     # will run until the site disconnects
@@ -225,7 +225,12 @@ module RSMP
       return site if site
       wait_for(@site_id_condition,timeout) { find_site site_id }
     rescue Async::TimeoutError
-      raise RSMP::TimeoutError.new "Site '#{site_id}' did not connect within #{timeout}s"
+      if site_id == :any
+        str = "No site connected"
+      else
+        str = "Site '#{site_id}' did not connect"
+      end
+      raise RSMP::TimeoutError.new "#{str} within #{timeout}s"
     end
 
     def wait_for_site_disconnect site_id, timeout

data/lib/rsmp/supervisor_proxy.rb

@@ -129,7 +129,7 @@ module RSMP
       message = AggregatedStatus.new({
         "aSTS" => clock.to_s,
         "cId" =>  component.c_id,
-        "fP" => 'NormalControl',
+        "fP" => nil,
         "fS" => nil,
         "se" => component.aggregated_status_bools,
         "mId" => m_id,

data/lib/rsmp/version.rb

@@ -1,3 +1,3 @@
 module RSMP
-  VERSION = "0.2.2"
+  VERSION = "0.3.2"
 end

data/lib/rsmp.rb

@@ -21,11 +21,11 @@ require 'rsmp/notifier'
 
 require 'rsmp/listener'
 require 'rsmp/collector'
+require 'rsmp/matcher'
 require 'rsmp/component'
 require 'rsmp/site'
 require 'rsmp/proxy'
 require 'rsmp/supervisor_proxy'
-require 'rsmp/site_proxy_wait'
 require 'rsmp/site_proxy'
 require 'rsmp/error'
 require 'rsmp/message'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rsmp
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.2
 platform: ruby
 authors:
 - Emil Tin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-22 00:00:00.000000000 Z
+date: 2021-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -217,6 +217,7 @@ files:
 - lib/rsmp/listener.rb
 - lib/rsmp/logger.rb
 - lib/rsmp/logging.rb
+- lib/rsmp/matcher.rb
 - lib/rsmp/message.rb
 - lib/rsmp/node.rb
 - lib/rsmp/notifier.rb
@@ -254,7 +255,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.26
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: RoadSide Message Protocol (RSMP) library.