rsmp 0.1.17 → 0.1.30

data/lib/rsmp/listener.rb

@@ -0,0 +1,23 @@
+# Receives items from a Notifier, as long as it's
+# installed as a listener.
+
+module RSMP
+  class Listener
+    include Inspect
+
+    def initialize proxy, options={}
+      @proxy = proxy
+    end
+
+    def notify message
+    end
+
+    def listen &block
+      @proxy.add_listener self
+      yield
+    ensure
+      @proxy.remove_listener self
+    end
+
+  end
+end

data/lib/rsmp/logger.rb

@@ -13,6 +13,7 @@ module RSMP
         'component'=>false,
         'level'=>false,
         'ip'=>false,
+        'port'=>false,
         'index'=>false,
         'timestamp'=>true,
         'json'=>false,
@@ -82,7 +83,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 +125,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
@@ -137,8 +138,9 @@ module RSMP
       parts = []
       parts << item[:index].to_s.ljust(7) if @settings["index"] == true
       parts << item[:author].to_s.ljust(13) if @settings["author"] == true
-      parts << item[:timestamp].to_s.ljust(24) unless @settings["timestamp"] == false
+      parts << Clock.to_s(item[:timestamp]).ljust(24) unless @settings["timestamp"] == false
       parts << item[:ip].to_s.ljust(22) unless @settings["ip"] == false
+      parts << item[:port].to_s.ljust(8) unless @settings["port"] == false
       parts << item[:site_id].to_s.ljust(13) unless @settings["site_id"] == false
       parts << item[:component_id].to_s.ljust(18) unless @settings["component"] == false
       

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
@@ -15,7 +15,7 @@ module RSMP
     end
 
     def log str, options={}
-      default = { str:str, level: :log, author: author }
+      default = { str:str, level: :log, author: author, ip: @ip, port: @port }
       prepared = RSMP::Archive.prepare_item default.merge(options)
       @archive.add prepared
       @logger.log prepared

data/lib/rsmp/message.rb

@@ -1,33 +1,18 @@
+require 'rsmp_schemer'
+
 # rsmp messages
 module RSMP
   class Message
+    include Inspect
 
-    attr_reader :now, :attributes, :out, :timestamp
+    attr_reader :now, :attributes, :out
+    attr_reader :timestamp # this is an internal timestamp recording when we receive/send
     attr_accessor :json, :direction
 
-    def self.load_schemas
-      # path to files in submodule folder
-      schema_path = File.join(File.dirname(__dir__),'rsmp_schema','schema')
-      @@schemas = {}
-
-      core_schema_path = File.join(schema_path,'core','rsmp.json')
-      @@schemas[nil] = JSONSchemer.schema( Pathname.new(core_schema_path) )
-
-      tlc_schema_path = File.join(schema_path,'tlc','sxl.json')
-      @@schemas['traffic_light_controller'] = JSONSchemer.schema( Pathname.new(tlc_schema_path) )
-  
-      @@schemas
-    end
-
-    def self.get_schema sxl=nil
-      schema = @@schemas[sxl]
-      raise SchemaError.new("Unknown schema #{sxl}") unless schema
-      schema
+    def self.make_m_id
+      SecureRandom.uuid()
     end
 
-    @@schemas = load_schemas
-
-
     def self.parse_attributes json
       raise ArgumentError unless json
       JSON.parse json
@@ -46,6 +31,8 @@ module RSMP
         message = Version.new attributes
       when "AggregatedStatus"
         message = AggregatedStatus.new attributes
+      when "AggregatedStatusRequest"
+        message = AggregatedStatusRequest.new attributes
       when "Watchdog"
         message = Watchdog.new attributes
       when "Alarm"
@@ -80,8 +67,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
@@ -118,7 +109,9 @@ module RSMP
     end
 
     def initialize attributes = {}
-      @timestamp = RSMP.now_object
+      @timestamp = Time.now   # this timestamp is for internal use, and does not the clock
+                              # in the node, which can be set by an rsmp supervisor
+
       @attributes = { "mType"=> "rSMsg" }.merge attributes
 
       ensure_message_id
@@ -126,16 +119,13 @@ 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
-      schema = Message.get_schema(sxl)
-      unless schema.valid? attributes
-        errors = schema.validate attributes
-        error_string = errors.map do |item|
-          [item['data_pointer'],item['type'],item['details']].compact.join(' ')
-        end.join(", ")
+    def validate schemas
+      errors = RSMP::Schemer.validate attributes, schemas
+      if errors
+        error_string = errors.compact.join(', ').strip
         raise SchemaError.new error_string
       end
     end
@@ -189,6 +179,14 @@ module RSMP
     end
   end
 
+  class AggregatedStatusRequest < Message
+    def initialize attributes = {}
+      super({
+        "type" => "AggregatedStatusRequest",
+      }.merge attributes)
+    end
+  end
+
   class Alarm < Message
     def initialize attributes = {}
       super({
@@ -197,6 +195,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,58 @@
-# 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
+    include Inspect
+
+    attr_reader :archive, :logger, :task, :deferred, :error_condition, :clock
 
     def initialize options
-      super options
+      initialize_logging options
+      @task = options[:task]
+      @deferred = []
+      @clock = Clock.new
+      @error_condition = Async::Notification.new
+    end
+
+    def notify_error e, options={}
+      if options[:level] == :internal
+        log ["#{e.to_s} in task: #{Async::Task.current.to_s}",e.backtrace].flatten.join("\n"), level: :error
+      end
+      @error_condition.signal e
+    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,29 @@
+# Distributes messages to listeners
+
+module RSMP
+  module Notifier
+    include Inspect
+
+    def inspect
+      "#<#{self.class.name}:#{self.object_id}, #{inspector(:@listeners)}>"
+    end
+
+    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 message
+      @listeners.each { |listener| listener.notify message }
+    end
+  end
+end

data/lib/rsmp/proxy.rb

@@ -1,24 +1,61 @@
-# Base class for a connection to a remote site or supervisor.
+# Logging class for a connection to a remote site or supervisor.
+
+require 'rubygems'
 
 module RSMP  
-  class Proxy < Base
-    attr_reader :state, :archive, :connection_info, :sxl
+  class Proxy
+    WRAPPING_DELIMITER = "\f"
+
+    include Logging
+    include Wait
+    include Notifier
+    include Inspect
+
+    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]
+      @port = options[:port]
       @connection_info = options[:info]
       @sxl = nil
+      @site_settings = nil  # can't pick until we know the site id
+      initialize_distributor
+
+      prepare_collection @settings['collect']
       clear
     end
 
+    def inspect
+      "#<#{self.class.name}:#{self.object_id}, #{inspector(
+        :@acknowledgements,:@settings,:@site_settings
+        )}>"
+    end
+
+    def clock
+      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
+    end
+
     def run
       start
       @reader.wait if @reader
-      stop
+    ensure
+      stop unless [:stopped, :stopping].include? @state
     end
 
     def ready?
@@ -69,7 +106,7 @@ module RSMP
       @reader = @task.async do |task|
         task.annotate "reader"
         @stream = Async::IO::Stream.new(@socket)
-        @protocol = Async::IO::Protocol::Line.new(@stream,RSMP::WRAPPING_DELIMITER) # rsmp messages are json terminated with a form-feed
+        @protocol = Async::IO::Protocol::Line.new(@stream,WRAPPING_DELIMITER) # rsmp messages are json terminated with a form-feed
 
         while json = @protocol.read_line
           beginning = Time.now
@@ -97,33 +134,45 @@ module RSMP
         log "Connection reset by peer", level: :warning
       rescue Errno::EPIPE
         log "Broken pipe", level: :warning
-      rescue SystemCallError => e # all ERRNO errors
-        log "Proxy exception: #{e.to_s}", level: :error
       rescue StandardError => e
-        log ["Proxy exception: #{e.inspect}",e.backtrace].flatten.join("\n"), level: :error
+        notify_error e, level: :internal
       end
     end
 
+    def notify_error e, options={}
+      node.notify_error e, options
+    end
+
     def start_watchdog
-      log "Starting watchdog with interval #{@settings["watchdog_interval"]} seconds", level: :debug
+      log "Starting watchdog with interval #{@site_settings['intervals']['watchdog']} seconds", level: :debug
       send_watchdog
       @watchdog_started = true
     end
 
     def start_timer
       name = "timer"
-      interval = @settings["timer_interval"] || 1
+      interval = @site_settings['intervals']['timer'] || 1
       log "Starting #{name} with interval #{interval} seconds", level: :debug
-      @latest_watchdog_received = RSMP.now_object
+      @latest_watchdog_received = Clock.now
 
       @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 = Clock.now
+            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
+            notify_error e, level: :internal
+          end
         ensure
           next_time += interval
           duration = next_time - Time.now.to_f
@@ -133,14 +182,14 @@ module RSMP
     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
+      return if @site_settings['intervals']['watchdog'] == :never
       
       if @latest_watchdog_send_at == nil
         send_watchdog now
@@ -148,47 +197,38 @@ module RSMP
         # we add half the timer interval to pick the timer
         # event closes to the wanted wathcdog interval
         diff = now - @latest_watchdog_send_at
-        if (diff + 0.5*@settings["timer_interval"]) >= (@settings["watchdog_interval"])
+        if (diff + 0.5*@site_settings['intervals']['timer']) >= (@site_settings['intervals']['watchdog'])
           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
-      now = RSMP.now_object unless nil
-      message = Watchdog.new( {"wTs" => RSMP.now_object_to_string(now)})
+    def send_watchdog now=Clock.now
+      message = Watchdog.new( {"wTs" => clock.to_s})
       send_message message
       @latest_watchdog_send_at = now
     end
 
     def check_ack_timeout now
-      timeout = @settings["acknowledgement_timeout"]
+      timeout = @site_settings['timeouts']['acknowledgement']
       # hash cannot be modify during iteration, so clone it
       @awaiting_acknowledgement.clone.each_pair do |m_id, message|
         latest = message.timestamp + timeout
         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"]
+      timeout = @site_settings['timeouts']['watchdog']
       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
@@ -200,23 +240,36 @@ module RSMP
       super str, options.merge(ip: @ip, port: @port, site_id: @site_id)
     end
 
-    def send_message message, reason=nil
+    def get_schemas
+      # normally we have an sxl, but during connection, it hasn't been established yet
+      # at these times we only validate against the core schema
+      # TODO
+      # what schema should we use to validate the intial Version and MessageAck messages?
+      schemas = { core: '3.1.5' }
+      schemas[sxl] = sxl_version if sxl
+      schemas
+    end
+
+    def send_message message, reason=nil, validate: true
       raise IOError unless @protocol
-      message.generate_json
-      message.validate sxl
       message.direction = :out
+      message.generate_json
+      message.validate get_schemas unless validate==false
       expect_acknowledgement message
       @protocol.write_lines message.json
+      notify message
       log_send message, reason
     rescue EOFError, IOError
       buffer_message message
     rescue SchemaError => e
-      log "Error sending #{message.type}, schema validation failed: #{e.message}", message: message, level: :error
+      str = "Could not send #{message.type} because schema validation failed: #{e.message}"
+      log str, message: message, level: :error
+      notify_error e.exception("#{str} #{message.json}")
     end
 
     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
@@ -236,25 +289,38 @@ module RSMP
     def process_packet json
       attributes = Message.parse_attributes json
       message = Message.build attributes, json
-      message.validate sxl
+      message.validate get_schemas
+      notify 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}"
+      str = "Received invalid package, must be valid JSON but got #{json.size} bytes: #{e.message}"
+      notify_error e.exception(str)
+      log str, level: :warning
       nil
     rescue MalformedMessage => e
-      warning "Received malformed message, #{e.message}", Malformed.new(attributes)
+      str = "Received malformed message, #{e.message}"
+      notify_error e.exception(str)
+      log str, message: Malformed.new(attributes), level: :warning
       # cannot send NotAcknowledged for a malformed message since we can't read it, just ignore it
       nil
     rescue SchemaError => e
-      dont_acknowledge message, "Received", "invalid #{message.type}, schema errors: #{e.message}"
+      str = "Received invalid #{message.type}, schema errors: #{e.message}"
+      log str, message: message, level: :warning
+      notify_error e.exception("#{str} #{message.json}")
+      dont_acknowledge message, str
       message
     rescue InvalidMessage => e
-      dont_acknowledge message, "Received", "invalid #{message.type}, #{e.message}"
+      str = "Received", "invalid #{message.type}, #{e.message}"
+      notify_error e.exception("#{str} #{message.json}")
+      dont_acknowledge message, str
       message
     rescue FatalError => e
-      dont_acknowledge message, "Rejected #{message.type},", "#{e.message}"
+      str = "Rejected #{message.type},"
+      notify_error e.exception("#{str} #{message.json}")
+      dont_acknowledge message, str, "#{e.message}"
       stop
       message
     end
@@ -294,13 +360,20 @@ module RSMP
       dont_acknowledge message, "Received", "extraneous Version message"
     end
 
+    def rsmp_versions
+      return ['3.1.5'] if @site_settings["rsmp_versions"] == 'latest'
+      return ['3.1.1','3.1.2','3.1.3','3.1.4','3.1.5'] if @site_settings["rsmp_versions"] == 'all'
+      @site_settings["rsmp_versions"]
+    end
+
     def check_rsmp_version message
+      versions = rsmp_versions
       # find versions that both we and the client support
-      candidates = message.versions & @settings["rsmp_versions"]
+      candidates = message.versions & versions
       if candidates.any?
-        @rsmp_version = candidates.sort.last  # pick latest version
+        @rsmp_version = candidates.sort_by { |v| Gem::Version.new(v) }.last  # pick latest version
       else
-        raise FatalError.new "RSMP versions [#{message.versions.join(',')}] requested, but only [#{@settings["rsmp_versions"].join(',')}] supported."
+        raise FatalError.new "RSMP versions [#{message.versions.join(',')}] requested, but only [#{versions.join(',')}] supported."
       end
     end
 
@@ -335,14 +408,24 @@ 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
+    rescue Async::TimeoutError
+      raise RSMP::TimeoutError.new "Did not reach state #{state} within #{timeout}s"
     end
 
     def send_version site_id, rsmp_versions
-      versions_array = [rsmp_versions].flatten.map {|v| {"vers" => v} }
+      if rsmp_versions=='latest'
+        versions = ['3.1.5']
+      elsif rsmp_versions=='all'
+        versions = ['3.1.1','3.1.2','3.1.3','3.1.4','3.1.5']
+      else
+        versions = [rsmp_versions].flatten
+      end
+      versions_array = versions.map {|v| {"vers" => v} }
+
       site_id_array = [site_id].flatten.map {|id| {"sId" => id} }
 
       version_response = Version.new({
@@ -428,7 +511,7 @@ module RSMP
 
     def process_watchdog message
       log "Received #{message.type}", message: message, level: :log
-      @latest_watchdog_received = RSMP.now_object
+      @latest_watchdog_received = Clock.now
       acknowledge message
     end
 
@@ -445,27 +528,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