rsmp 0.1.17 → 0.1.30

data/lib/rsmp/rsmp.rb

@@ -1,31 +1,42 @@
-# RSMP module
+# Get the current time in UTC, with optional adjustment
+# Convertion to string uses the RSMP format 2015-06-08T12:01:39.654Z 
+# Note that using to_s on a my_clock.to_s will not produce an RSMP formatted timestamp,
+# you need to use Clock.to_s my_clock
+
+require 'time'
 
 module RSMP
-  WRAPPING_DELIMITER = "\f"
 
-  def self.now_object
-    # date using UTC time zone
-    Time.now.utc
-  end
+  class Clock
+    attr_reader :adjustment
 
-  def self.now_object_to_string now
-    # date in the format required by rsmp, using UTC time zone
-    # example: 2015-06-08T12:01:39.654Z
-    time ||= now.utc
-    time.strftime("%FT%T.%3NZ")
-  end
+    def initialize
+      @adjustment = 0
+    end
 
-  def self.now_string time=nil
-    time ||= Time.now
-    now_object_to_string time
-  end
+    def set target
+      @adjustment = target - Time.now
+    end
 
-  def self.parse_time time_str
-    Time.parse time_str
-  end
-  
-  def self.log_prefix ip
-    "#{now_string} #{ip.ljust(20)}"
-  end
+    def reset
+      @adjustment = 0
+    end
 
+    def now
+      Time.now.utc + @adjustment
+    end
+
+    def to_s
+      Clock.to_s now
+    end
+
+    def self.now
+      Time.now.utc
+    end
+
+    def self.to_s time=nil
+      (time || now).strftime("%FT%T.%3NZ")
+    end
+
+  end
 end

data/lib/rsmp/site.rb

@@ -4,12 +4,12 @@
 
 module RSMP
   class Site < Node
-    include SiteBase
+    include Components
 
     attr_reader :rsmp_versions, :site_settings, :logger, :proxies
 
     def initialize options={}
-      initialize_site
+      initialize_components
       handle_site_settings options
       super options
       @proxies = []
@@ -20,43 +20,41 @@ module RSMP
       @site_settings['site_id']
     end
 
-    def handle_site_settings options
-      @site_settings = {
+    def handle_site_settings options={}
+      defaults = {
         'site_id' => 'RN+SI0001',
         'supervisors' => [
           { 'ip' => '127.0.0.1', 'port' => 12111 }
         ],
-        'rsmp_versions' => ['3.1.1','3.1.2','3.1.3','3.1.4'],
-        'sxl' => 'traffic_light_controller',
-        'sxl_version' => '1.0.7',
-        'timer_interval' => 0.1,
-        'watchdog_interval' => 1,
-        'watchdog_timeout' => 2,
-        'acknowledgement_timeout' => 2,
-        'command_response_timeout' => 1,
-        'status_response_timeout' => 1,
-        'status_update_timeout' => 1,
-        'site_connect_timeout' => 2,
-        'site_ready_timeout' => 1,
-        'reconnect_interval' => 0.1,
+        'rsmp_versions' => 'all',
+        'sxl' => 'tlc',
+        'sxl_version' => '1.0.15',
+        'intervals' => {
+          'timer_' => 0.1,
+          'watchdog' => 1,
+          'reconnect' => 0.1
+        },
+        'timeouts' => {
+          'watchdog' => 2,
+          'acknowledgement' => 2
+        },
         'send_after_connect' => true,
         'components' => {
           'C1' => {}
         }
       }
-      if options[:site_settings]
-        converted = options[:site_settings].map { |k,v| [k.to_s,v] }.to_h   #convert symbol keys to string keys
-        converted.compact!
-        @site_settings.merge! converted
-      end
-
-      required = [:supervisors,:rsmp_versions,:site_id,:watchdog_interval,:watchdog_timeout,
-                  :acknowledgement_timeout,:command_response_timeout]
-      check_required_settings @site_settings, required
-
+      
+      @site_settings = defaults.deep_merge options[:site_settings]
+      check_sxl_version
       setup_components @site_settings['components']
     end
 
+    def check_sxl_version
+      sxl = @site_settings['sxl']
+      version = @site_settings['sxl_version']
+      RSMP::Schemer::find_schema! sxl, version
+    end
+
     def reconnect
       @sleep_condition.signal
     end
@@ -64,8 +62,10 @@ module RSMP
     def start_action
       @site_settings["supervisors"].each do |supervisor_settings|
         @task.async do |task|
-          task.annotate "site_proxy"
+          task.annotate "site proxy"
           connect_to_supervisor task, supervisor_settings
+        rescue StandardError => e
+          notify_error e, level: :internal
         end
       end
     end
@@ -101,16 +101,16 @@ module RSMP
         proxy.run       # run until disconnected
       rescue IOError => e
         log "Stream error: #{e}", level: :warning
-      rescue SystemCallError => e # all ERRNO errors
-        log "Reader exception: #{e.to_s}", level: :error
       rescue StandardError => e
-        log ["Reader exception: #{e}",e.backtrace].flatten.join("\n"), level: :error
+        notify_error e, level: :internal
       ensure
         begin
-          if @site_settings["reconnect_interval"] != :no
+          if @site_settings['intervals']['watchdog'] != :no
             # sleep until waken by reconnect() or the reconnect interval passed
             proxy.set_state :wait_for_reconnect
-            task.with_timeout(@site_settings["reconnect_interval"]) { @sleep_condition.wait }
+            task.with_timeout(@site_settings['intervals']['watchdog']) do
+              @sleep_condition.wait
+            end
           else
             proxy.set_state :cannot_connect
             break
@@ -133,7 +133,7 @@ module RSMP
     def starting
       log "Starting site #{@site_settings["site_id"]}",
           level: :info,
-          timestamp: RSMP.now_object
+          timestamp: @clock.now
     end
 
     def alarm
@@ -141,5 +141,6 @@ module RSMP
         proxy.stop
       end
     end
+
   end
 end

data/lib/rsmp/site_proxy.rb

@@ -2,18 +2,24 @@
 
 module RSMP  
   class SiteProxy < Proxy
-    include SiteBase
+    include Components
+    include SiteProxyWait
 
     attr_reader :supervisor, :site_id
 
     def initialize options
       super options
-      initialize_site
+      initialize_components
       @supervisor = options[:supervisor]
       @settings = @supervisor.supervisor_settings.clone
       @site_id = nil
     end
 
+    def inspect
+      "#<#{self.class.name}:#{self.object_id}, #{inspector(
+        :@acknowledgements,:@settings,:@site_settings,:@components
+        )}>"
+    end
     def node
       supervisor
     end
@@ -23,9 +29,14 @@ module RSMP
       start_reader
     end
 
+    def stop
+      log "Closing connection to site", level: :info
+      super
+    end
+
     def connection_complete
       super
-      log "Connection to site #{@site_id} established", level: :info
+      log "Connection to site #{@site_id} established, using core #{@rsmp_version}, #{@sxl} #{@site_sxl_version}", level: :info
     end
 
     def process_message message
@@ -37,6 +48,8 @@ module RSMP
           will_not_handle message
         when AggregatedStatus
           process_aggregated_status message
+        when AggregatedStatusRequest
+          will_not_handle message
         when Alarm
           process_alarm message
         when CommandResponse
@@ -50,19 +63,44 @@ module RSMP
       end
     end
 
+    def process_command_response message
+      log "Received #{message.type}", message: message, level: :log
+      acknowledge message
+    end
+
+    def process_deferred
+      supervisor.process_deferred
+    end
+
     def version_accepted message
-      log "Received Version message for site #{@site_id} using RSMP #{@rsmp_version}", message: message, level: :log
+      log "Received Version message for site #{@site_id}", message: message, level: :log
       start_timer
       acknowledge message
-      send_version @site_id, @settings['rsmp_versions']
+      send_version @site_id, rsmp_versions
       @version_determined = true
 
-      if @settings['sites']
-        @site_settings = @settings['sites'][@site_id]
-        @site_settings =@settings['sites'][:any] unless @site_settings
-        if @site_settings
-          setup_components @site_settings['components']
+    end
+
+    def request_aggregated_status component, options={}
+      raise NotReady unless ready?
+      m_id = options[:m_id] || RSMP::Message.make_m_id
+
+      message = RSMP::AggregatedStatusRequest.new({
+          "ntsOId" => '',
+          "xNId" => '',
+          "cId" => component,
+          "mId" => m_id
+      })
+      if options[:collect]
+        result = nil
+        task = @task.async do |task|
+          wait_for_aggregated_status task, options[:collect]
         end
+        send_message message, validate: options[:validate]
+        return message, task.wait
+      else
+        send_message message, validate: options[:validate]
+        message
       end
     end
 
@@ -123,16 +161,39 @@ module RSMP
       @supervisor.site_ids_changed
     end
 
-    def request_status component, status_list, timeout=nil
-      raise NotReady unless @state == :ready
+    def request_status component, status_list, options={}
+      raise NotReady unless ready?
+      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
+      request_list = status_list.map { |item| item.slice('sCI','n') }
+
       message = RSMP::StatusRequest.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => status_list
+          "sS" => request_list,
+          "mId" => m_id
       })
-      send_message message
-      return message, wait_for_status_response(message: message, timeout: timeout)
+      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
+      end
     end
 
     def process_status_response message
@@ -140,43 +201,50 @@ module RSMP
       acknowledge message
     end
 
-    def wait_for_status_response options
-      raise ArgumentError unless options[:message]
-      item = @archive.capture(@task, options.merge(
-        type: ['StatusResponse','MessageNotAck'],
-        with_message: true,
-        num: 1
-      )) do |item|
-        if item[:message].type == 'MessageNotAck'
-          next item[:message].attribute('oMId') == options[:message].m_id
-        elsif item[:message].type == 'StatusResponse'
-          next item[:message].attribute('cId') == options[:message].attribute('cId')
-        end
-      end
-      item[:message] if item
-    end
+    def subscribe_to_status component, status_list, options={}
+      raise NotReady unless ready?
+      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 subscribe message
+      subscribe_list = status_list.map { |item| item.slice('sCI','n','uRt') }
 
-    def subscribe_to_status component, status_list, timeout
-      raise NotReady unless @state == :ready
       message = RSMP::StatusSubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => status_list
+          "sS" => subscribe_list,
+          'mId' => m_id
       })
-      send_message message
-      return message, wait_for_status_update(component: component, timeout: timeout)[:message]
+      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
+      end
     end
 
-    def unsubscribe_to_status component, status_list
-      raise NotReady unless @state == :ready
+    def unsubscribe_to_status component, status_list, options={}
+      raise NotReady unless ready?
       message = RSMP::StatusUnsubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
           "sS" => status_list
       })
-      send_message message
+      send_message message, validate: options[:validate]
       message
     end
 
@@ -185,80 +253,63 @@ module RSMP
       acknowledge message
     end
 
-    def wait_for_status_update options={}
-      raise ArgumentError unless options[:component]
-      matching_status = nil
-      item = @archive.capture(@task,options.merge(type: "StatusUpdate", with_message: true, num: 1)) do |item|
-        # TODO check components
-        matching_status = nil
-        sS = item[:message].attributes['sS']
-        sS.each do |status|
-          next if options[:sCI] && options[:sCI] != status['sCI']
-          next if options[:n] && options[:n] != status['n']
-          next if options[:q] && options[:q] != status['q']
-          if options[:s].is_a? Regexp
-            next if options[:s] && status['s'] !~ options[:s]
-          else
-            next if options[:s] && options[:s] != status['s']
-          end
-          matching_status = status
-          break
-        end
-        matching_status != nil
-      end
-      if item
-        { message: item[:message], status: matching_status }
-      end
-    end
-
-    def wait_for_alarm options={}
-      raise ArgumentError unless options[:component]
-      matching_alarm = nil
-      item = @archive.capture(@task,options.merge(type: "Alarm", with_message: true, num: 1)) do |item|
-        # TODO check components
-        matching_alarm = nil
-        alarm = item[: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: item[:message], status: matching_alarm }
-      end
-    end
-
-    def send_command component, args
-      raise NotReady unless @state == :ready
-      message = RSMP::CommandRequest.new({
+    def send_alarm_acknowledgement component, alarm_code, options={}
+      message = RSMP::AlarmAcknowledged.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "arg" => args
+          "aCId" => alarm_code,
+          "xACId" => '',
+          "xNACId" => '',
+          "aSp" => 'Acknowledge'
       })
-      send_message message
+      send_message message, validate: options[:validate]
       message
     end
 
-    def process_command_response message
-      log "Received #{message.type}", message: message, level: :log
-      acknowledge message
-    end
-
-    def wait_for_command_response options
-      raise ArgumentError unless options[:component]
-      item = @archive.capture(@task,options.merge(num: 1, type: "CommandResponse", with_message: true)) do |item|
-         # check component
+    def send_command component, command_list, options={}
+      raise NotReady unless ready?
+      m_id = options[:m_id] || RSMP::Message.make_m_id
+      message = RSMP::CommandRequest.new({
+          "ntsOId" => '',
+          "xNId" => '',
+          "cId" => component,
+          "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
       end
-      item[:message] if item
     end
 
     def set_watchdog_interval interval
-      @settings["watchdog_interval"] = interval
+      @settings['intervals']['watchdog'] = interval
     end
 
     def check_sxl_version message
+
+      # check that we have a schema for specified sxl type and version
+      # note that the type comes from the site config, while the version
+      # comes from the Version message send by the site
+      type = 'tlc'
+      version = message.attribute 'SXL'
+      RSMP::Schemer::find_schema! type, version 
+
       # store sxl version requested by site
       # TODO should check agaist site settings
       @site_sxl_version = message.attribute 'SXL'
@@ -276,6 +327,8 @@ module RSMP
       check_rsmp_version message
       check_sxl_version message
       version_accepted message
+    rescue RSMP::Schemer::UnknownSchemaError => e
+      dont_acknowledge message, "Rejected #{message.type} message,", "#{e}"
     end
 
     def check_site_ids message
@@ -283,9 +336,38 @@ module RSMP
       site_id = message.attribute("siteId").map { |item| item["sId"] }.first
       @supervisor.check_site_id site_id
       @site_id = site_id
+      setup_site_settings
       site_ids_changed
     end
 
+    def find_site_settings site_id
+      if @settings['sites'] && @settings['sites'][@site_id]
+        log "Using site settings for site id #{@site_id}", level: :debug
+        return @settings['sites'][@site_id]
+      end
+
+      settings = @settings['guest']
+      if @settings['guest']
+        log "Using site settings for guest", level: :debug
+        return @settings['guest']
+      end
+  
+      nil
+    end
+
+    def setup_site_settings
+      @site_settings = find_site_settings @site_id
+      if @site_settings
+        @sxl = @site_settings['sxl']
+        setup_components @site_settings['components']
+      else
+        dont_acknowledge message, 'Rejected', "No config found for site #{@site_id}"
+      end
+    end
+
+    def notify_error e, options={}
+      @supervisor.notify_error e, options if @supervisor
+    end
 
   end
 end