rsmp 0.29.0 → 0.32.0

data/lib/rsmp/collect/state_collector.rb

@@ -1,13 +1,13 @@
 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
+  # a list of matchers. Matchers 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.
+  # Note that matchers can contain regex patterns for values, like /\d+/ in the example above.
   #
   # When an input messages is received it typically contains several items, eg:
   # [
@@ -16,9 +16,9 @@ module RSMP
   #   {"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:
+  # Each input item is matched against each of the matchers.
+  # If a match is found, it's stored in the @results hash, with the matcher as the key,
+  # and a mesage and status as the key. In the example above, this matcher:
   #
   # {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>/\d+/}
   #
@@ -32,101 +32,101 @@ module RSMP
   #     { <StatusResponse message>, {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>"9"} }
   # }
   class StateCollector < Collector
-    attr_reader :queries
+    attr_reader :matchers
 
     # Initialize with a list of wanted statuses
     def initialize proxy, want, options={}
       raise ArgumentError.new("num option cannot be used") if options[:num]
-      super proxy, options.merge( ingoing: true, outgoing: false)
-      @queries = want.map { |item| build_query item }
+      super proxy, options
+      @matchers = want.map { |item| build_matcher item }
     end
 
-    # Build a query object.
-    # Sub-classes should override to use their own query classes.
-    def build_query want
-      Query.new want
+    # Build a matcher object.
+    # Sub-classes should override to use their own matcher classes.
+    def build_matcher want
+      Matcher.new want
     end
 
     # Get a results
-    def query_result want
-      query = @queries.find { |q| q.want == want}
-      raise unless query
-      query.got
+    def matcher_result want
+      matcher = @matchers.find { |q| q.want == want}
+      raise unless matcher
+      matcher.got
     end
 
-    # Get an array of the last item received for each query
+    # Get an array of the last item received for each matcher
     def reached
-      @queries.map { |query| query.got }.compact
+      @matchers.map { |matcher| matcher.got }.compact
     end
 
     # Get messages from results
     def messages
-      @queries.map { |query| query.message }.uniq.compact
+      @matchers.map { |matcher| matcher.message }.uniq.compact
     end
 
-    # Return progress as completes queries vs. total number of queries
+    # Return progress as completes matchers vs. total number of matchers
     def progress
-      need = @queries.size
-      reached =  @queries.count { |query| query.done? }
+      need = @matchers.size
+      reached =  @matchers.count { |matcher| matcher.done? }
       { need: need, reached: reached }
     end
 
-    # Are there queries left to type_match?
+    # Are there matchers left to type_match?
     def done?
-      @queries.all? { |query| query.done? }
+      @matchers.all? { |matcher| matcher.done? }
     end
 
-    # Get a simplified hash of queries, with values set to either true or false,
-    # indicating which queries have been matched.
-    def query_status
-      @queries.map { |query| [query.want, query.done?] }.to_h
+    # Get a simplified hash of matchers, with values set to either true or false,
+    # indicating which matchers have been matched.
+    def matcher_status
+      @matchers.map { |matcher| [matcher.want, matcher.done?] }.to_h
     end
 
-    # Get a simply array of bools, showing which queries have been matched.
+    # Get a simply array of bools, showing which matchers have been matched.
     def summary
-      @queries.map { |query| query.done? }
+      @matchers.map { |matcher| matcher.done? }
     end
 
     # Check if a messages matches our criteria.
-    # Match each query against each item in the message
+    # Match each matcher against each item in the message
     def perform_match message
       return false if super(message) == false
       return unless collecting?
-      @queries.each do |query|       # look through queries
+      @matchers.each do |matcher|       # look through matchers
         get_items(message).each do |item|  # look through items in message
-          matched = query.perform_match(item,message,@block)
+          matched = matcher.perform_match(item,message,@block)
           return unless collecting?
           if matched != nil
-            #type = {true=>'match',false=>'mismatch'}[matched]
-            #@notifier.log "#{@title.capitalize} #{message.m_id_short} collect #{type} #{query.want}, item #{item}", level: :debug
+            type = {true=>'match',false=>'mismatch'}[matched]
+            @distributor.log "#{@title.capitalize} #{message.m_id_short} collect #{type} #{matcher.want}, item #{item}", level: :debug
             if matched == true
-              query.keep message, item
+              matcher.keep message, item
             elsif matched == false
-              query.forget
+              matcher.forget
             end
           end
         end
       end
     end
 
-    # don't collect anything. Query will collect them instead
+    # don't collect anything. Matcher will collect them instead
     def keep message
     end
 
     def describe
-      @queries.map {|q| q.want.to_s }
+      @matchers.map {|q| q.want.to_s }
     end
 
     # return a string that describes the attributes that we're looking for
-    def describe_query
-      "#{super} matching #{query_want_hash.to_s}"
+    def describe_matcher
+      "#{super} matching #{matcher_want_hash.to_s}"
     end
 
-    # return a hash that describe the status of all queries
+    # return a hash that describe the status of all matchers
     def progress_hash
       h = {}
-      @queries.each do |query|
-        want = query.want
+      @matchers.each do |matcher|
+        want = matcher.want
         if want['cCI']
           cCI = want['cCI']
           h[cCI] ||= {}
@@ -140,8 +140,8 @@ module RSMP
           h[sCI] ||= {}
           n = want['n']
           s = want['s']
-          if query.got && query.got['s']
-            h[sCI][n] = { {s=>query.got['s']} => query.done? }
+          if matcher.got && matcher.got['s']
+            h[sCI][n] = { {s=>matcher.got['s']} => matcher.done? }
           else
             h[sCI][n] = { s=>nil }
           end
@@ -152,15 +152,15 @@ module RSMP
 
     # return a string that describe how many many messages have been collected
     def describe_progress
-      num_queries = @queries.size
-      num_matched =  @queries.count { |query| query.done? }
-      ".. Matched #{num_matched}/#{num_queries} with #{progress_hash.to_s}"
+      num_matchers = @matchers.size
+      num_matched =  @matchers.count { |matcher| matcher.done? }
+      ".. Matched #{num_matched}/#{num_matchers} with #{progress_hash.to_s}"
     end
 
-    def query_want_hash
+    def matcher_want_hash
       h = {}
-      @queries.each do |query|
-        item = query.want
+      @matchers.each do |matcher|
+        item = matcher.want
         if item['cCI']
           cCI = item['cCI']
           h[cCI] ||= {}
@@ -181,11 +181,11 @@ module RSMP
     end
 
     # return a hash that describe the end result
-    def query_got_hash
+    def matcher_got_hash
       h = {}
-      @queries.each do |query|
-        want = query.want
-        got = query.got
+      @matchers.each do |matcher|
+        want = matcher.want
+        got = matcher.got
         if want['cCI']
           cCI = want['cCI']
           h[cCI] ||= {}
@@ -207,7 +207,7 @@ module RSMP
 
     # log when we end collecting
     def log_complete
-      @notifier.log "#{identifier}: Completed with #{query_got_hash.to_s}", level: :collect
+      @distributor.log "#{identifier}: Completed with #{matcher_got_hash.to_s}", level: :collect
     end
   end
 end

data/lib/rsmp/collect/status_collector.rb

@@ -2,15 +2,18 @@ module RSMP
   # Base class for waiting for status updates or responses
   class StatusCollector < StateCollector
     def initialize proxy, want, options={}
-      super proxy, want, options.merge(title: 'status response')
+      type = []
+      type << 'StatusUpdate' unless options[:updates] == false
+      type << 'StatusResponse' unless options[:reponses] == false
 
-      @options[:type] ||= []
-      @options[:type] << 'StatusUpdate' unless options[:updates] == false
-      @options[:type] << 'StatusResponse' unless options[:reponses] == false
+      super proxy, want, options.merge(
+        title: 'status response',
+        filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: type)
+      )
     end
 
-    def build_query want
-      RSMP::StatusQuery.new want
+    def build_matcher want
+      RSMP::StatusMatcher.new want
     end
 
     # Get items, in our case status values

data/lib/rsmp/collect/{status_query.rb → status_matcher.rb}

@@ -1,7 +1,7 @@
 module RSMP
   # Match a specific status response or update
-  class StatusQuery < Query
-    # Match a status value against a query
+  class StatusMatcher < Matcher
+    # Match a status value against a matcher
     def match? item
       return nil if @want['sCI'] && @want['sCI'] != item['sCI']
       return nil if @want['cO'] && @want['cO'] != item['cO']

data/lib/rsmp/component.rb

@@ -56,5 +56,9 @@ module RSMP
       log "Deactivating alarm #{alarm_code}", level: :info
       @node.alarm_activated_or_deactivated alarm
     end
+
+    def status_updates_sent
+    end
+    
   end
 end

data/lib/rsmp/node.rb

@@ -36,7 +36,7 @@ module RSMP
       @ignore_errors = was
     end
 
-    def notify_error e, options={}
+    def distribute_error e, options={}
       return if @ignore_errors.find { |klass| e.is_a? klass }
       if options[:level] == :internal
         log ["#{e.to_s} in task: #{Async::Task.current.to_s}",e.backtrace].flatten.join("\n"), level: :error

data/lib/rsmp/proxy.rb

@@ -9,7 +9,7 @@ module RSMP
     WRAPPING_DELIMITER = "\f"
 
     include Logging
-    include Notifier
+    include Distributor
     include Inspect
     include Task
 
@@ -47,7 +47,7 @@ module RSMP
       close_socket
       stop_reader
       set_state :disconnected
-      notify_error DisconnectError.new("Connection was closed")
+      distribute_error DisconnectError.new("Connection was closed")
 
       # stop timer
       # as we're running inside the timer, code after stop_timer() will not be called,
@@ -188,7 +188,7 @@ module RSMP
     rescue Errno::EPIPE
       log "Broken pipe", level: :warning
     rescue StandardError => e
-      notify_error e, level: :internal
+      distribute_error e, level: :internal
     end
 
     def read_line
@@ -213,8 +213,8 @@ module RSMP
       log str, level: :statistics
     end
 
-    def notify_error e, options={}
-      @node.notify_error e, options
+    def receive_error e, options={}
+      @node.receive_error e, options
     end
 
     def start_watchdog
@@ -265,7 +265,7 @@ module RSMP
         rescue Errno::EPIPE => e
           log "Timer: Broken pipe", level: :warning
         rescue StandardError => e
-          notify_error e, level: :internal
+          distribute_error e, level: :internal
         end
       ensure
         next_time += interval
@@ -312,7 +312,7 @@ module RSMP
           begin
             close
           ensure
-            notify_error MissingAcknowledgment.new(str)
+            distribute_error MissingAcknowledgment.new(str)
           end
         end
       end
@@ -325,7 +325,7 @@ module RSMP
       if left < 0
         str = "No Watchdog received within #{timeout} seconds"
         log str, level: :warning
-        notify MissingWatchdog.new(str)
+        distribute MissingWatchdog.new(str)
       end
     end
 
@@ -340,22 +340,22 @@ module RSMP
       schemas
     end
 
-    def send_message message, reason=nil, validate: true
-      raise NotReady unless connected?
+    def send_message message, reason=nil, validate: true, force: false
+      raise NotReady unless connected? unless force
       raise IOError unless @protocol
       message.direction = :out
       message.generate_json
       message.validate get_schemas unless validate==false
       @protocol.write_lines message.json
       expect_acknowledgement message
-      notify message
+      distribute message
       log_send message, reason
     rescue EOFError, IOError
       buffer_message message
     rescue SchemaError, RSMP::Schema::Error => e
       str = "Could not send #{message.type} because schema validation failed: #{e.message}"
       log str, message: message, level: :error
-      notify_error e.exception("#{str} #{message.json}")
+      distribute_error e.exception("#{str} #{message.json}")
     end
 
     def buffer_message message
@@ -398,39 +398,39 @@ module RSMP
       message = Message.build attributes, json
       message.validate(get_schemas) if should_validate_ingoing_message?(message)
       verify_sequence message
-      deferred_notify do
-        notify message
+      with_deferred_distribution do
+        distribute message
         process_message message
       end
       process_deferred
       message
     rescue InvalidPacket => e
       str = "Received invalid package, must be valid JSON but got #{json.size} bytes: #{e.message}"
-      notify_error e.exception(str)
+      distribute_error e.exception(str)
       log str, level: :warning
       nil
     rescue MalformedMessage => e
       str = "Received malformed message, #{e.message}"
-      notify_error e.exception(str)
+      distribute_error e.exception(str)
       log str, message: Malformed.new(attributes), level: :warning
       # cannot send NotAcknowledged for a malformed message since we can't read it, just ignore it
       nil
     rescue SchemaError, RSMP::Schema::Error => e
       reason = "schema errors: #{e.message}"
       str = "Received invalid #{message.type}"
-      notify_error e.exception(str), message: message
+      distribute_error e.exception(str), message: message
       dont_acknowledge message, str, reason
       message
     rescue InvalidMessage => e
       reason = "#{e.message}"
       str = "Received invalid #{message.type},"
-      notify_error e.exception("#{str} #{message.json}"), message: message
+      distribute_error e.exception("#{str} #{message.json}"), message: message
       dont_acknowledge message, str, reason
       message
     rescue FatalError => e
       reason = e.message
       str = "Rejected #{message.type},"
-      notify_error e.exception(str), message: message
+      distribute_error e.exception(str), message: message
       dont_acknowledge message, str, reason
       close
       message
@@ -486,7 +486,9 @@ module RSMP
       if candidates.any?
         @core_version = candidates.sort_by { |v| Gem::Version.new(v) }.last  # pick latest version
       else
-        raise HandshakeError.new "RSMP versions [#{message.versions.join(',')}] requested, but only [#{versions.join(',')}] supported."
+        reason = "RSMP versions [#{message.versions.join(',')}] requested, but only [#{versions.join(',')}] supported."
+        dont_acknowledge message, "Version message rejected", reason, force: true
+        raise HandshakeError.new reason
       end
     end
 
@@ -501,7 +503,7 @@ module RSMP
       check_ingoing_acknowledged original
     end
 
-    def dont_acknowledge original, prefix=nil, reason=nil
+    def dont_acknowledge original, prefix=nil, reason=nil, force: true
       raise InvalidArgument unless original
       str = [prefix,reason].join(' ')
       log str, message: original, level: :warning if reason
@@ -510,7 +512,7 @@ module RSMP
         "rea" => reason || "Unknown reason"
       })
       message.original = original.clone
-      send_message message, "for #{original.type} #{original.m_id_short}"
+      send_message message, "for #{original.type} #{original.m_id_short}", force: force
     end
 
     def wait_for_state state, timeout:

data/lib/rsmp/site.rb

@@ -58,6 +58,7 @@ module RSMP
 
       @site_settings = defaults.deep_merge options[:site_settings]
       check_sxl_version
+      check_core_versions
       setup_components @site_settings['components']
     end
 
@@ -67,10 +68,49 @@ module RSMP
       RSMP::Schema::find_schema! sxl, version, lenient: true
     end
 
+  def check_core_versions
+      return if @site_settings['core_versions'] == 'all'
+      requested = [@site_settings['core_versions']].flatten
+      invalid = requested - RSMP::Schema::core_versions
+      if invalid.any?
+        if invalid.size == 1
+          error_str = "Unknown core version: #{invalid.first}"
+        else
+          error_str = "Unknown core versions: [#{invalid.join(' ')}]"
+        end
+
+        raise RSMP::ConfigurationError.new(error_str)
+      end
+    end
+
+    def site_type_name
+      "site"
+    end
+
+    def log_site_starting
+      log "Starting #{site_type_name} #{@site_settings["site_id"]}", level: :info, timestamp: @clock.now
+
+      sxl = "Using #{@site_settings["sxl"]} sxl #{@site_settings["sxl_version"]}"
+
+      versions = @site_settings["core_versions"]
+      if versions.is_a?(Array) && versions.size == 1
+        versions = versions.first
+      end
+      if versions == 'all'
+        core = "accepting all core versions [#{RSMP::Schema.core_versions.join(', ')}]"
+      else
+        if versions.is_a?(String)
+          core = "accepting only core version #{versions}"
+        else
+          core = "accepting core versions [#{versions.join(', ')}]"
+        end
+      end
+
+      log "#{sxl}, #{core}", level: :info, timestamp: @clock.now
+    end
+
     def run
-      log "Starting site #{@site_settings["site_id"]}",
-          level: :info,
-          timestamp: @clock.now
+      log_site_starting
       @proxies.each { |proxy| proxy.start }
       @proxies.each { |proxy| proxy.wait }
     end

data/lib/rsmp/site_proxy.rb

@@ -24,7 +24,7 @@ module RSMP
     rescue RSMP::ConnectionError => e
       log e, level: :error
     rescue StandardError => e
-      notify_error e, level: :internal
+      distribute_error e, level: :internal
     ensure
       close
     end
@@ -77,7 +77,7 @@ module RSMP
     rescue RSMP::RepeatedAlarmError, RSMP::RepeatedStatusError, RSMP::TimestampError => e
       str = "Rejected #{message.type} message,"
       dont_acknowledge message, str, "#{e}"
-      notify_error e.exception("#{str}#{e.message} #{message.json}")
+      distribute_error e.exception("#{str}#{e.message} #{message.json}")
     end
 
     def process_command_response message
@@ -367,8 +367,8 @@ module RSMP
       end
     end
 
-    def notify_error e, options={}
-      @supervisor.notify_error e, options if @supervisor
+    def receive_error e, options={}
+      @supervisor.receive_error e, options if @supervisor
       distribute_error e, options
     end
 

data/lib/rsmp/supervisor.rb

@@ -69,11 +69,11 @@ module RSMP
       tasks = @endpoint.accept do |socket|  # creates async tasks
         handle_connection(socket)
       rescue StandardError => e
-        notify_error e, level: :internal
+        distribute_error e, level: :internal
       end
       tasks.each { |task| task.wait }
     rescue StandardError => e
-      notify_error e, level: :internal
+      distribute_error e, level: :internal
     end
 
     # stop
@@ -94,12 +94,12 @@ module RSMP
       else
         reject_connection socket, info
       end
-    rescue ConnectionError => e
+    rescue ConnectionError, HandshakeError => e
       log "Rejected connection from #{remote_ip}:#{remote_port}, #{e.to_s}", level: :warning
-      notify_error e
+      distribute_error e
     rescue StandardError => e
       log "Connection: #{e.to_s}", exception: e, level: :error
-      notify_error e, level: :internal
+      distribute_error e, level: :internal
     ensure
       close socket, info
     end

data/lib/rsmp/supervisor_proxy.rb

@@ -34,7 +34,7 @@ module RSMP
         log e, level: :error
         break if reconnect_delay == false
       rescue StandardError => e
-        notify_error e, level: :internal
+        distribute_error e, level: :internal
         break if reconnect_delay == false
       ensure
         close
@@ -474,6 +474,7 @@ module RSMP
         set_nts_message_attributes update
         send_message update
         store_last_sent_status update
+        component.status_updates_sent
       end
     end
 

data/lib/rsmp/tlc/signal_priority.rb

@@ -10,19 +10,35 @@ class RSMP::TLC::SignalPriority
     set_state 'received'
   end
 
+  def prune?
+    @state == 'stale' || @state == 'completed'
+  end
+
+  def cancel
+    if @state == 'activated'
+      set_state 'completed'
+    end
+  end
+
   def set_state state
     @state = state
     @updated = node.clock.now
-    node.signal_priority_changed self, @state
+    @node.signal_priority_changed self, @state
   end
 
   def timer
     @age = @node.clock.now - @updated
     case @state
     when 'received'
-      set_state 'activated' if @age >= 0.5
+      if @age >= 0.5
+        @node.log "Priority request #{@id} activated.", level: :info
+        set_state 'activated'
+      end
     when 'activated'
-      set_state 'completed' if @age >= 0.5
+      if @age >= 1
+        @node.log "Priority request #{@id} became stale.", level: :info
+        set_state 'stale'
+      end
     end
   end
 end