rsmp 0.1.21 → 0.1.32

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,
@@ -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/logging.rb

@@ -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,32 +1,14 @@
+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
-    end
-
-    @@schemas = load_schemas
-
     def self.make_m_id
       SecureRandom.uuid()
     end
@@ -49,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"
@@ -125,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
@@ -136,13 +122,10 @@ module RSMP
       @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
@@ -196,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({

data/lib/rsmp/node.rb

@@ -4,13 +4,23 @@ module RSMP
   class Node
     include Logging
     include Wait
+    include Inspect
 
-    attr_reader :archive, :logger, :task, :deferred
+    attr_reader :archive, :logger, :task, :deferred, :error_condition, :clock
 
     def initialize 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

data/lib/rsmp/notifier.rb

@@ -2,6 +2,11 @@
 
 module RSMP
   module Notifier
+    include Inspect
+
+    def inspect
+      "#<#{self.class.name}:#{self.object_id}, #{inspector(:@listeners)}>"
+    end
 
     def initialize_distributor
       @listeners = []
@@ -17,8 +22,8 @@ module RSMP
       @listeners.delete listener
     end
 
-    def notify item
-      @listeners.each { |listener| listener.notify item }
+    def notify message
+      @listeners.each { |listener| listener.notify message }
     end
   end
 end

data/lib/rsmp/proxy.rb

@@ -1,10 +1,15 @@
 # Logging class for a connection to a remote site or supervisor.
 
+require 'rubygems'
+
 module RSMP  
   class Proxy
+    WRAPPING_DELIMITER = "\f"
+
     include Logging
     include Wait
     include Notifier
+    include Inspect
 
     attr_reader :state, :archive, :connection_info, :sxl, :task, :collector
 
@@ -14,15 +19,26 @@ module RSMP
       @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 options[:settings]['collect']
-
+      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
@@ -31,13 +47,14 @@ module RSMP
     end
 
     def collect task, options, &block
-      probe = RSMP::Collector.new self, options
-      probe.collect task, &block
+      collector = RSMP::Collector.new self, options
+      collector.collect task, &block
     end
 
     def run
       start
       @reader.wait if @reader
+    ensure
       stop unless [:stopped, :stopping].include? @state
     end
 
@@ -89,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
@@ -117,31 +134,33 @@ 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
           begin
-            now = RSMP.now_object
+            now = Clock.now
             timer(now)
           rescue EOFError => e
             log "Timer: Connection closed: #{e}", level: :warning
@@ -152,9 +171,7 @@ module RSMP
           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
+            notify_error e, level: :internal
           end
         ensure
           next_time += interval
@@ -172,7 +189,7 @@ module RSMP
 
     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
@@ -180,21 +197,20 @@ 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
     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
@@ -206,7 +222,7 @@ module RSMP
     end
 
     def check_watchdog_timeout now
-      timeout = @settings["watchdog_timeout"]
+      timeout = @site_settings['timeouts']['watchdog']
       latest = @latest_watchdog_received + timeout
       left = latest - now
       if left < 0
@@ -224,19 +240,31 @@ 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: message
+      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
@@ -261,27 +289,38 @@ module RSMP
     def process_packet json
       attributes = Message.parse_attributes json
       message = Message.build attributes, json
-      message.validate sxl
-      notify message: message
+      message.validate get_schemas
+      notify message
       expect_version_message(message) unless @version_determined
       process_message message
       process_deferred
       message
     rescue InvalidPacket => e
-      log "Received invalid package, must be valid JSON but got #{json.size} bytes: #{e.message}", level: :warning
+      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
-      log "Received malformed message, #{e.message}", message: Malformed.new(attributes), level: :warning
+      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
@@ -321,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
 
@@ -366,10 +412,20 @@ module RSMP
         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({
@@ -455,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