rsmp 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a57d963e9f3f6f4dccdfbfaf7bc2d4c09fcbae56d1ec886ed699faa373e054ed
-  data.tar.gz: 4035d49f738d335f94d4df8c9dd33a3744d258740e51df55be9da5998ce3e538
+  metadata.gz: 9a3b1b8a67bdc7a3c8887ea606d3539d934121d99597f1a77f697d8259daba97
+  data.tar.gz: 03f420b48a4eff2f3b6978eed5053a838a87da4f507eb2ddb2f0c15cb0e3e7b4
 SHA512:
-  metadata.gz: 94e7df5ad072745c960726053e0630b8b9efefc87c746a0f96afb53c32c4ff7450a553d3576a9ad9cd430640355e8ff329862cb4fd24da8338780e500f3c0245
-  data.tar.gz: 70b0a93eb41dca5cfabe62cacfb08f675fe2f359886bc4038aa647a95d873553b04056277ee08bac16476c441c7b6f646300179567fe2b33f58aa83121456b37
+  metadata.gz: 9fef0b5ea4b2e5481d3be7992e76c7cddb1d20db49df06c86d9b90faa37b56d458fde9cba36e14ea085e96e67f61dbe67f1a82a49401d360cb48900c6138b27d
+  data.tar.gz: a14a735fccf39e8584e3d9ab43a1fdb727c279f395c138d9c7c50f7a8d491265c0aeb3aa67ee071642195bd7a15e0339de4785b5230bbed624965ef3619a231e

data/Gemfile.lock

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

data/lib/rsmp/collector.rb

@@ -1,21 +1,19 @@
-# 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
+      reset
     end
 
     def inspect
@@ -34,17 +32,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 +42,97 @@ 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
+    def result
+      return @messages.first if @options[:num] == 1      # if one message was requested, return it instead of array
+      @messages.first @options[:num]      # return array, but ensure we never return more than requested
     end
 
     def reset
-      @message.clear
+      @messages = []
+      @error = nil
       @done = false
     end
 
+    # Check for MessageNotAck
+    # If the original request identified by @m_id is rejected, set the result to an exception,
+    # which will be returned by the async 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.
+    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
+      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
+    def done?
+      @options[:num] && @messages.size >= @options[:num]
+    end
+
+    def complete
+      @done = true
+      @proxy.remove_listener self
+      @condition.signal
+    end
+
+    def keep message
+      @messages << message
+    end
+
+    def forget message
+      @messages.delete message
+    end
 
+    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/matcher.rb

@@ -0,0 +1,183 @@
+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
+
+    # 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
+
+    # Queries left to match?
+    def done?
+      @queries.values.all? { |result| result != 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 is wanted.
+    # Returns true when we found all that we want.
+    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 request'
+      )
+    end
+
+    def get_items message
+      message.attributes['rvs']
+    end
+
+    # Match an 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
+
+    def get_items message
+      message.attributes['sS']
+    end
+
+    # Match an item 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 request'
+      )
+    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 subscription'
+      )
+    end
+  end
+
+  # Class for waiting for an aggregated status response
+  class AggregatedStatusMatcher < Collector
+    def initialize proxy, options={}
+      super proxy, options.merge(
+        num: 1,
+        type: ['AggregatedStatus','MessageNotAck'],
+        title: 'aggregated status request'
+      )
+    end
+  end
+end

data/lib/rsmp/proxy.rb

@@ -59,6 +59,7 @@ module RSMP
     def collect task, options, &block
       collector = RSMP::Collector.new self, options
       collector.collect task, &block
+      collector
     end
 
     def run

data/lib/rsmp/site_proxy.rb

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

data/lib/rsmp/site_proxy_wait.rb

@@ -1,184 +0,0 @@
-# waiting for various types of messages and reponses from remote sites
-module RSMP
-  module SiteProxyWait
-
-    class Matcher
-      attr_reader :result, :messages
-
-      # Initialize with a list a wanted statuses
-      def initialize want, options={}
-        @want = want.clone
-        @result = {}
-        @messages = []
-        @m_id = options[:m_id]
-      end
-
-      # Check if a messages is wanted.
-      # Returns true when we found all that we want.
-      def process message
-        ack_status = check_not_ack message
-        return ack_status if ack_status != nil
-
-        add = false
-        @want.each_with_index do |query,i|          # look through wanted
-          get_items(message).each do |input|  # look through status items in message
-            matching = 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      # queries left to match?
-      end
-
-      # Check for MessageNotAck
-      # If the original request identified by @m_id is rejected, we abort
-      def check_not_ack 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 async 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("#{type_str} #{m_id_short} was rejected: #{message.attribute('rea')}")
-            @messages = [message]
-            return true
-          end
-          return false
-        end
-      end
-    end
-
-    class CommandResponseMatcher < RSMP::SiteProxyWait::Matcher
-      def initialize want, options={}
-        super
-      end
-
-      def type_str
-        "Command request"
-      end
-
-      def get_items message
-        message.attributes['rvs']
-      end
-
-      def 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
-    end
-
-    # Class for matching incoming messaging against a list of wanted statuses,
-    # and flagging when everything has been matched.
-    class StatusResponseMatcher < RSMP::SiteProxyWait::Matcher
-      def initialize want, options={}
-        super
-      end
-
-      def type_str
-        "Status request"
-      end
-
-      def get_items message
-        message.attributes['sS']
-      end
-
-      # Match an item against a query
-      def 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
-    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, 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"
-      matcher = CommandResponseMatcher.new options[:command_list], m_id: m_id
-      collect(parent_task,options.merge(type: ['CommandResponse','MessageNotAck'], num: 1)) do |message|
-        matcher.process message   # returns true when done (all queries matched)
-      end
-      return matcher.result, matcher.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
-      matcher = StatusResponseMatcher.new options[:status_list], m_id: m_id
-      collect(task,options.merge( type: [type,'MessageNotAck'], num: 1 )) do |message|
-        matcher.process message   # returns true when done (all queries matched)
-      end
-      return matcher.result, matcher.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 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

@@ -225,7 +225,12 @@ module RSMP
       return site if site
       wait_for(@site_id_condition,timeout) { find_site site_id }
     rescue Async::TimeoutError
-      raise RSMP::TimeoutError.new "Site '#{site_id}' did not connect within #{timeout}s"
+      if site_id == :any
+        str = "No site connected"
+      else
+        str = "Site '#{site_id}' did not connect"
+      end
+      raise RSMP::TimeoutError.new "#{str} within #{timeout}s"
     end
 
     def wait_for_site_disconnect site_id, timeout

data/lib/rsmp/supervisor_proxy.rb

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

data/lib/rsmp/version.rb

@@ -1,3 +1,3 @@
 module RSMP
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 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.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Emil Tin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-08 00:00:00.000000000 Z
+date: 2021-10-14 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