rsmp 0.1.11 → 0.1.21

data/lib/rsmp/collector.rb

@@ -0,0 +1,90 @@
+# A probe checks incoming messages and store matches
+# Once it has collected what it needs, it triggers a condition variable
+# and the client wakes up.
+
+module RSMP
+  class Collector < Listener
+    attr_reader :condition, :items, :done
+
+    def initialize proxy, options={}
+      #raise ArgumentError.new("timeout option is missing") unless options[:timeout]
+      super proxy, options
+      @items = []
+      @condition = Async::Notification.new
+      @done = false
+      @options = options
+      @num = options[:num]
+    end
+
+    def wait
+      @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]
+      @block = block
+
+      siphon do
+        task.with_timeout(@options[:timeout]) do
+          @condition.wait
+        end
+      end
+
+      #if @num == 1
+      #  @items = @items.first       # if one item was requested, return item instead of array
+      #else
+      #  @items = @items.first @num  # return array, but ensure we never return more than requested
+      #end
+      #@items
+    end
+
+    def reset
+      @items.clear
+      @done = false
+    end
+
+    def notify item
+      raise ArgumentError unless item
+      return true if @done
+      return if item[:message].direction == :in && @ingoing == false
+      return if item[:message].direction == :out && @outgoing == false
+      if matches? item
+        @items << item
+        if @num && @items.size >= @num
+          @done = true
+          @proxy.remove_listener self
+          @condition.signal
+        end
+      end
+    end
+
+    def matches? item
+      raise ArgumentError unless item
+
+      if @options[:type]
+        return false if item[:message] == nil
+        if @options[:type].is_a? Array
+          return false unless @options[:type].include? item[:message].type
+        else
+          return false unless item[:message].type == @options[:type]
+        end
+      end
+      return if @options[:level] && item[:level] != @options[:level]
+      return false if @options[:with_message] && !(item[:direction] && item[:message])
+      if @options[:component]
+        return false if item[:message].attributes['cId'] && item[:message].attributes['cId'] != @options[:component]
+      end
+      if @block
+        return false if @block.call(item) == false
+      end
+      true
+    end
+  end
+end

data/lib/rsmp/component.rb

@@ -1,6 +1,6 @@
 module RSMP
   class Component
-    attr_reader :c_id, :alarms, :statuses, :aggregated_status, :aggregated_status_bools, :grouped
+    attr_reader :c_id, :node, :alarms, :statuses, :aggregated_status, :aggregated_status_bools, :grouped
 
     AGGREGATED_STATUS_KEYS = [ :local_control,
                                :communication_distruption,
@@ -23,6 +23,7 @@ module RSMP
     def clear_aggregated_status
       @aggregated_status = []
       @aggregated_status_bools = Array.new(8,false)
+      @aggregated_status_bools[5] = true
     end
 
     def set_aggregated_status status
@@ -58,7 +59,16 @@ module RSMP
     def alarm code:, status:
     end
 
-    def status code:, value:
+    def log str, options
+      @node.log str, options
+    end
+
+    def handle_command command_code, arg
+      raise UnknownCommand.new "Command #{command_code} not implemented by #{self.class}"
+    end
+
+    def get_status status_code, status_name=nil
+      raise UnknownStatus.new "Status #{status_code}/#{status_name} not implemented by #{self.class}"
     end
 
   end

data/lib/rsmp/{site_base.rb → components.rb}

@@ -1,10 +1,10 @@
 # Things shared between sites and site proxies
 
 module RSMP
-  module SiteBase
+  module Components
     attr_reader :components
     
-    def initialize_site
+    def initialize_components
       @components = {}
     end
 
@@ -13,8 +13,10 @@ module RSMP
 
     def setup_components settings
       return unless settings
-      settings.each_pair do |id,settings|
-        @components[id] = build_component(id,settings)
+      settings.each_pair do |type,components_by_type|
+        components_by_type.each_pair do |id,settings|
+          @components[id] = build_component(id:id, type:type, settings:settings)
+        end
       end
     end
 
@@ -22,8 +24,8 @@ module RSMP
       @components[component.c_id] = component
     end
 
-    def build_component id, settings={}
-      Component.new id: id, node: self, grouped: true
+    def build_component id:, type:, settings:{}
+      Component.new id:id, node: self, grouped: true
     end
 
     def find_component component_id

data/lib/rsmp/error.rb

@@ -23,7 +23,7 @@ module RSMP
 	class MissingWatchdog < Error
 	end
 
-	class MissingAcknowledgment < Error
+	class MessageRejected < Error
 	end
 
 	class MissingAttribute < InvalidMessage
@@ -43,4 +43,13 @@ module RSMP
 
 	class UnknownComponent < Error
 	end
+
+	class UnknownCommand < Error
+	end
+
+	class UnknownStatus < Error
+	end
+
+	class ConfigurationError < Error
+	end
 end

data/lib/rsmp/listener.rb

@@ -0,0 +1,33 @@
+# Receives messages from a Notifier, as long as it's
+# installed as a listener.
+# Can listen for ingoing and/or outgoing messages.
+
+module RSMP
+  class Listener
+
+    def initialize proxy, options={}
+      @proxy = proxy
+      @ingoing = options[:ingoing] == nil ? true  : options[:ingoing]
+      @outgoing = options[:outgoing] == nil ? false : options[:outgoing]
+    end
+
+    def ingoing?
+      ingoing == true
+    end
+
+    def outgoing?
+      outgoing == true
+    end
+
+    def notify item
+    end
+
+    def siphon &block
+      @proxy.add_listener self
+      yield
+    ensure
+      @proxy.remove_listener self
+    end
+
+  end
+end

data/lib/rsmp/logger.rb

@@ -82,7 +82,6 @@ module RSMP
     end
 
     def colorize level, str
-      #p String.color_samples
       if @settings["color"] == false || @settings["color"] == nil
         str
       elsif @settings["color"] == true
@@ -125,8 +124,9 @@ module RSMP
       end
     end 
 
-    def dump archive, force:false
-      log = archive.items.map do |item|
+    def dump archive, force:false, num:nil
+      num ||= archive.items.size
+      log = archive.items.last(num).map do |item|
         str = build_output item
         str = colorize item[:level], str
       end

data/lib/rsmp/{base.rb → logging.rb}

@@ -3,10 +3,10 @@
 #
 
 module RSMP
-  class Base
+  module Logging
     attr_reader :archive, :logger
 
-    def initialize options
+    def initialize_logging options
       @archive = options[:archive] || RSMP::Archive.new
       @logger = options[:logger] || RSMP::Logger.new(options[:log_settings]) 
     end

data/lib/rsmp/message.rb

@@ -27,6 +27,9 @@ module RSMP
 
     @@schemas = load_schemas
 
+    def self.make_m_id
+      SecureRandom.uuid()
+    end
 
     def self.parse_attributes json
       raise ArgumentError unless json
@@ -80,8 +83,12 @@ module RSMP
       @attributes["mId"]
     end
 
+    def self.shorten_m_id m_id, length=4
+      m_id[0..length-1]
+    end
+
     def m_id_short
-      @attributes["mId"][0..3]
+      Message.shorten_m_id @attributes["mId"]
     end
 
     def attribute key
@@ -126,7 +133,7 @@ module RSMP
 
     def ensure_message_id
       # if message id is empty, generate a new one
-      @attributes["mId"] ||= SecureRandom.uuid()
+      @attributes["mId"] ||= Message.make_m_id
     end
 
     def validate sxl=nil
@@ -197,6 +204,22 @@ module RSMP
     end
   end
 
+  class AlarmRequest < Message
+    def initialize attributes = {}
+      super({
+        "type" => "Alarm",
+      }.merge attributes)
+    end
+  end
+
+  class AlarmAcknowledged < Message
+    def initialize attributes = {}
+      super({
+        "type" => "Alarm",
+      }.merge attributes)
+    end
+  end
+
   class Watchdog < Message
     def initialize attributes = {}
       super({

data/lib/rsmp/node.rb

@@ -1,23 +1,48 @@
-# RSMP site
-#
-# Handles a single connection to a supervisor.
-# We connect to the supervisor.
+# Base class for sites and supervisors
 
 module RSMP
-  class Node < Base
-    attr_reader :archive, :logger, :task
+  class Node
+    include Logging
+    include Wait
+
+    attr_reader :archive, :logger, :task, :deferred
 
     def initialize options
-      super options
+      initialize_logging options
+      @task = options[:task]
+      @deferred = []
+    end
+
+    def defer item
+      @deferred << item
+    end
+
+    def process_deferred
+      cloned = @deferred.clone    # clone in case do_deferred restarts the current task
+      @deferred.clear
+      cloned.each do |item|
+        do_deferred item
+      end
+    end
+
+    def do_deferred item
+    end
+
+    def do_start task
+      task.annotate self.class.to_s
+      @task = task
+      start_action
+      idle
     end
 
     def start
       starting
-      Async do |task|
-        task.annotate self.class
-        @task = task
-        start_action
-        idle
+      if @task
+        do_start @task
+      else
+        Async do |task|
+          do_start task
+        end
       end
     rescue Errno::EADDRINUSE => e
       log "Cannot start: #{e.to_s}", level: :error

data/lib/rsmp/notifier.rb

@@ -0,0 +1,24 @@
+# Distributes messages to listeners
+
+module RSMP
+  module Notifier
+
+    def initialize_distributor
+      @listeners = []
+    end
+
+    def add_listener listener
+      raise ArgumentError unless listener
+      @listeners << listener unless @listeners.include? listener
+    end
+
+    def remove_listener listener
+      raise ArgumentError unless listener
+      @listeners.delete listener
+    end
+
+    def notify item
+      @listeners.each { |listener| listener.notify item }
+    end
+  end
+end

data/lib/rsmp/proxy.rb

@@ -1,24 +1,44 @@
-# Base class for a connection to a remote site or supervisor.
+# Logging class for a connection to a remote site or supervisor.
 
 module RSMP  
-  class Proxy < Base
-    attr_reader :state, :archive, :connection_info, :sxl
+  class Proxy
+    include Logging
+    include Wait
+    include Notifier
+
+    attr_reader :state, :archive, :connection_info, :sxl, :task, :collector
 
     def initialize options
-      super options
+      initialize_logging options
       @settings = options[:settings]
       @task = options[:task]
       @socket = options[:socket]
       @ip = options[:ip]
       @connection_info = options[:info]
       @sxl = nil
+      initialize_distributor
+
+      prepare_collection options[:settings]['collect']
+
       clear
     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
+      probe = RSMP::Collector.new self, options
+      probe.collect task, &block
+    end
+
     def run
       start
       @reader.wait if @reader
-      stop
+      stop unless [:stopped, :stopping].include? @state
     end
 
     def ready?
@@ -115,26 +135,42 @@ module RSMP
       interval = @settings["timer_interval"] || 1
       log "Starting #{name} with interval #{interval} seconds", level: :debug
       @latest_watchdog_received = RSMP.now_object
+
       @timer = @task.async do |task|
         task.annotate "timer"
+        next_time = Time.now.to_f
         loop do
-          now = RSMP.now_object
-          break if timer(now) == false
-        rescue StandardError => e
-          log ["#{name} exception: #{e}",e.backtrace].flatten.join("\n"), level: :error
+          begin
+            now = RSMP.now_object
+            timer(now)
+          rescue EOFError => e
+            log "Timer: Connection closed: #{e}", level: :warning
+          rescue IOError => e
+            log "Timer: IOError", level: :warning
+          rescue Errno::ECONNRESET
+            log "Timer: Connection reset by peer", level: :warning
+          rescue Errno::EPIPE => e
+            log "Timer: Broken pipe", level: :warning
+          rescue StandardError => e
+            log "Error: #{e}", level: :debug
+          #rescue StandardError => e
+          #  log ["Timer error: #{e}",e.backtrace].flatten.join("\n"), level: :error
+          end
         ensure
-          task.sleep interval
+          next_time += interval
+          duration = next_time - Time.now.to_f
+          task.sleep duration
         end
       end
     end
 
     def timer now
-      check_watchdog_send_time now
-      return false if check_ack_timeout now
-      return false if check_watchdog_timeout now
+      watchdog_send_timer now
+      check_ack_timeout now
+      check_watchdog_timeout now
     end
 
-    def check_watchdog_send_time now
+    def watchdog_send_timer now
       return unless @watchdog_started  
       return if @settings["watchdog_interval"] == :never
       
@@ -148,8 +184,6 @@ module RSMP
           send_watchdog now
         end
       end
-    rescue StandardError => e
-      log ["Watchdog error: #{e}",e.backtrace].flatten.join("\n"), level: :error
     end
 
     def send_watchdog now=nil
@@ -167,24 +201,18 @@ module RSMP
         if now > latest
           log "No acknowledgements for #{message.type} #{message.m_id_short} within #{timeout} seconds", level: :error
           stop
-          return true
         end
       end
-      false
     end
 
     def check_watchdog_timeout now
-
       timeout = @settings["watchdog_timeout"]
       latest = @latest_watchdog_received + timeout
       left = latest - now
-      #log "Check watchdog, time:#{timeout}, last:#{@latest_watchdog_received}, now: #{now}, latest:#{latest}, left #{left}, fail:#{left<0}", level: :debug
       if left < 0
         log "No Watchdog within #{timeout} seconds", level: :error
         stop
-        return true
       end
-      false
     end
 
     def stop_tasks
@@ -203,6 +231,7 @@ module RSMP
       message.direction = :out
       expect_acknowledgement message
       @protocol.write_lines message.json
+      notify message: message
       log_send message, reason
     rescue EOFError, IOError
       buffer_message message
@@ -212,7 +241,7 @@ module RSMP
 
     def buffer_message message
       # TODO
-      log "Cannot send #{message.type} because the connection is closed.", message: message, level: :error
+      #log "Cannot send #{message.type} because the connection is closed.", message: message, level: :error
     end
 
     def log_send message, reason=nil
@@ -233,14 +262,16 @@ module RSMP
       attributes = Message.parse_attributes json
       message = Message.build attributes, json
       message.validate sxl
+      notify message: message
       expect_version_message(message) unless @version_determined
       process_message message
+      process_deferred
       message
     rescue InvalidPacket => e
-      warning "Received invalid package, must be valid JSON but got #{json.size} bytes: #{e.message}"
+      log "Received invalid package, must be valid JSON but got #{json.size} bytes: #{e.message}", level: :warning
       nil
     rescue MalformedMessage => e
-      warning "Received malformed message, #{e.message}", Malformed.new(attributes)
+      log "Received malformed message, #{e.message}", 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 => e
@@ -331,7 +362,7 @@ module RSMP
     def wait_for_state state, timeout
       states = [state].flatten
       return if states.include?(@state)
-      RSMP::Wait.wait_for(@task,@state_condition,timeout) do |s|
+      wait_for(@state_condition,timeout) do
         states.include?(@state)
       end
       @state
@@ -441,27 +472,16 @@ module RSMP
     def version_acknowledged
     end
 
-    def wait_for_acknowledgement original, timeout, options={}
-      raise ArgumentError unless original
-      RSMP::Wait.wait_for(@task,@acknowledgement_condition,timeout) do |message|
-        message.is_a?(MessageAck) &&
-        message.attributes["oMId"] == original.m_id
-      end
-    end
-
-    def wait_for_not_acknowledged original, timeout
+    def wait_for_acknowledgement original, timeout
       raise ArgumentError unless original
-      RSMP::Wait.wait_for(@task,@acknowledgement_condition,timeout) do |message|
-        message.is_a?(MessageNotAck) &&
-        message.attributes["oMId"] == original.m_id
-      end
-    end
-
-    def wait_for_acknowledgements timeout
-      return if @awaiting_acknowledgement.empty?
-      RSMP::Wait.wait_for(@task,@acknowledgement_condition,timeout) do |message|
-        @awaiting_acknowledgement.empty?
+      wait_for(@acknowledgement_condition,timeout) do |message|
+        if message.is_a?(MessageNotAck) && message.attributes["oMId"] == original.m_id
+          raise RSMP::MessageRejected.new(message.attributes['rea'])
+        end
+        message.is_a?(MessageAck) && message.attributes["oMId"] == original.m_id
       end
+    rescue Async::TimeoutError
+      raise RSMP::TimeoutError.new("Acknowledgement for #{original.type} #{original.m_id} not received within #{timeout}s")
     end
 
     def node