rsmp 0.1.19 → 0.1.31

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,14 @@ 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"]) do
+            task.with_timeout(@site_settings['intervals']['watchdog']) do
               @sleep_condition.wait
             end
           else
@@ -135,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

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
@@ -30,7 +36,7 @@ module RSMP
 
     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
@@ -42,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
@@ -55,23 +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
 
@@ -132,38 +161,39 @@ module RSMP
       @supervisor.site_ids_changed
     end
 
-    def fetch_status parent_task, options
-      wait_for_status_responses(parent_task,options) do |m_id|
-        request_status options.merge(m_id: m_id)
-      end
-    end
+    def request_status component, status_list, options={}
+      raise NotReady unless ready?
+      m_id = options[:m_id] || RSMP::Message.make_m_id
 
-    # Convert from a short ruby hash:
-    # {:S0001=>[:signalgroupstatus, :cyclecounter, :basecyclecounter, :stage]}
-    # to an rsmp-style list:
-    # [{"sCI"=>"S0001", "n"=>"signalgroupstatus"}, {"sCI"=>"S0001", "n"=>"cyclecounter"}, {"sCI"=>"S0001", "n"=>"basecyclecounter"}, {"sCI"=>"S0001", "n"=>"stage"}]
-    #
-    # If the input is already an array, just return it
-    def convert_status_list list
-      return list.clone if list.is_a? Array
-      list.map do |status_code_id,names|
-        names.map do |name|
-          { 'sCI' => status_code_id.to_s, 'n' => name.to_s }
-        end
-      end.flatten
-    end
+      # 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') }
 
-    def request_status options
-      raise NotReady unless ready?
       message = RSMP::StatusRequest.new({
           "ntsOId" => '',
           "xNId" => '',
-          "cId" => options[:component],
-          "sS" => convert_status_list(options[:status_list]),
-          "mId" => options[:m_id]
+          "cId" => component,
+          "sS" => request_list,
+          "mId" => m_id
       })
-      send_message message
-      message
+      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
@@ -173,26 +203,48 @@ module RSMP
 
     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') }
+
       message = RSMP::StatusSubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => convert_status_list(status_list),
-          'mId'=>options[:m_id]
+          "sS" => subscribe_list,
+          'mId' => m_id
       })
-      send_message message
-      return 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
+    def unsubscribe_to_status component, status_list, options={}
       raise NotReady unless ready?
       message = RSMP::StatusUnsubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => convert_status_list(status_list)
+          "sS" => status_list
       })
-      send_message message
+      send_message message, validate: options[:validate]
       message
     end
 
@@ -201,37 +253,7 @@ module RSMP
       acknowledge message
     end
 
-    def status_match? query, item
-      return false if query[:sCI] && query[:sCI] != item['sCI']
-      return false if query[:n] && query[:n] != item['n']
-      return false if query[:q] && query[:q] != item['q']
-      if query[:s].is_a? Regexp
-        return false if query[:s] && item['s'] !~ query[:s]
-      else
-        return false if query[:s] && item['s'] != query[:s]
-      end
-      true
-    end
-
-    def wait_for_alarm options={}
-      raise ArgumentError.new("component argument is missing") 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_alarm_acknowledgement component, alarm_code
+    def send_alarm_acknowledgement component, alarm_code, options={}
       message = RSMP::AlarmAcknowledged.new({
           "ntsOId" => '',
           "xNId" => '',
@@ -241,44 +263,53 @@ module RSMP
           "xNACId" => '',
           "aSp" => 'Acknowledge'
       })
-      send_message message
+      send_message message, validate: options[:validate]
       message
     end
 
-    def wait_for_alarm_acknowledgement_response options
-      raise ArgumentError.new("component argument is missing") unless options[:component]
-      item = @archive.capture(@task,options.merge(
-        num: 1,
-        type: ['AlarmAcknowledgedResponse','MessageNotAck'],
-        with_message: true
-      )) do |item|
-        if item[:message].type == 'MessageNotAck'
-          next item[:message].attribute('oMId') == options[:message].m_id
-        elsif item[:message].type == 'AlarmAcknowledgedResponse'
-          next item[:message].attribute('cId') == options[:message].attribute('cId')
-        end
-      end
-      item[:message] if item
-    end
-
-    def send_command component, args, options={}
+    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" => args,
-          "mId" => options[:m_id]
+          "arg" => command_list,
+          "mId" => m_id
       })
-      send_message message
-      message
+      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
     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'
@@ -296,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
@@ -303,8 +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