rsmp 0.7.4 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e33d1daa5e26bfea0abc96970804ebc66f294200c5e952c4febf8105b4a9041
-  data.tar.gz: 6bb4d576fb0f9738f10a885265d3f58d56df78cac77ea520671d3d269de981f4
+  metadata.gz: 49e4aee9252ad888e831e5ce0738eff5bba57fdd6f2ec2220d7e74936e0e8177
+  data.tar.gz: 5866b23cb324d0732de17f995abec6304f50673e9cfcaa7b440dea6858102cd8
 SHA512:
-  metadata.gz: ec2bda9f884954830d81b65bdee1bdfeee7183e3e7655e4677defad2d0a47e76bc4004c966ef6119f7623570d9febc03a84358897803733c07255b471503097f
-  data.tar.gz: b660975c624bb275c7853cc8060d0c95c0abac5a60f79ab0c2327324d9e7757b618c6dc4e2e91de4924fe1b1de0c5eb480e5cf35fd620e6c4c19aa923e33051e
+  metadata.gz: 0ff9a48cde72b3fb3963c421a321c4bd08c0edfb9afcd7b4b919e2e92aa37624259a5124c81f4bd0189cc6a3596414edc75a305fb19b0c348fadc4e836bdf7cf
+  data.tar.gz: 490aa51f0a4a5b9a6a197c0f6bbe11b8ae16934e5eecd76a486b6e4e34786ebbb334d4ddabf7340c9f13d4946cad4e162db49205a3fbf04fa064938bf6029e0f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rsmp (0.7.4)
+    rsmp (0.8.2)
       async (~> 1.29.1)
       async-io (~> 1.32.1)
       colorize (~> 0.8.1)
@@ -95,7 +95,7 @@ GEM
       thor
       thread_safe
     rake (13.0.3)
-    regexp_parser (2.1.1)
+    regexp_parser (2.2.0)
     rsmp_schemer (0.3.2)
       json_schemer (~> 0.2.18)
     rspec (3.10.0)

data/config/tlc.yaml

@@ -21,10 +21,10 @@ signal_plans:
       1: 0
       2: 5
     states:
-      A1: '11NBBB'
-      A2: '1NBBBB'
-      B1: 'BBB11N'
-      B2: 'BBB1NB'
+      A1: '123efg'
+      A2: '123efg'
+      B1: '123efg'
+      B2: '123efg'
   2:
     states:
       A1: '111NBB'

data/documentation/classes_and_modules.md

@@ -19,9 +19,6 @@ Handle logging.
 ### Wait
 Handles waiting for an async condition and block.
 
-### SiteProxyWait
-Handles waiting for different types of messages and responses from a remote site.
-
 ### Components
 Component handling.
 
@@ -38,7 +35,7 @@ A Site has one or more SupervisorProxies (connections to supervisor).
 
 A site has one of more components.
 
-### Supervisor 
+### Supervisor
 A Supervisor represents an RSMP supervisor, typically a central supervisor system. An RSMP supervisor can handle connections one or more sites.
 
 A Supervisor has one or more SiteProxies (connections to sites).

data/documentation/collecting_message.md

@@ -0,0 +1,196 @@
+# Collection
+You often need to collect messages or responses. The collector classes are used to collect message asyncronously. Other tasks continue until the collection completes, time outs or is cancelled.
+
+A collector can collect ingoing and/or outgoing messages. 
+
+An object that includes the Notifier module (or implements the same functionality) must be provided when you construct a Collected. The collector will attach itself to this notifier when it starts collecting, to receive messages. The SiteProxy and SupervisorProxy classes both include the Notifier module, and can therefore be used as message sources.
+
+Messages that match the relevant criteria are stored by the collector.
+
+When the collection is done, the collector detaches from the notifier, and returns the status.
+
+
+## Collector
+Class uses for collecting messages filtered by message type, direction and/or component id. A block can be used for custom filtering.
+
+You can choose to collect a specific number of message and/or for a specific duration.
+
+A collector has a status, which is `:ready` initialialy. When you start collecting, it changes to `:collecting`. It will be `:ok` once collection completes successfully, or `:cancel` if it was cancelled to to some error or by a filter block.
+
+### Initialization
+When you create a collector, you specify the messages types you want to collect.
+You can also specify ingoing and/or outgoing direction and the RSMP component.
+
+```ruby
+collector = MessageCollector.new notifier, num: 10, ingoing: true, outgoing: true
+```
+
+num: The number of messages to collect. If not provided, a timeout must be set instead.
+timeout: The number of seconds to collect
+ingoing: Whether to collect ingoing messages. Defaults to true
+outgoing: Whether to collect outgoing messages. Defaults to true
+component: An RSMP component id.
+
+### Collecting
+Use collect() to start collecting and wait for completion or timeout. The status will be returned. 
+
+```ruby
+result = collector.collect # => :ok, :timeout or :cancelled
+collector.messages # => collected messages
+```
+
+If you want start collection, but not wait for the result, use `start()`. You can then later use `wait()` if you want:
+
+```ruby
+result = collector.start # => nil
+# do other stuff
+result = collector.wait
+```
+
+### Custom filtering
+You can use a block to do extra filtering. The block will be callled for each messages that fulfils the  correct message type, direction and component id.
+
+The block must return nil or a list of symbols to indicate whether the message should be kept, and whether collection should be cancelled.
+
+```ruby
+result = collector.collect do |message|
+	:keep, :cancel 		# example of how to keep the message and cancel collection
+end
+```
+
+`:keep` keeps (collect) this message
+`:cancel` cancel collection
+
+Note that you cannot use `return` in a block. You can either simply provide the values as the last expresssion in the block, or use next().
+
+Exceptions in the block will cause the collector to abort. If the collect! or wait! variants are used, the exception is propagated to the caller.
+
+### Bang version
+The method collect!() will raise exceptions in case of errors, and will return the collect message directly.
+
+```ruby
+message = collector.collect # => collected message.
+```
+
+Similar, `wait!()` will raise an exception in case of timeouts or errors:
+
+```ruby
+message = collector.wait! # => collected message.
+```
+
+
+### Schema Errors and Disconnects
+The collector can optionally cancel collection in special cases, controlled by the `:cancel` option provided when contructing the collector.
+
+```ruby
+options = {
+	cancel: {
+		disconnect: true,
+		schema_error: true
+	}
+}
+result = collector.collect options
+```
+
+disconnect: If the proxy which provides messages experience a disconnect, the collector will cancel collection.
+
+schema_error: If the proxy receives a message with a schema error, the collector will cancel collection, if the the invalid message has the correct message type.
+
+### NotAck
+A typical scenaria is that you send a command or status request, and want to collect the response. But if the original message is rejected by the site, you will received a NotAck instead of a reply. The collector classes can handle this, as long as you provide the message id of the original request in the `m_id` key of teh options when you construct the collector.
+
+If a NotAck is received with a matching `oMId` (original message id), the collection is cancelled.
+
+## StatusCollector
+Waits for a set of status criteria to be met.
+
+Note that a single RSMP status message can contain multiple status items. Unlike MessageCollector, a StatusCollector therefore operates on items, rather than messages, and you can't specify a number of messages to collect.
+
+
+### Criteria
+You construct a StatusCollector with set of criteria, specifying the status codes, names, and optionally values that must be met.
+
+### Collecting
+When you start collection, it will complete once all criteria are all fulfilled, the timeout is reached or a custom filtering block aborts the collection.
+
+```ruby
+collector = StatusCollector.new(options)
+result = matcher.collect(timeout: 5)
+```
+
+### Custom filtering
+You can use a block to do extra filtering. The block will be called for each individual status item that fulfils all criteria, like status code and name, component, etc.
+
+Like with MessageCollector, the block must return a hash specifing whether to keep the message and whether to continue collection.
+
+```ruby
+matcher = StatusCollector.new(options)
+result = matcher.collect(options) do |message,item|
+	next(:keep) if good_item?(item) 		# keep item
+end
+```
+
+## Subscribing to status updates
+The method `subscribe_to_status` can be used to subscribe to one of more status messages.
+
+### Without collection
+The simple form sends an RSMP status subscription message to the site and then returns immediatly. To collect incoming status messages, you need to manually use e.g. a Collector.
+
+A hash is returned, with `:sent` containing the send subscription messages.
+
+```ruby
+options = {
+	list: [{'sCI'=>'S0001','n'=>'signalgroupstatus'}],
+}
+result = subscribe_to_status(options)
+result.keys => # [:sent]
+```
+
+Note: If you want to use this simple form and manually collect responses, it's best to start collection in an asyncronous task _before_ you subscribe, to make sure you don't miss early responses:
+
+```ruby
+task = async do
+	MessageCollector.new(options).collect(num: 5, timeout:10)  # start listening for status messages
+end
+result = subscribe_to_status(options) # subscribe
+task.wait  # wait for collection task to complete (or time out)
+```
+
+### With collection
+If you provide `:collect` options, it will be used to construct a StatusUpdateCollector for collecting the relevant status messages. When collection completes the collector is returned in the `:collector` key:
+
+```ruby
+options = {
+	list: [{'sCI'=>'S0001','n'=>'signalgroupstatus'}],
+	collect: {timeout: 5}
+}
+result = subscribe_to_status(options)
+result.keys => # [:sent, :collector]
+result[:collector].messages # => list of collected messages
+```
+
+You can pass you own collector which will give you more control of how to collect the incoming status messages:
+
+```ruby
+collector = Collector.new(options)
+options = {collect: collector}
+result = subscribe_to_status(options)
+result.keys => # [:sent, :collector]
+result[:collector].messages # => list of collected messages
+```
+
+### Processing responses
+If you pass a block, the block will be used to construct a collector. The block will be called for each matching  status item received.
+Collection will continue until the block returns :cancel, or it times.
+
+```ruby
+options = {
+	list: [{'sCI'=>'S0001','n'=>'signalgroupstatus'}]
+}
+result = subscribe_to_status(options) do |message|
+	# do something with message
+	:keep # or not
+end
+result.keys => # [:sent, :collector]
+```
+

data/lib/rsmp/collect/aggregated_status_collector.rb

@@ -0,0 +1,9 @@
+module RSMP
+  # Class for waiting for an aggregated status response
+  class AggregatedStatusCollector < Collector
+    def initialize proxy, options={}
+      required = { type: ['AggregatedStatus','MessageNotAck'], title: 'aggregated status' }
+      super proxy, options.merge(required)
+    end
+  end
+end

data/lib/rsmp/collect/collector.rb

@@ -1,9 +1,10 @@
 module RSMP
 
-  # Collects ingoing and/or outgoing messages from a notifier.
-  # Can filter by message type and wakes up the client once the desired number of messages has been collected.
+  # Collects messages from a notifier.
+  # Can filter by message type, componet and direction.
+  # Wakes up the once the desired number of messages has been collected.
   class Collector < Listener
-    attr_reader :condition, :messages, :done
+    attr_reader :condition, :messages, :status, :error, :task
 
     def initialize proxy, options={}
       super proxy, options
@@ -17,16 +18,51 @@ module RSMP
       @outgoing = options[:outgoing] == nil ? false : options[:outgoing]
       @condition = Async::Notification.new
       @title = options[:title] || [@options[:type]].flatten.join('/')
-      @options[:timeout] ||= 1
-      @options[:num] ||= 1
+      @task = options[:task]
       reset
     end
 
+    def use_task task
+      @task = task
+    end
+
+    # Clear all query results
+    def reset
+      @messages = []
+      @error = nil
+      @status = :ready
+    end
+
     # Inspect formatter that shows the message we have collected
     def inspect
       "#<#{self.class.name}:#{self.object_id}, #{inspector(:@messages)}>"
     end
 
+    # Is collection active?
+    def collecting?
+      @status == :collecting
+    end
+
+    # Is collection active?
+    def ok?
+      @status == :ok
+    end
+
+    # Has collection time out?
+    def timeout?
+      @status == :timeout
+    end
+
+    # Is collection ready to start?
+    def ready?
+      @status == :ready
+    end
+
+    # Has collection been cancelled?
+    def cancelled?
+      @status == :cancelled
+    end
+
     # Want ingoing messages?
     def ingoing?
       @ingoing == true
@@ -37,91 +73,104 @@ module RSMP
       @outgoing == true
     end
 
-    # Block until all messages have been collected
-    def wait
-      @condition.wait
+    # Collect message
+    # Will return once all messages have been collected, or timeout is reached
+    def collect &block
+      start &block
+      wait
+      @status
+    ensure
+      @notifier.remove_listener self if @notifier
     end
 
     # Collect message
-    # Will block until all messages have been collected,
-    # or we time out 
-    def collect task, options={}, &block
-      @options.merge! options
-      @block = block
-      unless @done
-        listen do
-          task.with_timeout(@options[:timeout]) do
-            @condition.wait
-          end
-        end
+    # Returns the collected messages, or raise an exception in case of a time out.
+    def collect! &block
+      if collect(&block) == :timeout
+        raise RSMP::TimeoutError.new describe_progress
       end
-      return @error if @error
-      self
-    rescue Async::TimeoutError
-      str = "#{@title.capitalize} collection"
-      str << " in response to #{options[:m_id]}" if options[:m_id]
-      str << " didn't complete within #{@options[:timeout]}s"
-      reached = progress
-      str << ", reached #{progress[:reached]}/#{progress[:need]}"
-      raise RSMP::TimeoutError.new str
+      @messages
     end
 
-    # Return progress as collected vs. number requested
-    def progress
-      need = @options[:num]
-      reached =  @messages.size
-      { need: need, got: reached }
+    # If collection is not active, return status immeditatly. Otherwise wait until
+    # the desired messages have been collected, or timeout is reached.
+    def wait
+      if collecting?
+        if @options[:timeout]
+          @task.with_timeout(@options[:timeout]) { @condition.wait }
+        else
+          @condition.wait
+        end
+      end
+      @status
+    rescue Async::TimeoutError
+      @status = :timeout
     end
 
-    # Get the collected message.
-    def message
-      @messages.first
+    # If collection is not active, raise an error. Otherwise wait until
+    # the desired messages have been collected.
+    # If timeout is reached, an exceptioin is raised.
+    def wait!
+      wait
+      raise RSMP::TimeoutError.new(describe_progress) if timeout?
+      @messages
     end
 
-    # Get the collected messages.
-    def messages
-      @messages
+    # Start collection and return immediately
+    # You can later use wait() to wait for completion
+    def start &block
+      raise RuntimeError.new("Can't begin unless ready (currenty #{@status})") unless ready?
+      @block = block
+      raise ArgumentError.new("Num, timeout or block must be provided") unless @options[:num] || @options[:timeout] || @block
+      reset
+      @status = :collecting
+      @notifier.add_listener self if @notifier
     end
 
-    # Clear all query results
-    def reset
-      @messages = []
-      @error = nil
-      @done = false
+    # Build a string describing how how progress reached before timeout
+    def describe_progress
+      str = "#{@title.capitalize} collection "
+      str << "in response to #{@options[:m_id]} " if @options[:m_id]
+      str << "didn't complete within #{@options[:timeout]}s, "
+      str << "reached #{@messages.size}/#{@options[:num]}"
+      str
     end
 
     # Check if we receive a NotAck related to initiating request, identified by @m_id.
-    def check_not_ack message
+    def reject_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 with '#{message.attribute('rea')}'")
-          complete
+          cancel RSMP::MessageRejected.new("#{@title} #{m_id_short} was rejected with '#{message.attribute('rea')}'")
+          true
         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
-      check_match message
-      complete if done?
-      @done
+      raise RuntimeError.new("can't process message when status is :#{@status}, title: #{@title}, desc: #{describe}") unless ready? || collecting?
+      perform_match message
+      @status
+    end
+
+    def describe
     end
 
     # Match message against our collection criteria
-    def check_match message
-      matched = match? message
-      if matched == true
+    def perform_match message
+      return false if reject_not_ack(message)
+      return false unless type_match?(message)
+      if @block
+        status = [@block.call(message)].flatten
+        return unless collecting?
+        keep message if status.include?(:keep)
+      else
         keep message
-      elsif matched == false
-        forget message
       end
+      complete if done?
     end
 
     # Have we collected the required number of messages?
@@ -132,8 +181,14 @@ module RSMP
     # 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
+      @status = :ok
+      do_stop
+    end
+
+    # Remove ourself as a listener, so we don't receive message notifications anymore,
+    # and wake up the async condition
+    def do_stop
+      @notifier.remove_listener self
       @condition.signal
     end
 
@@ -143,7 +198,7 @@ module RSMP
       case error
       when RSMP::SchemaError
         notify_schema_error error, options
-      when RSMP::ConnectionError
+      when RSMP::DisconnectError
         notify_disconnect error, options
       end
     end
@@ -154,24 +209,23 @@ module RSMP
       message = options[:message]
       return unless message
       klass = message.class.name.split('::').last
-      return unless [@options[:type]].flatten.include? klass
-      @proxy.log "Collect cancelled due to schema error in #{klass} #{message.m_id_short}", level: :debug
+      return unless @options[:type] == nil || [@options[:type]].flatten.include?(klass)
+      @notifier.log "Collection cancelled due to schema error in #{klass} #{message.m_id_short}", level: :debug
       cancel error
     end
 
     # Cancel if we received e notificaiton about a disconnect
     def notify_disconnect error, options
       return unless @options.dig(:cancel,:disconnect)
-      @proxy.log "Collect cancelled due to a connection error: #{error.to_s}", level: :debug
+      @notifier.log "Collection cancelled due to a connection error: #{error.to_s}", level: :debug
       cancel error
     end
 
     # Abort collection
-    def cancel error
-      @error = error if error
-      @done = false
-      @proxy.remove_listener self
-      @condition.signal
+    def cancel error=nil
+      @error = error
+      @status = :cancelled
+      do_stop
     end
 
     # Store a message in the result array
@@ -179,30 +233,20 @@ module RSMP
       @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
+    # Return true if there's a match, false if not
+    def type_match? message
+      return false if message.direction == :in && @ingoing == false
+      return false if message.direction == :out && @outgoing == false
       if @options[:type]
-        return if message == nil
         if @options[:type].is_a? Array
-          return unless @options[:type].include? message.type
+          return false unless @options[:type].include? message.type
         else
-          return unless message.type == @options[:type]
+          return false unless message.type == @options[:type]
         end
       end
       if @options[:component]
-        return if message.attributes['cId'] && message.attributes['cId'] != @options[:component]
-      end
-      if @block
-        return if @block.call(message) == false
+        return false if message.attributes['cId'] && message.attributes['cId'] != @options[:component]
       end
       true
     end

data/lib/rsmp/collect/command_query.rb

@@ -0,0 +1,16 @@
+module RSMP
+  # Match a specific command responses
+  class CommandQuery < Query
+    # Match a return value item against a query
+    def match? item
+      return nil if @want['cCI'] && @want['cCI'] != item['cCI']
+      return nil if @want['n'] && @want['n'] != item['n']
+      if @want['v'].is_a? Regexp
+        return false if @want['v'] && item['v'] !~ @want['v']
+      else
+        return false if @want['v'] && item['v'] != @want['v']
+      end
+      true
+    end
+  end
+end

data/lib/rsmp/collect/command_response_collector.rb

@@ -0,0 +1,20 @@
+module RSMP
+  # Class for waiting for specific command responses
+  class CommandResponseCollector < StateCollector
+    def initialize proxy, want, options={}
+      super proxy, want, options.merge(
+        type: ['CommandResponse','MessageNotAck'],
+        title:'command response'
+      )
+    end
+
+    def build_query want
+      CommandQuery.new want
+    end
+
+    # Get items, in our case the return values
+    def get_items message
+      message.attributes['rvs'] || []
+    end
+  end
+end

data/lib/rsmp/collect/filter.rb

@@ -0,0 +1,31 @@
+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
+      @ingoing = ingoing
+      @outgoing = outgoing
+      @type = type
+      @component = component
+    end
+
+    # Check a message against our match criteria
+    # Return true if there's a match, false if not
+    def accept? message
+      return false if message.direction == :in && @ingoing == false
+      return false if message.direction == :out && @outgoing == false
+      if @type
+        if @type.is_a? Array
+          return false unless @type.include? message.type
+        else
+          return false unless message.type == @type
+        end
+      end
+      if @component
+        return false if message.attributes['cId'] && message.attributes['cId'] != @component
+      end
+      true
+    end
+  end
+end

data/lib/rsmp/collect/listener.rb

@@ -5,22 +5,19 @@ module RSMP
   class Listener
     include Inspect
 
-    def initialize proxy, options={}
-      @proxy = proxy
+    def initialize notifier, options={}
+      @notifier = notifier
     end
 
-    def notify message
+    def change_notifier notifier
+      @notifier.remove_listener self if @notifier
+      @notifier = notifier
     end
 
-    def notify_error error, options={}
+    def notify message
     end
 
-    def listen &block
-      @proxy.add_listener self
-      yield
-    ensure
-      @proxy.remove_listener self
+    def notify_error error, options={}
     end
-
   end
 end

data/lib/rsmp/collect/message_matchers.rb

@@ -1,64 +0,0 @@
-module RSMP
-  # 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
-
-    def build_query want
-      CommandQuery.new want
-    end
-
-    # Get items, in our case the return values
-    def get_items message
-      message.attributes['rvs']
-    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
-
-    def build_query want
-      StatusQuery.new want
-    end
-
-    # Get items, in our case status values
-    def get_items message
-      message.attributes['sS']
-    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/collect/query.rb

@@ -1,5 +1,5 @@
 module RSMP
-    
+
   # Class that matches a single status or command item
   class Query
     attr_reader :want, :got, :message
@@ -8,26 +8,36 @@ module RSMP
       @want = want
       @got = nil
       @message = nil
-      @done = false
     end
 
     # Are we done, i.e. did the last checked item match?
     def done?
-      @done
+      @got != nil
     end
 
     # Check an item and set @done to true if it matches
     # Store the item and corresponding message if there's a positive or negative match
-    def check_match item, message
+    def perform_match item, message, block
       matched = match? item
       if matched != nil
-        @message = message
-        @got = item
-        @done = matched
+        if block
+          status = block.call(nil,item)
+          matched = status if status == true || status == false
+        end
       end
       matched
     end
 
+    def keep message, item
+      @message = message
+      @got = item
+    end
+
+    def forget
+      @message = nil
+      @got = nil
+    end
+
     def match? item
     end
   end

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

@@ -31,15 +31,14 @@ module RSMP
   #   {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>/\d+/} =>
   #     { <StatusResponse message>, {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>"9"} }
   # }
-
-  class Matcher < Collector
+  class StateCollector < Collector
     attr_reader :queries
 
     # 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 }
-      @want = want
     end
 
     # Build a query object.
@@ -60,14 +59,9 @@ module RSMP
       @queries.map { |query| query.got }.compact
     end
 
-    # get the first message. Useful when you only collect one mesage
-    def message
-      @queries.first.message
-    end
-
     # Get messages from results
     def messages
-      @queries.map { |query| query.message }.uniq
+      @queries.map { |query| query.message }.uniq.compact
     end
 
     # Return progress as completes queries vs. total number of queries
@@ -77,14 +71,14 @@ module RSMP
       { need: need, reached: reached }
     end
 
-    # Are there queries left to match?
+    # Are there queries left to type_match?
     def done?
       @queries.all? { |query| query.done? }
     end
 
     # Get a simplified hash of queries, with values set to either true or false,
     # indicating which queries have been matched.
-    def status
+    def query_status
       @queries.map { |query| [query.want, query.done?] }.to_h
     end
 
@@ -95,19 +89,34 @@ module RSMP
 
     # Check if a messages matches our criteria.
     # Match each query against each item in the message
-    def check_match message
-      return unless match?(message)
+    def perform_match message
+      return false if super(message) == false
+      return unless collecting?
       @queries.each do |query|       # look through queries
         get_items(message).each do |item|  # look through items in message
-          matched = query.check_match(item,message)
+          matched = query.perform_match(item,message,@block)
+          return unless collecting?
           if matched != nil
             type = {true=>'match',false=>'mismatch'}[matched]
-            @proxy.log "#{@title.capitalize} #{message.m_id_short} collect #{type} #{query.want}, item #{item}", level: :debug
-            break
+            @notifier.log "#{@title.capitalize} #{message.m_id_short} collect #{type} #{query.want}, item #{item}", level: :debug
+            if matched == true
+              query.keep message, item
+            elsif matched == false
+              query.forget
+            end
           end
         end
       end
-      @proxy.log "#{@title.capitalize} collect reached #{summary}", level: :debug
+      complete if done?
+      @notifier.log "#{@title.capitalize} collect reached #{summary}", level: :debug
+    end
+
+    # don't collect anything. Query will collect them instead
+    def keep message
+    end
+
+    def describe
+      @queries.map {|q| q.want.to_s }
     end
   end
 end

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

@@ -1,20 +1,5 @@
 module RSMP
-  # Match a specific command responses
-  class CommandQuery < Query
-    # Match a return value item against a query
-    def match? item
-      return nil if @want['cCI'] && @want['cCI'] != item['cCI']
-      return nil if @want['n'] && @want['n'] != item['n']
-      if @want['v'].is_a? Regexp
-        return false if @want['v'] && item['v'] !~ @want['v']
-      else
-        return false if @want['v'] && item['v'] != @want['v']
-      end
-      true
-    end
-  end
-
-  # Match a specific status response or update 
+  # Match a specific status response or update
   class StatusQuery < Query
     # Match a status value against a query
     def match? item

data/lib/rsmp/collect/status_response_collector.rb

@@ -0,0 +1,11 @@
+module RSMP
+  # Class for waiting for specific status responses
+  class StatusResponseCollector < StatusUpdateOrResponseCollector
+    def initialize proxy, want, options={}
+      super proxy, want, options.merge(
+        type: ['StatusResponse','MessageNotAck'],
+        title: 'status response'
+      )
+    end
+  end
+end

data/lib/rsmp/collect/status_update_collector.rb

@@ -0,0 +1,11 @@
+module RSMP
+  # Class for waiting for specific status responses
+  class StatusUpdateCollector < StatusUpdateOrResponseCollector
+    def initialize proxy, want, options={}
+      super proxy, want, options.merge(
+        type: ['StatusUpdate','MessageNotAck'],
+        title:'status update'
+      )
+    end
+  end
+end

data/lib/rsmp/collect/status_update_or_response_collector.rb

@@ -0,0 +1,17 @@
+module RSMP
+  # Base class for waiting for status updates or responses
+  class StatusUpdateOrResponseCollector < StateCollector
+    def initialize proxy, want, options={}
+      super proxy, want, options.merge(outgoing: false)
+    end
+
+    def build_query want
+      RSMP::StatusQuery.new want
+    end
+
+    # Get items, in our case status values
+    def get_items message
+      message.attributes['sS'] || []
+    end
+  end
+end

data/lib/rsmp/error.rb

@@ -41,7 +41,7 @@ module RSMP
 	class TimeoutError < Error
 	end
 
-	class DisonnectError < Error
+	class DisconnectError < Error
 	end
 
 	class ConnectionError < Error

data/lib/rsmp/node.rb

@@ -6,7 +6,7 @@ module RSMP
     include Wait
     include Inspect
 
-    attr_reader :archive, :logger, :task, :deferred, :error_queue, :clock
+    attr_reader :archive, :logger, :task, :deferred, :error_queue, :clock, :collector
 
     def initialize options
       initialize_logging options
@@ -15,6 +15,8 @@ module RSMP
       @clock = Clock.new
       @error_queue = Async::Queue.new
       @ignore_errors = []
+      options[:collector]
+      @collect = options[:collect]
     end
 
     def ignore_errors classes, &block

data/lib/rsmp/proxy.rb

@@ -15,9 +15,8 @@ module RSMP
 
     def initialize options
       initialize_logging options
-      setup options
       initialize_distributor
-      prepare_collection @settings['collect']
+      setup options
       clear
     end
 
@@ -37,6 +36,10 @@ module RSMP
       @sxl = nil
       @site_settings = nil  # can't pick until we know the site id
       @state = :stopped
+      if options[:collect]
+        @collector = RSMP::Collector.new self, options[:collect]
+        @collector.start
+      end
     end
 
     def inspect
@@ -49,16 +52,9 @@ module RSMP
       node.clock
     end
 
-    def prepare_collection num
-      if num
-        @collector = RSMP::Collector.new self, num: num, ingoing: true, outgoing: true
-        add_listener @collector
-      end
-    end
-
-    def collect task, options, &block
-      collector = RSMP::Collector.new self, options
-      collector.collect task, &block
+    def collect options, &block
+      collector = RSMP::Collector.new self, options.merge(task: @task)
+      collector.collect &block
       collector
     end
 
@@ -86,7 +82,7 @@ module RSMP
       return if @state == :stopped
       set_state :stopping
       stop_tasks
-      notify_error DisonnectError.new("Connection was closed")
+      notify_error DisconnectError.new("Connection was closed")
     ensure
       close_socket
       clear

data/lib/rsmp/site_proxy.rb

@@ -101,15 +101,8 @@ module RSMP
           "cId" => component,
           "mId" => m_id
       })
-      if options[:collect]
-        task = @task.async do |task|
-          collect_aggregated_status task, options[:collect].merge(m_id: m_id)
-        end
-        send_message message, validate: options[:validate]
-        return message, task.wait
-      else
-        send_message message, validate: options[:validate]
-        message
+      send_and_collect_if_needed message, options do |task|
+        collect_aggregated_status task, options[:collect].merge(m_id: m_id, num:1)
       end
     end
 
@@ -181,7 +174,7 @@ module RSMP
           "sS" => request_list,
           "mId" => m_id
       })
-      send_while_collecting message, options do |task|
+      send_and_collect_if_needed message, options do |task|
         collect_status_responses task, status_list, options[:collect].merge(m_id: m_id)
       end
     end
@@ -193,11 +186,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
+    def send_and_collect_if_needed message, options, &block
+      if options[:collect]
+        task = @task.async { |task| yield task }
+        send_message message, validate: options[:validate]
+        { sent: message, collector: task.wait }
+      else
+        send_message message, validate: options[:validate]
+        return { sent: message }
+      end
     end
 
     def subscribe_to_status component_id, status_list, options={}
@@ -218,7 +215,7 @@ module RSMP
           "sS" => subscribe_list,
           'mId' => m_id
       })
-      send_while_collecting message, options do |task|
+      send_and_collect_if_needed message, options do |task|
          collect_status_updates task, status_list, options[:collect].merge(m_id: m_id)
       end
     end
@@ -264,7 +261,7 @@ module RSMP
           "arg" => command_list,
           "mId" => m_id
       })
-      send_while_collecting message, options do |task|
+      send_and_collect_if_needed message, options do |task|
         collect_command_responses task, command_list, options[:collect].merge(m_id: m_id)
       end
     end
@@ -352,19 +349,27 @@ module RSMP
     end
 
     def collect_status_updates task, status_list, options
-      StatusUpdateMatcher.new(self, status_list, options).collect task
+      collector = StatusUpdateCollector.new(self, status_list, options.merge(task:task))
+      collector.collect
+      collector
     end
 
     def collect_status_responses task, status_list, options
-      StatusResponseMatcher.new(self, status_list, options).collect task
+      collector = StatusResponseCollector.new(self, status_list, options.merge(task:task))
+      collector.collect
+      collector
     end
 
     def collect_command_responses task, command_list, options
-      CommandResponseMatcher.new(self, command_list, options).collect task
+      collector = CommandResponseCollector.new(self, command_list, options.merge(task:task))
+      collector.collect
+      collector
     end
 
     def collect_aggregated_status task, options
-      AggregatedStatusMatcher.new(self, options).collect task
+      collector = AggregatedStatusCollector.new(self, options.merge(task:task))
+      collector.collect
+      collector
     end
   end
 end

data/lib/rsmp/supervisor.rb

@@ -7,7 +7,6 @@ module RSMP
     attr_reader :rsmp_versions, :site_id, :supervisor_settings, :proxies, :logger
 
     def initialize options={}
-
       handle_supervisor_settings( options[:supervisor_settings] || {} )
       super options
       @proxies = []
@@ -161,7 +160,7 @@ module RSMP
         ip: info[:ip],
         port: info[:port],
         task: @task,
-        settings: {'collect'=>@supervisor_settings['collect']},
+        collect: @collect,
         socket: socket,
         stream: stream,
         protocol: protocol,

data/lib/rsmp/supervisor_proxy.rb

@@ -282,11 +282,7 @@ module RSMP
     end
 
     def fetch_last_sent_status component, code, name
-      if @last_status_sent && @last_status_sent[component] && @last_status_sent[component][code]
-        @last_status_sent[component][code][name]
-      else
-        nil
-      end
+      @last_status_sent.dig component, code, name if @last_status_sent
     end
 
     def store_last_sent_status message
@@ -310,10 +306,12 @@ module RSMP
         by_code.each_pair do |code,by_name|
           by_name.each_pair do |name,subscription|
             current = nil
+            should_send = false
             if subscription[:interval] == 0 
               # send as soon as the data changes
               if component_object
                 current, age = *(component_object.get_status code, name)
+                current = current.to_s
               end
               last_sent = fetch_last_sent_status component, code, name
               if current != last_sent

data/lib/rsmp/tlc/signal_group.rb

@@ -16,7 +16,7 @@ module RSMP
         return default unless plan.states
         states = plan.states[c_id]
         return default unless states
-        state =states[pos]
+        state = states[pos]
         return default unless state =~ /[a-hA-G0-9N-P]/  # valid signal group states
         state
       end

data/lib/rsmp/version.rb

@@ -1,3 +1,3 @@
 module RSMP
-  VERSION = "0.7.4"
+  VERSION = "0.8.2"
 end

data/lib/rsmp.rb

@@ -20,10 +20,16 @@ require 'rsmp/components'
 require 'rsmp/collect/notifier'
 require 'rsmp/collect/listener'
 require 'rsmp/collect/collector'
+require 'rsmp/collect/state_collector'
+require 'rsmp/collect/filter'
 require 'rsmp/collect/query'
-require 'rsmp/collect/matcher'
-require 'rsmp/collect/message_queries'
-require 'rsmp/collect/message_matchers'
+require 'rsmp/collect/status_query'
+require 'rsmp/collect/command_query'
+require 'rsmp/collect/status_update_or_response_collector'
+require 'rsmp/collect/status_response_collector'
+require 'rsmp/collect/status_update_collector'
+require 'rsmp/collect/command_response_collector'
+require 'rsmp/collect/aggregated_status_collector'
 require 'rsmp/component'
 require 'rsmp/site'
 require 'rsmp/proxy'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rsmp
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.8.2
 platform: ruby
 authors:
 - Emil Tin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-02 00:00:00.000000000 Z
+date: 2022-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -201,18 +201,26 @@ files:
 - config/supervisor.yaml
 - config/tlc.yaml
 - documentation/classes_and_modules.md
+- documentation/collecting_message.md
 - documentation/message_distribution.md
 - exe/rsmp
 - lib/rsmp.rb
 - lib/rsmp/archive.rb
 - lib/rsmp/cli.rb
+- lib/rsmp/collect/aggregated_status_collector.rb
 - lib/rsmp/collect/collector.rb
+- lib/rsmp/collect/command_query.rb
+- lib/rsmp/collect/command_response_collector.rb
+- lib/rsmp/collect/filter.rb
 - lib/rsmp/collect/listener.rb
-- lib/rsmp/collect/matcher.rb
 - lib/rsmp/collect/message_matchers.rb
-- lib/rsmp/collect/message_queries.rb
 - lib/rsmp/collect/notifier.rb
 - lib/rsmp/collect/query.rb
+- lib/rsmp/collect/state_collector.rb
+- lib/rsmp/collect/status_query.rb
+- lib/rsmp/collect/status_response_collector.rb
+- lib/rsmp/collect/status_update_collector.rb
+- lib/rsmp/collect/status_update_or_response_collector.rb
 - lib/rsmp/component.rb
 - lib/rsmp/components.rb
 - lib/rsmp/convert/export/json_schema.rb