rsmp 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43f928133404e5dbc56e1a45eba044b20783bd2decfd1631a0ae2b66e731e5e2
-  data.tar.gz: ad786c056a21aa65a65406edfe3200229a5b02a104871e63e656d4dae4c6910c
+  metadata.gz: a19b3e748ae4dff7c8f652f7015d8f0b798f78a3d8f07c545638724308f4c819
+  data.tar.gz: 8353a6b756fa36f45b0c9e8cf33d56cb96f69ef30ab158ebf34ea2cc8a863122
 SHA512:
-  metadata.gz: 453a4f85fbd4985dc300fd6321c2c534723b251410e6a7c577aff53175197aa1e8898234a1086b1d747fe4e093a67007b6ffd426e15a1b0d3a6ebaa489791f2a
-  data.tar.gz: 7c443d27d2dbc108b5b34af6faf15fa03e145193f83584c465ae685f74de4203db0cd37d06fdee4525a06077cd0a208020e7f9a635b021d20eb92050eeaaa8d5
+  metadata.gz: 23fb75e6bad681f67be2f04038a6bebec458c5e6e5c29ee5d5333dc5583b490ba8e1841e5304a88a384ac4761edea45818848f2144a97e73a31dbe2ca89090ed
+  data.tar.gz: cc37d48a622961d41444631cb3543967ccbd926dfcf1314a45294c676270977272e842853a5e1f59a08f1706b26dd85a2494aaea1a12b5dced4917dbaaee9015

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rsmp (0.2.1)
+    rsmp (0.3.1)
       async (~> 1.29.1)
       async-io (~> 1.32.1)
       colorize (~> 0.8.1)
@@ -24,12 +24,12 @@ GEM
       cucumber (>= 2.4, < 7.0)
       rspec-expectations (~> 3.4)
       thor (~> 1.0)
-    async (1.29.1)
+    async (1.29.2)
       console (~> 1.10)
       nio4r (~> 2.3)
       timers (~> 4.1)
-    async-io (1.32.1)
-      async (~> 1.14)
+    async-io (1.32.2)
+      async
     builder (3.2.4)
     childprocess (4.1.0)
     colorize (0.8.1)
@@ -88,7 +88,7 @@ GEM
     mime-types-data (3.2021.0225)
     minitest (5.14.4)
     multi_test (0.1.2)
-    nio4r (2.5.7)
+    nio4r (2.5.8)
     protobuf-cucumber (3.10.8)
       activesupport (>= 3.2)
       middleware

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/logger.rb

@@ -96,7 +96,8 @@ module RSMP
           'statistics' => 'light_black',
           'not_acknowledged' => 'cyan',
           'warning' => 'light_yellow',
-          'error' => 'red'
+          'error' => 'red',
+          'debug' => 'light_black'
         }
         colors.merge! @settings["color"] if @settings["color"].is_a?(Hash)
         if colors[level.to_s]

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

@@ -11,22 +11,32 @@ module RSMP
     include Notifier
     include Inspect
 
-    attr_reader :state, :archive, :connection_info, :sxl, :task, :collector
+    attr_reader :state, :archive, :connection_info, :sxl, :task, :collector, :ip, :port
 
     def initialize options
       initialize_logging options
+      setup options
+      initialize_distributor
+      prepare_collection @settings['collect']
+      clear
+    end
+
+    def revive options
+      setup options
+    end
+
+    def setup options
       @settings = options[:settings]
       @task = options[:task]
       @socket = options[:socket]
+      @stream = options[:stream]
+      @protocol = options[:protocol]
       @ip = options[:ip]
       @port = options[:port]
       @connection_info = options[:info]
       @sxl = nil
       @site_settings = nil  # can't pick until we know the site id
-      initialize_distributor
-
-      prepare_collection @settings['collect']
-      clear
+      @state = :stopped
     end
 
     def inspect
@@ -49,6 +59,7 @@ module RSMP
     def collect task, options, &block
       collector = RSMP::Collector.new self, options
       collector.collect task, &block
+      collector
     end
 
     def run
@@ -105,15 +116,19 @@ module RSMP
     def start_reader  
       @reader = @task.async do |task|
         task.annotate "reader"
-        @stream = Async::IO::Stream.new(@socket)
-        @protocol = Async::IO::Protocol::Line.new(@stream,WRAPPING_DELIMITER) # rsmp messages are json terminated with a form-feed
+        @stream ||= Async::IO::Stream.new(@socket)
+        @protocol ||= Async::IO::Protocol::Line.new(@stream,WRAPPING_DELIMITER) # rsmp messages are json terminated with a form-feed
 
         while json = @protocol.read_line
           beginning = Time.now
           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)
@@ -192,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,7 +41,9 @@ module RSMP
         },
         'send_after_connect' => true,
         'components' => {
-          'C1' => {}
+          'main' => {
+            'C1' => {}
+          }
         }
       }
       

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,9 +11,16 @@ module RSMP
       initialize_components
       @supervisor = options[:supervisor]
       @settings = @supervisor.supervisor_settings.clone
-      @site_id = nil
+      @site_id = options[:site_id]
     end
 
+    def revive options
+      super options
+      @supervisor = options[:supervisor]
+      @settings = @supervisor.supervisor_settings.clone
+    end
+
+
     def inspect
       "#<#{self.class.name}:#{self.object_id}, #{inspector(
         :@acknowledgements,:@settings,:@site_settings,:@components
@@ -36,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
 
@@ -79,11 +85,14 @@ module RSMP
       acknowledge message
       send_version @site_id, rsmp_versions
       @version_determined = true
+    end
 
+    def validate_ready action
+      raise NotReady.new("Can't #{action} because connection is not ready. (Currently #{@state})") unless ready?
     end
 
     def request_aggregated_status component, options={}
-      raise NotReady unless ready?
+      validate_ready 'request aggregated status'
       m_id = options[:m_id] || RSMP::Message.make_m_id
 
       message = RSMP::AggregatedStatusRequest.new({
@@ -93,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
@@ -163,11 +171,11 @@ module RSMP
     end
 
     def request_status component, status_list, options={}
-      raise NotReady unless ready?
+      validate_ready 'request status'
       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({
@@ -177,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
 
@@ -202,8 +195,15 @@ 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={}
-      raise NotReady unless ready?
+      validate_ready 'subscribe to status'
       m_id = options[:m_id] || RSMP::Message.make_m_id
       
       # additional items can be used when verifying the response,
@@ -217,28 +217,13 @@ 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
 
     def unsubscribe_to_status component, status_list, options={}
-      raise NotReady unless ready?
+      validate_ready 'unsubscribe to status'
       message = RSMP::StatusUnsubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
@@ -269,7 +254,7 @@ module RSMP
     end
 
     def send_command component, command_list, options={}
-      raise NotReady unless ready?
+      validate_ready 'send command'
       m_id = options[:m_id] || RSMP::Message.make_m_id
       message = RSMP::CommandRequest.new({
           "ntsOId" => '',
@@ -278,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
 
@@ -370,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

@@ -136,6 +136,13 @@ module RSMP
       end
     end
 
+    def peek_version_message protocol
+      json = protocol.peek_line
+      attributes = Message.parse_attributes json
+      message = Message.build attributes, json
+      message.attribute('siteId').first['sId']
+    end
+
     def connect socket, info
       log "Site connected from #{format_ip_and_port(info)}",
           ip: info[:ip],
@@ -144,25 +151,36 @@ module RSMP
           timestamp: Clock.now
 
       authorize_ip info[:ip]
-      check_max_sites
 
-      proxy = build_proxy({
+      stream = Async::IO::Stream.new socket
+      protocol = Async::IO::Protocol::Line.new stream, Proxy::WRAPPING_DELIMITER
+
+      settings = {
         supervisor: self,
         ip: info[:ip],
         port: info[:port],
         task: @task,
         settings: {'collect'=>@supervisor_settings['collect']},
         socket: socket,
+        stream: stream,
+        protocol: protocol,
         info: info,
         logger: @logger,
         archive: @archive
-      })
-      @proxies.push proxy
+      }
+
+      id = peek_version_message protocol
+      proxy = find_site id
+      if proxy
+        proxy.revive settings
+      else
+        check_max_sites
+        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
     ensure
-      @proxies.delete proxy
       site_ids_changed
-
       stop if @supervisor_settings['one_shot']
     end
 
@@ -188,7 +206,14 @@ module RSMP
       return find_site(site_id) != nil
     end
 
-    def find_site site_id
+    def find_site_from_ip_port ip, port
+      @proxies.each do |site|
+        return site if site.ip == ip && site.port == port
+      end
+      nil
+    end
+
+   def find_site site_id
       @proxies.each do |site|
         return site if site_id == :any || site.site_id == site_id
       end
@@ -200,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
@@ -210,12 +240,13 @@ module RSMP
     end
 
     def check_site_id site_id
-      check_site_already_connected site_id
+      #check_site_already_connected site_id
       return site_id_to_site_setting site_id
     end
 
     def check_site_already_connected site_id
-      raise FatalError.new "Site '#{site_id}' already connected" if find_site(site_id)
+      site = find_site(site_id)
+      raise FatalError.new "Site '#{site_id}' already connected" if site != nil && site != self
     end
 
     def site_id_to_site_setting site_id

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/tlc.rb

@@ -798,7 +798,7 @@ module RSMP
       super options
       @sxl = 'traffic_light_controller'
       @security_codes = options[:site_settings]['security_codes']
-      @interval = options[:site_settings]['intervals']['timer'] || 1
+      @interval = options[:site_settings].dig('intervals','timer') || 1
       unless @main
         raise ConfigurationError.new "TLC must have a main component"
       end

data/lib/rsmp/version.rb

@@ -1,3 +1,3 @@
 module RSMP
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 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.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Emil Tin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-02 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