rsmp 0.29.0 → 0.31.0

data/lib/rsmp/collect/filter.rb

@@ -3,10 +3,13 @@ module RSMP
   # Filter messages based on type, direction and component id.
   # Used by Collectors.
   class Filter
-    def initialize ingoing:true, outgoing:true, type:, component:nil
+
+    attr_reader :ingoing, :outgoing, :type, :component
+
+    def initialize ingoing:true, outgoing:true, type:nil, component:nil
       @ingoing = ingoing
       @outgoing = outgoing
-      @type = type
+      @type = type ? [type].flatten : nil
       @component = component
     end
 
@@ -16,10 +19,8 @@ module RSMP
       return false if message.direction == :in && @ingoing == false
       return false if message.direction == :out && @outgoing == false
       if @type
-        if @type.is_a? Array
+        unless message.is_a?(MessageNotAck)
           return false unless @type.include? message.type
-        else
-          return false unless message.type == @type
         end
       end
       if @component
@@ -27,5 +28,9 @@ module RSMP
       end
       true
     end
+
+    def reject? message
+      !accept?(message)
+    end
   end
 end

data/lib/rsmp/collect/{query.rb → matcher.rb}

@@ -1,7 +1,7 @@
 module RSMP
 
   # Class that matches a single status or command item
-  class Query
+  class Matcher
     attr_reader :want, :got, :message
 
     def initialize want

data/lib/rsmp/collect/queue.rb

@@ -0,0 +1,39 @@
+# Receives items from a Distributor and keeps them in a queue.
+# The client can wait for mesages and will get them one by one.
+
+module RSMP
+  class Queue
+    include Receiver
+
+    attr_reader :messages
+
+    def initialize distributor, filter: nil, task:
+      initialize_receiver distributor, filter: filter
+      @condition = Async::Notification.new
+      @task = task
+      clear
+    end
+
+    def clear
+      @messages = []
+    end
+
+    def wait_for_message timeout: nil
+      if @messages.empty?
+        if timeout
+          @task.with_timeout(timeout) { @condition.wait }
+        else
+          @condition.wait
+        end
+      end
+      @messages.shift
+    rescue Async::TimeoutError
+      raise RSMP::TimeoutError
+    end
+
+    def handle_message message
+      @messages << message
+      @condition.signal
+    end
+  end
+end

data/lib/rsmp/collect/receiver.rb

@@ -0,0 +1,40 @@
+# Receives items from a Distributor, as long as it's
+# installed as a receiver.
+# Optionally can filter mesage using a Filter.
+
+module RSMP
+  module Receiver
+    include Inspect
+
+    def initialize_receiver distributor, filter: nil
+      @distributor = distributor
+      @filter = filter
+    end
+
+    def start_receiving
+      @distributor.add_receiver(self)
+    end
+
+    def stop_receiving
+      @distributor.remove_receiver(self)
+    end
+
+    def receive message
+      handle_message(message) if accept_message?(message) 
+    end
+
+    def receive_error error, options={}
+    end
+
+    def accept_message? message
+      @filter == nil || @filter.accept?(message)
+    end
+
+    def reject_message? message
+      !accept_message?(message)
+    end
+
+    def handle_message message
+    end
+  end
+end

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
 
@@ -348,14 +348,14 @@ module RSMP
       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

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
@@ -96,10 +96,10 @@ module RSMP
       end
     rescue ConnectionError => 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