rsmp 0.29.0 → 0.32.0

data/lib/rsmp/collect/collector.rb

@@ -1,40 +1,53 @@
 module RSMP
 
-  # Collects messages from a notifier.
+  # Collects messages from a distributor.
   # 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, :status, :error, :task
+  class Collector
+    include Receiver
+    attr_reader :condition, :messages, :status, :error, :task, :m_id
 
-    def initialize notifier, options={}
-      super notifier, options
+    def initialize distributor, options={}
+      initialize_receiver distributor, filter: options[:filter]
       @options = {
         cancel: {
           schema_error: true,
           disconnect: false,
         }
       }.deep_merge options
-      @ingoing = options[:ingoing] == nil ? true  : options[:ingoing]
-      @outgoing = options[:outgoing] == nil ? false : options[:outgoing]
+      @timeout = options[:timeout]
+      @num = options[:num]
+      @m_id = options[:m_id]
       @condition = Async::Notification.new
-      @title = options[:title] || [@options[:type]].flatten.join('/')
-      if options[:task]
-        @task = options[:task]
+      make_title options[:title]
+      
+      if task
+        @task = task
       else
-         # if notifier is a Proxy, or some other object that implements task(),
+         # if distributor is a Proxy, or some other object that implements task(),
          # then try to get the task that way
-        if notifier.respond_to? 'task'
-          @task = notifier.task
+        if distributor.respond_to? 'task'
+          @task = distributor.task
         end
       end
       reset
     end
 
+    def make_title title
+      if title
+        @title = title
+      elsif @filter
+        @title = [@filter.type].flatten.join('/')
+      else
+        @title = ""
+      end
+    end
+
     def use_task task
       @task = task
     end
 
-    # Clear all query results
+    # Clear all matcher results
     def reset
       @messages = []
       @error = nil
@@ -95,7 +108,7 @@ module RSMP
       wait
       @status
     ensure
-      @notifier.remove_listener self if @notifier
+      @distributor.remove_receiver self if @distributor
     end
 
     # Collect message
@@ -110,8 +123,8 @@ module RSMP
     # the desired messages have been collected, or timeout is reached.
     def wait
       if collecting?
-        if @options[:timeout]
-          @task.with_timeout(@options[:timeout]) { @condition.wait }
+        if @timeout
+          @task.with_timeout(@timeout) { @condition.wait }
         else
           @condition.wait
         end
@@ -136,39 +149,41 @@ module RSMP
     def start &block
       raise RuntimeError.new("Can't start collectimng unless ready (currently #{@status})") unless ready?
       @block = block
-      raise ArgumentError.new("Num, timeout or block must be provided") unless @options[:num] || @options[:timeout] || @block
+      raise ArgumentError.new("Num, timeout or block must be provided") unless @num || @timeout || @block
       reset
       @status = :collecting
       log_start
-      @notifier.add_listener self if @notifier
+      @distributor.add_receiver self if @distributor
     end
 
     # Build a string describing how how progress reached before timeout
     def describe_progress
       str = "#{identifier}: #{@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 << "in response to #{@m_id} " if @m_id
+      str << "didn't complete within #{@timeout}s, "
+      str << "reached #{@messages.size}/#{@num}"
       str
     end
 
     # Check if we receive a NotAck related to initiating request, identified by @m_id.
     def reject_not_ack message
-      return unless @options[:m_id]
+      return unless @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
+        if message.attribute('oMId') == @m_id
+          m_id_short = RSMP::Message.shorten_m_id @m_id, 8
           cancel RSMP::MessageRejected.new("#{@title} #{m_id_short} was rejected with '#{message.attribute('rea')}'")
-          @notifier.log "#{identifier}: cancelled due to a NotAck", level: :debug
+          @distributor.log "#{identifier}: cancelled due to a NotAck", level: :debug
           true
         end
       end
     end
 
     # Handle message. and return true when we're done collecting
-    def notify message
+    def receive message
       raise ArgumentError unless message
-      raise RuntimeError.new("can't process message when status is :#{@status}, title: #{@title}, desc: #{describe}") unless ready? || collecting?
+      unless ready? || collecting?
+        raise RuntimeError.new("can't process message when status is :#{@status}, title: #{@title}, desc: #{describe}") 
+      end
       if perform_match message
         if done?
           complete
@@ -185,8 +200,8 @@ module RSMP
     # Match message against our collection criteria
     def perform_match message
       return false if reject_not_ack(message)
-      return false unless type_match?(message)
-      #@notifier.log "#{identifier}: Looking at #{message.type} #{message.m_id_short}", level: :collect
+      return false unless acceptable?(message)
+      #@distributor.log "#{identifier}: Looking at #{message.type} #{message.m_id_short}", level: :collect
       if @block
         status = [@block.call(message)].flatten
         return unless collecting?
@@ -198,10 +213,10 @@ module RSMP
 
     # Have we collected the required number of messages?
     def done?
-      @options[:num] && @messages.size >= @options[:num]
+      @num && @messages.size >= @num
     end
 
-    # Called when we're done collecting. Remove ourself as a listener,
+    # Called when we're done collecting. Remove ourself as a receiver,
     # se we don't receive message notifications anymore
     def complete
       @status = :ok
@@ -214,39 +229,39 @@ module RSMP
       log_incomplete
     end
 
-    # Remove ourself as a listener, so we don't receive message notifications anymore,
+    # Remove ourself as a receiver, so we don't receive message notifications anymore,
     # and wake up the async condition
     def do_stop
-      @notifier.remove_listener self
+      @distributor.remove_receiver self
       @condition.signal
     end
 
     # An error occured upstream.
     # Check if we should cancel.
-    def notify_error error, options={}
+    def receive_error error, options={}
       case error
       when RSMP::SchemaError
-        notify_schema_error error, options
+        receive_schema_error error, options
       when RSMP::DisconnectError
-        notify_disconnect error, options
+        receive_disconnect error, options
       end
     end
 
     # Cancel if we received e schema error for a message type we're collecting
-    def notify_schema_error error, options
+    def receive_schema_error error, options
       return unless @options.dig(:cancel,:schema_error)
       message = options[:message]
       return unless message
       klass = message.class.name.split('::').last
-      return unless @options[:type] == nil || [@options[:type]].flatten.include?(klass)
-      @notifier.log "#{identifier}: cancelled due to schema error in #{klass} #{message.m_id_short}", level: :debug
+      return unless @filter&.type == nil || [@filter&.type].flatten.include?(klass)
+      @distributor.log "#{identifier}: 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
+    def receive_disconnect error, options
       return unless @options.dig(:cancel,:disconnect)
-      @notifier.log "#{identifier}: cancelled due to a connection error: #{error.to_s}", level: :debug
+      @distributor.log "#{identifier}: cancelled due to a connection error: #{error.to_s}", level: :debug
       cancel error
     end
 
@@ -264,39 +279,27 @@ module RSMP
 
     # Check a message against our match criteria
     # 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]
-        if @options[:type].is_a? Array
-          return false unless @options[:type].include? message.type
-        else
-          return false unless message.type == @options[:type]
-        end
-      end
-      if @options[:component]
-        return false if message.attributes['cId'] && message.attributes['cId'] != @options[:component]
-      end
-      true
+    def acceptable? message
+      @filter == nil || @filter.accept?(message)
     end
 
     # return a string describing the types of messages we're collecting
     def describe_types
-      [@options[:type]].flatten.join('/')
+      [@filter&.type].flatten.join('/')
     end
 
     # return a string that describes whe number of messages, and type of message we're collecting
     def describe_num_and_type
-      if @options[:num] && @options[:num] > 1
-        "#{@options[:num]} #{describe_types}s"
+      if @num && @num > 1
+        "#{@num} #{describe_types}s"
       else
         describe_types
       end
     end
 
     # return a string that describes the attributes that we're looking for
-    def describe_query
-      h = {component: @options[:component]}.compact
+    def describe_matcher
+      h = {component: @filter&.component}.compact
       if h.empty?
         describe_num_and_type
       else
@@ -306,8 +309,8 @@ module RSMP
 
     # return a string that describe how many many messages have been collected
     def describe_progress
-      if @options[:num]
-        "#{@messages.size} of #{@options[:num]} message#{'s' if @messages.size!=1} collected"
+      if @num
+        "#{@messages.size} of #{@num} message#{'s' if @messages.size!=1} collected"
       else
         "#{@messages.size} message#{'s' if @messages.size!=1} collected"
       end        
@@ -315,17 +318,17 @@ module RSMP
 
     # log when we start collecting
     def log_start
-      @notifier.log "#{identifier}: Waiting for #{describe_query}".strip, level: :collect
+      @distributor.log "#{identifier}: Waiting for #{describe_matcher}".strip, level: :collect
     end
 
     # log current progress
     def log_incomplete
-      @notifier.log "#{identifier}: #{describe_progress}", level: :collect
+      @distributor.log "#{identifier}: #{describe_progress}", level: :collect
     end
 
     # log when we end collecting
     def log_complete
-      @notifier.log "#{identifier}: Done", level: :collect
+      @distributor.log "#{identifier}: Done", level: :collect
     end
 
     # get a short id in hex format, identifying ourself

data/lib/rsmp/collect/{command_query.rb → command_matcher.rb}

@@ -1,7 +1,7 @@
 module RSMP
   # Match a specific command responses
-  class CommandQuery < Query
-    # Match a return value item against a query
+  class CommandMatcher < Matcher
+    # Match a return value item against a matcher
     def match? item
       return nil if @want['cCI'] && @want['cCI'] != item['cCI']
       return nil if @want['n'] && @want['n'] != item['n']

data/lib/rsmp/collect/command_response_collector.rb

@@ -3,13 +3,13 @@ module RSMP
   class CommandResponseCollector < StateCollector
     def initialize proxy, want, options={}
       super proxy, want, options.merge(
-        type: 'CommandResponse',
+        filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: 'CommandResponse'),
         title:'command response'
       )
     end
 
-    def build_query want
-      CommandQuery.new want
+    def build_matcher want
+      CommandMatcher.new want
     end
 
     # Get items, in our case the return values

data/lib/rsmp/collect/distributor.rb

@@ -0,0 +1,65 @@
+# Distributes messages to receivers
+
+module RSMP
+  module Distributor
+    attr_reader :receivers
+
+    include Inspect
+
+    def inspect
+      "#<#{self.class.name}:#{self.object_id}, #{inspector(:@receivers)}>"
+    end
+
+    def initialize_distributor
+      @receivers = []
+      @defer_distribution = false
+      @deferred_messages = []
+    end
+
+    def clear_deferred_distribution &block
+      @deferred_messages = []
+    end
+
+    def with_deferred_distribution &block
+      was, @defer_distribution = @defer_distribution, true
+      yield
+      distribute_queued
+    ensure
+      @defer_distribution = was
+      @deferred_messages = []
+    end
+
+    def distribute_queued
+      @deferred_messages.each { |message| distribute_immediately message }
+    ensure
+      @deferred_messages = []
+    end
+
+    def add_receiver receiver
+      raise ArgumentError unless receiver
+      @receivers << receiver unless @receivers.include? receiver
+    end
+
+    def remove_receiver receiver
+      raise ArgumentError unless receiver
+      @receivers.delete receiver
+    end
+
+    def distribute message
+      raise ArgumentError unless message
+      if @defer_distribution
+        @deferred_messages << message
+      else
+        distribute_immediately message
+      end
+    end
+
+    def distribute_immediately message
+      @receivers.each { |receiver| receiver.receive message }
+    end
+
+    def distribute_error error, options={}
+      @receivers.each { |receiver| receiver.receive_error error, options }
+    end
+  end
+end

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