rsmp 0.46.0 → 0.48.0

data/lib/rsmp/proxy/supervisor/modules/status_updates.rb

@@ -0,0 +1,148 @@
+module RSMP
+  class SupervisorProxy < Proxy
+    module Modules
+      # Periodic and on-change status update handling.
+      module StatusUpdates
+        PrecomputedStatusValue = Struct.new(:value)
+
+        def fetch_last_sent_status(component, code, name)
+          @last_status_sent&.dig component, code, name
+        end
+
+        def store_last_sent_status(message)
+          component_id = message.attribute('cId')
+          @last_status_sent ||= {}
+          @last_status_sent[component_id] ||= {}
+          message.attribute('sS').each { |item| store_last_sent_status_item(component_id, item) }
+        end
+
+        def store_last_sent_status_item(component_id, item)
+          @last_status_sent[component_id][item['sCI']] ||= {}
+          @last_status_sent[component_id][item['sCI']][item['n']] = item['s']
+        end
+
+        def check_on_change_update(subscription, component, code, name)
+          return [nil, false] unless subscription[:interval].zero?
+
+          current = current_status_value(component, code, name)
+          last_sent = fetch_last_sent_status component.c_id, code, name
+          [current, encode_status_value(code, name, current) != last_sent]
+        end
+
+        def current_status_value(component, code, name)
+          return unless component
+
+          value, quality = *(component.get_status code, name)
+          rsmpify_value(value, quality)
+        end
+
+        def encode_status_value(code, name, value)
+          message = { 'type' => 'StatusUpdate', 'sS' => [{ 'sCI' => code, 'n' => name }] }
+          type, version = RSMP::Schema.resolve_sxl(message, schemas: schemas)
+          descriptor = RSMP::Schema.sxl_argument_descriptor(type, version, :statuses, code, name)
+          descriptor ? RSMP::Message.encode_sxl_value(value, descriptor) : value
+        end
+
+        def interval_update_due?(subscription, now)
+          return true if subscription[:last_sent_at].nil?
+
+          (now - subscription[:last_sent_at]) >= subscription[:interval]
+        end
+
+        def check_status_subscription(subscription, component, code, name, now)
+          current, should_send = check_on_change_update(subscription, component, code, name)
+          should_send ||= interval_update_due?(subscription, now) if subscription[:interval].positive?
+          return [nil, false] unless should_send
+
+          subscription[:last_sent_at] = now
+          [current, true]
+        end
+
+        def status_update_timer(now)
+          send_status_updates status_updates_due(now)
+        end
+
+        def status_updates_due(now)
+          update_list = {}
+          @status_subscriptions.each_pair do |component_id, by_code|
+            collect_component_status_updates(update_list, component_id, by_code, now)
+          end
+          update_list
+        end
+
+        def collect_component_status_updates(update_list, component_id, by_code, now)
+          component = @site.find_component component_id
+          by_code.each_pair do |code, by_name|
+            by_name.each_pair do |name, subscription|
+              current, should_send = check_status_subscription(subscription, component, code, name, now)
+              next unless should_send
+
+              value = precomputed_status_value(subscription, current)
+              add_status_update(update_list, component.c_id, code, name, value)
+            end
+          end
+        end
+
+        def add_status_update(update_list, component_id, code, name, value)
+          update_list[component_id] ||= {}
+          update_list[component_id][code] ||= {}
+          update_list[component_id][code][name] = value
+        end
+
+        def precomputed_status_value(subscription, current)
+          PrecomputedStatusValue.new(current) if subscription[:interval].zero?
+        end
+
+        def build_status_list(component, by_code)
+          by_code.each_pair.with_object([]) do |(code, names), ss|
+            each_status_name(names) do |status_name, value|
+              ss << build_status_item(component, code, status_name, value)
+            end
+          end
+        end
+
+        def each_status_name(names, &block)
+          if names.respond_to?(:each_pair)
+            names.each_pair(&block)
+          else
+            names.each { |status_name| block.call(status_name, nil) }
+          end
+        end
+
+        def build_status_item(component, code, status_name, value)
+          value, quality = status_item_value(component, code, status_name, value)
+          { 'sCI' => code, 'n' => status_name, 's' => rsmpify_value(value, quality), 'q' => quality }
+        end
+
+        def status_item_value(component, code, status_name, value)
+          return [value.value, 'recent'] if value.is_a?(PrecomputedStatusValue)
+
+          component.get_status code, status_name
+        rescue UnknownStatus => e
+          log e.to_s, level: :warning
+          [nil, 'unknown']
+        end
+
+        def send_status_updates(update_list)
+          now = clock.to_s
+          update_list.each_pair do |component_id, by_code|
+            send_component_status_update(component_id, by_code, now)
+          end
+        end
+
+        def send_component_status_update(component_id, by_code, now)
+          component = @site.find_component component_id
+          update = StatusUpdate.new({
+                                      'cId' => component_id,
+                                      'sTs' => now,
+                                      'sS' => build_status_list(component, by_code)
+                                    })
+          apply_nts_message_attributes update
+          send_message update
+          store_last_sent_status update
+          component.status_updates_sent
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/proxy/supervisor/supervisor_proxy.rb

@@ -28,6 +28,11 @@ module RSMP
     # handle communication
     # if disconnected, then try to reconnect
     def run
+      if @protocol
+        run_accepted_connection
+        return
+      end
+
       loop do
         connect
         start_reader
@@ -49,6 +54,20 @@ module RSMP
       end
     end
 
+    def run_accepted_connection
+      self.state = :connected
+      start_reader
+      start_handshake
+      wait_for_reader
+    rescue RSMP::ConnectionError => e
+      log e, level: :error
+    rescue StandardError => e
+      distribute_error e, level: :internal
+    ensure
+      close
+      stop_subtasks
+    end
+
     def start_handshake
       send_version_request @site_settings['site_id'], core_versions
     end

data/lib/rsmp/schema.rb

@@ -218,7 +218,44 @@ module RSMP
     # raises an error if the schema type/version is not found, or has no status catalogue
     def self.status_catalogue(type, version)
       sxl_catalogue(type, version, :statuses).transform_keys(&:to_sym).transform_values do |status|
-        status.fetch('arguments', []).map(&:to_sym)
+        (argument_names(status['required']) + argument_names(status['optional'])).sort.map(&:to_sym)
+      end
+    end
+
+    def self.argument_names(arguments)
+      case arguments
+      when Hash
+        arguments.keys
+      when Array
+        arguments
+      else
+        []
+      end
+    end
+
+    def self.sxl_catalogue_item(type, version, kind, code, options = {})
+      version = sanitize_version(version.to_s) if options[:lenient]
+      catalogue = sxl_catalogue(type, version, kind)
+      prefix = sxl_prefix(type, version, options)
+      code = code.to_s
+      unprefixed = prefix && code.start_with?(prefix) ? code[prefix.length..] : code
+      catalogue[code] || catalogue[code.to_sym] ||
+        catalogue[unprefixed] || catalogue[unprefixed.to_sym]
+    end
+
+    def self.sxl_argument_descriptor(type, version, kind, code, name)
+      item = sxl_catalogue_item(type, version, kind, code)
+      return unless item
+
+      argument_descriptor(item['required'], name) || argument_descriptor(item['optional'], name)
+    end
+
+    def self.argument_descriptor(arguments, name)
+      return unless arguments
+
+      case arguments
+      when Hash
+        arguments[name] || arguments[name.to_sym]
       end
     end
 

data/lib/rsmp/tlc/detector_logic.rb

@@ -66,8 +66,8 @@ module RSMP
 
       def handle_m0008(arg, _options = {})
         @node.verify_security_code 2, arg['securityCode']
-        status = arg['status'] == 'True'
-        mode = arg['mode'] == 'True'
+        status = arg['status']
+        mode = arg['mode']
         force_detector_logic status, mode
         arg
       end

data/lib/rsmp/tlc/modules/helpers.rb

@@ -10,28 +10,6 @@ module RSMP
           plan
         end
 
-        def string_to_bool(bool_str)
-          case bool_str
-          when 'True'
-            true
-          when 'False'
-            false
-          else
-            raise RSMP::MessageRejected, "Invalid boolean '#{bool}', must be 'True' or 'False'"
-          end
-        end
-
-        def bool_string_to_digit(bool)
-          case bool
-          when 'True'
-            '1'
-          when 'False'
-            '0'
-          else
-            raise RSMP::MessageRejected, "Invalid boolean '#{bool}', must be 'True' or 'False'"
-          end
-        end
-
         def bool_to_digit(bool)
           bool ? '1' : '0'
         end

data/lib/rsmp/tlc/modules/inputs.rb

@@ -43,7 +43,7 @@ module RSMP
         def handle_m0006(arg, _options = {})
           @node.verify_security_code 2, arg['securityCode']
           input = arg['input'].to_i
-          status = string_to_bool arg['status']
+          status = arg['status']
           raise MessageRejected, "Input must be in the range 1-#{@inputs.size}" unless input.between?(1, @inputs.size)
 
           if status
@@ -72,6 +72,7 @@ module RSMP
         def parse_input_status(status_string)
           set = []
           clear = []
+          status_string = status_string.join(',') if status_string.is_a?(Array)
           status_string.split(';').each do |part|
             offset, set_bits, clear_bits = part.split(',').map(&:to_i)
             extract_input_bits(set_bits, offset, set)
@@ -136,8 +137,8 @@ module RSMP
         def handle_m0019(arg, _options = {})
           @node.verify_security_code 2, arg['securityCode']
           input = arg['input'].to_i
-          force = string_to_bool arg['status']
-          forced_value = string_to_bool arg['inputValue']
+          force = arg['status']
+          forced_value = arg['inputValue']
           raise MessageRejected, "Input must be in the range 1-#{@inputs.size}" unless input.between?(1, @inputs.size)
 
           if force

data/lib/rsmp/tlc/modules/modes.rb

@@ -74,7 +74,7 @@ module RSMP
         def handle_m0005(arg, _options = {})
           @node.verify_security_code 2, arg['securityCode']
           route = arg['emergencyroute'].to_i
-          enable = (arg['status'] == 'True')
+          enable = arg['status']
           @last_emergency_route = route
 
           if enable
@@ -144,7 +144,7 @@ module RSMP
           when 'intersection'
             TrafficControllerSite.make_status @intersection
           when 'status'
-            TrafficControllerSite.make_status TrafficControllerSite.to_rmsp_bool(@function_position == 'YellowFlash')
+            TrafficControllerSite.make_status @function_position == 'YellowFlash'
           when 'source'
             TrafficControllerSite.make_status @function_position_source
           end

data/lib/rsmp/tlc/modules/plans.rb

@@ -14,7 +14,7 @@ module RSMP
         # M0002 - Set current time plan
         def handle_m0002(arg, _options = {})
           @node.verify_security_code 2, arg['securityCode']
-          if TrafficControllerSite.from_rsmp_bool?(arg['status'])
+          if arg['status']
             switch_plan arg['timeplan'], source: 'forced'
           else
             switch_plan 0, source: 'startup' # TODO: use clock/calender
@@ -55,7 +55,7 @@ module RSMP
         def handle_m0014(arg, _options = {})
           @node.verify_security_code 2, arg['securityCode']
           plan = find_plan arg['plan']
-          arg['status'].split(',').each do |item|
+          status_items(arg['status']).each do |item|
             matched = /(\d+)-(\d+)/.match item
             band = matched[1].to_i
             value = matched[2].to_i
@@ -77,7 +77,7 @@ module RSMP
         # M0017 - Set time tables
         def handle_m0017(arg, _options = {})
           @node.verify_security_code 2, arg['securityCode']
-          arg['status'].split(',').each do |item|
+          status_items(arg['status']).each do |item|
             elems = item.split('-')
             nr = elems[0].to_i
             plan = elems[1].to_i
@@ -119,6 +119,10 @@ module RSMP
           @dynamic_bands_timeout = timeout
         end
 
+        def status_items(status)
+          status.is_a?(Array) ? status : status.split(',')
+        end
+
         # S0014 - Current signal program
         def handle_s0014(_status_code, status_name = nil, _options = {})
           case status_name

data/lib/rsmp/tlc/modules/system.rb

@@ -48,7 +48,7 @@ module RSMP
             TrafficControllerSite.make_status([
                                                 {
                                                   'intersection' => '1',
-                                                  'startup' => TrafficControllerSite.to_rmsp_bool(@is_starting)
+                                                  'startup' => @is_starting
                                                 }
                                               ])
           end

data/lib/rsmp/tlc/proxy/control.rb

@@ -23,13 +23,12 @@ module RSMP
           raise 'TLC main component not found' unless main
 
           security_code = security_code_for(2)
-          active_str = active ? 'True' : 'False'
 
           command_list = [{
             'cCI' => 'M0005',
             'cO' => 'setEmergency',
             'n' => 'status',
-            'v' => active_str
+            'v' => command_value('M0005', 'status', active)
           }, {
             'cCI' => 'M0005',
             'cO' => 'setEmergency',
@@ -39,7 +38,7 @@ module RSMP
             'cCI' => 'M0005',
             'cO' => 'setEmergency',
             'n' => 'emergencyroute',
-            'v' => route.to_s
+            'v' => command_value('M0005', 'emergencyroute', route)
           }]
 
           send_command_and_collect(command_list, within: within).ok!
@@ -56,7 +55,7 @@ module RSMP
             'cCI' => 'M0007',
             'cO' => 'setFixedTime',
             'n' => 'status',
-            'v' => status.to_s
+            'v' => command_value('M0007', 'status', status)
           }, {
             'cCI' => 'M0007',
             'cO' => 'setFixedTime',
@@ -64,8 +63,7 @@ module RSMP
             'v' => security_code.to_s
           }]
 
-          confirm_status = [{ 'sCI' => 'S0009', 'n' => 'status',
-                              's' => /^#{Regexp.escape(status.to_s)}(,#{Regexp.escape(status.to_s)})*$/ }]
+          confirm_status = [{ 'sCI' => 'S0009', 'n' => 'status', 's' => [boolean_value(status)] }]
           send_command_and_collect(command_list, within: within).ok!
           wait_for_status "fixed time #{status}", confirm_status, timeout: within
         end
@@ -81,7 +79,7 @@ module RSMP
             'cCI' => 'M0003',
             'cO' => 'setTrafficSituation',
             'n' => 'status',
-            'v' => 'True'
+            'v' => command_value('M0003', 'status', true)
           }, {
             'cCI' => 'M0003',
             'cO' => 'setTrafficSituation',
@@ -91,10 +89,10 @@ module RSMP
             'cCI' => 'M0003',
             'cO' => 'setTrafficSituation',
             'n' => 'traficsituation',
-            'v' => situation.to_s
+            'v' => command_value('M0003', 'traficsituation', situation)
           }]
 
-          confirm_status = [{ 'sCI' => 'S0015', 'n' => 'status', 's' => situation.to_s }]
+          confirm_status = [{ 'sCI' => 'S0015', 'n' => 'status', 's' => integer_value(situation) }]
           send_command_and_collect(command_list, within: within).ok!
           wait_for_status "traffic situation #{situation}", confirm_status, timeout: within
         end
@@ -110,7 +108,7 @@ module RSMP
             'cCI' => 'M0003',
             'cO' => 'setTrafficSituation',
             'n' => 'status',
-            'v' => 'False'
+            'v' => command_value('M0003', 'status', false)
           }, {
             'cCI' => 'M0003',
             'cO' => 'setTrafficSituation',
@@ -120,10 +118,10 @@ module RSMP
             'cCI' => 'M0003',
             'cO' => 'setTrafficSituation',
             'n' => 'traficsituation',
-            'v' => '1'
+            'v' => command_value('M0003', 'traficsituation', 1)
           }]
 
-          confirm_status = [{ 'sCI' => 'S0015', 'n' => 'status', 's' => '1' }]
+          confirm_status = [{ 'sCI' => 'S0015', 'n' => 'status', 's' => 1 }]
           send_command_and_collect(command_list, within: within).ok!
           wait_for_status 'traffic situation unset', confirm_status, timeout: within
         end
@@ -135,22 +133,24 @@ module RSMP
           [
             { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'status', 'v' => status.to_s },
             { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'securityCode', 'v' => security_code.to_s },
-            { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'timeout', 'v' => timeout_minutes.to_s },
-            { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'intersection', 'v' => '0' }
+            { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'timeout',
+              'v' => command_value('M0001', 'timeout', timeout_minutes) },
+            { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'intersection',
+              'v' => command_value('M0001', 'intersection', 0) }
           ]
         end
 
         def functional_position_confirm_status(status)
           case status.to_s
           when 'YellowFlash'
-            [{ 'sCI' => 'S0011', 'n' => 'status', 's' => /^True(,True)*$/ }]
+            [{ 'sCI' => 'S0011', 'n' => 'status', 's' => [true] }]
           when 'Dark'
-            [{ 'sCI' => 'S0007', 'n' => 'status', 's' => /^False(,False)*$/ }]
+            [{ 'sCI' => 'S0007', 'n' => 'status', 's' => [false] }]
           when 'NormalControl'
             [
-              { 'sCI' => 'S0007', 'n' => 'status', 's' => /^True(,True)*$/ },
-              { 'sCI' => 'S0011', 'n' => 'status', 's' => /^False(,False)*$/ },
-              { 'sCI' => 'S0005', 'n' => 'status', 's' => 'False' }
+              { 'sCI' => 'S0007', 'n' => 'status', 's' => [true] },
+              { 'sCI' => 'S0011', 'n' => 'status', 's' => [false] },
+              { 'sCI' => 'S0005', 'n' => 'status', 's' => false }
             ]
           else
             []

data/lib/rsmp/tlc/proxy/detectors.rb

@@ -15,7 +15,7 @@ module RSMP
             'cCI' => 'M0008',
             'cO' => 'setForceDetectorLogic',
             'n' => 'status',
-            'v' => status.to_s
+            'v' => command_value('M0008', 'status', status)
           }, {
             'cCI' => 'M0008',
             'cO' => 'setForceDetectorLogic',
@@ -25,7 +25,7 @@ module RSMP
             'cCI' => 'M0008',
             'cO' => 'setForceDetectorLogic',
             'n' => 'mode',
-            'v' => mode.to_s
+            'v' => command_value('M0008', 'mode', mode)
           }]
           send_command_and_collect(command_list, component: component_id, within: within).ok!
         end
@@ -41,7 +41,7 @@ module RSMP
             'cCI' => 'M0021',
             'cO' => 'setLevel',
             'n' => 'status',
-            'v' => status.to_s
+            'v' => command_value('M0021', 'status', status)
           }, {
             'cCI' => 'M0021',
             'cO' => 'setLevel',

data/lib/rsmp/tlc/proxy/io.rb

@@ -15,7 +15,7 @@ module RSMP
             'cCI' => 'M0006',
             'cO' => 'setInput',
             'n' => 'status',
-            'v' => status.to_s
+            'v' => command_value('M0006', 'status', status)
           }, {
             'cCI' => 'M0006',
             'cO' => 'setInput',
@@ -25,7 +25,7 @@ module RSMP
             'cCI' => 'M0006',
             'cO' => 'setInput',
             'n' => 'input',
-            'v' => input.to_s
+            'v' => command_value('M0006', 'input', input)
           }]
           send_command_and_collect(command_list, within: within).ok!
         end
@@ -41,7 +41,7 @@ module RSMP
             'cCI' => 'M0013',
             'cO' => 'setInput',
             'n' => 'status',
-            'v' => status.to_s
+            'v' => command_value('M0013', 'status', status)
           }, {
             'cCI' => 'M0013',
             'cO' => 'setInput',
@@ -73,7 +73,7 @@ module RSMP
             'cCI' => 'M0020',
             'cO' => 'setOutput',
             'n' => 'status',
-            'v' => status.to_s
+            'v' => command_value('M0020', 'status', status)
           }, {
             'cCI' => 'M0020',
             'cO' => 'setOutput',
@@ -83,12 +83,12 @@ module RSMP
             'cCI' => 'M0020',
             'cO' => 'setOutput',
             'n' => 'output',
-            'v' => output.to_s
+            'v' => command_value('M0020', 'output', output)
           }, {
             'cCI' => 'M0020',
             'cO' => 'setOutput',
             'n' => 'outputValue',
-            'v' => value.to_s
+            'v' => command_value('M0020', 'outputValue', value)
           }]
           send_command_and_collect(command_list, within: within).ok!
         end
@@ -98,10 +98,13 @@ module RSMP
         def force_input_command_list(input, status, value)
           security_code = security_code_for(2)
           [
-            { 'cCI' => 'M0019', 'cO' => 'setInput', 'n' => 'status', 'v' => status.to_s },
+            { 'cCI' => 'M0019', 'cO' => 'setInput', 'n' => 'status',
+              'v' => command_value('M0019', 'status', status) },
             { 'cCI' => 'M0019', 'cO' => 'setInput', 'n' => 'securityCode', 'v' => security_code.to_s },
-            { 'cCI' => 'M0019', 'cO' => 'setInput', 'n' => 'input', 'v' => input.to_s },
-            { 'cCI' => 'M0019', 'cO' => 'setInput', 'n' => 'inputValue', 'v' => value.to_s }
+            { 'cCI' => 'M0019', 'cO' => 'setInput', 'n' => 'input',
+              'v' => command_value('M0019', 'input', input) },
+            { 'cCI' => 'M0019', 'cO' => 'setInput', 'n' => 'inputValue',
+              'v' => command_value('M0019', 'inputValue', value) }
           ]
         end
 
@@ -110,11 +113,11 @@ module RSMP
           # S0029 is used to check the forced status, but is only available from sxl 1.0.13
           if RSMP::Proxy.version_meets_requirement?(sxl_version, '>=1.0.13')
             result << { 'sCI' => 'S0029', 'n' => 'status',
-                        's' => /^.{#{input.to_i - 1}}#{status == 'True' ? '1' : '0'}/ }
+                        's' => /^.{#{input.to_i - 1}}#{boolean_value(status) ? '1' : '0'}/ }
           end
-          if status == 'True'
+          if boolean_value(status)
             result << { 'sCI' => 'S0003', 'n' => 'inputstatus',
-                        's' => /^.{#{input.to_i - 1}}#{value == 'True' ? '1' : '0'}/ }
+                        's' => /^.{#{input.to_i - 1}}#{boolean_value(value) ? '1' : '0'}/ }
           end
           result
         end