rsmp 0.46.0 → 0.48.0

data/lib/rsmp/options/schemas/supervisor_site.json

@@ -8,42 +8,30 @@
       "propertyNames": { "not": { "const": "core" } },
       "additionalProperties": { "type": "string" }
     },
+    "core_version": { "type": "string" },
+    "rsmp_versions": {
+      "oneOf": [
+        { "type": "string" },
+        { "type": "array", "items": { "type": "string" } }
+      ]
+    },
     "type": { "type": "string" },
-    "components": { "type": "object" },
+    "components": { "$ref": "config_common.json#/$defs/components" },
     "supervisors": {
       "type": "array",
-      "items": {
-        "type": "object",
-        "properties": {
-          "ip": { "type": "string" },
-          "port": { "type": ["integer", "string"] }
-        },
-        "required": ["ip", "port"],
-        "additionalProperties": true
-      }
-    },
-    "intervals": {
-      "type": "object",
-      "properties": {
-        "timer": { "type": "number" },
-        "watchdog": { "type": "number" },
-        "reconnect": { "type": "number" },
-        "after_connect": { "type": "number" }
-      },
-      "additionalProperties": true
-    },
-    "timeouts": {
-      "type": "object",
-      "properties": {
-        "connect": { "type": "number" },
-        "watchdog": { "type": "number" },
-        "acknowledgement": { "type": "number" }
-      },
-      "additionalProperties": true
+      "items": { "$ref": "config_common.json#/$defs/endpoint" }
     },
+    "intervals": { "$ref": "config_common.json#/$defs/intervals" },
+    "timeouts": { "$ref": "config_common.json#/$defs/timeouts" },
     "send_after_connect": { "type": "boolean" },
+    "receive_alarms": { "type": "boolean" },
+    "message_buffer": { "$ref": "config_common.json#/$defs/message_buffer" },
     "skip_validation": { "type": "array", "items": { "type": "string" } },
-    "security_codes": { "type": "object" }
+    "security_codes": { "$ref": "config_common.json#/$defs/security_codes" },
+    "startup_sequence": { "type": "string" },
+    "signal_plans": { "$ref": "config_common.json#/$defs/signal_plans" },
+    "inputs": { "$ref": "config_common.json#/$defs/inputs" },
+    "live_output": { "type": ["string", "null"] }
   },
-  "additionalProperties": true
+  "additionalProperties": false
 }

data/lib/rsmp/options/schemas/traffic_controller_site.json

@@ -12,8 +12,7 @@
         "inputs": { "type": "object" },
         "live_output": { "type": ["string", "null"] },
         "type": { "type": "string" }
-      },
-      "additionalProperties": true
+      }
     }
   ]
 }

data/lib/rsmp/options/site_options.rb

@@ -5,28 +5,15 @@ module RSMP
       def defaults
         {
           'site_id' => 'RN+SI0001',
-          'supervisors' => [
-            { 'ip' => '127.0.0.1', 'port' => 12_111 }
-          ],
-          'sxls' => {
-            'tlc' => RSMP::Schema.latest_version(:tlc)
-          },
-          'intervals' => {
-            'timer' => 0.1,
-            'watchdog' => 1,
-            'reconnect' => 0.1
-          },
-          'timeouts' => {
-            'watchdog' => 2,
-            'acknowledgement' => 2
-          },
+          'connection_role' => 'client',
+          'ip' => '0.0.0.0',
+          'supervisors' => default_supervisors,
+          'sxls' => default_sxls,
+          'intervals' => default_intervals,
+          'timeouts' => default_timeouts,
           'send_after_connect' => true,
           'message_buffer' => default_message_buffer,
-          'components' => {
-            'main' => {
-              'C1' => {}
-            }
-          }
+          'components' => default_components
         }
       end
 
@@ -38,16 +25,37 @@ module RSMP
 
       def default_message_buffer
         {
-          'enabled' => true,
           'max_messages' => 10_000,
-          'statuses' => []
+          'statuses' => true
         }
       end
 
+      def default_supervisors
+        [{ 'ip' => '127.0.0.1', 'port' => 12_111 }]
+      end
+
+      def default_sxls
+        { 'tlc' => RSMP::Schema.latest_version(:tlc) }
+      end
+
+      def default_intervals
+        { 'timer' => 0.1, 'watchdog' => 1, 'reconnect' => 0.1 }
+      end
+
+      def default_timeouts
+        { 'watchdog' => 2, 'acknowledgement' => 2 }
+      end
+
+      def default_components
+        { 'main' => { 'C1' => {} } }
+      end
+
       def apply_defaults(options)
         defaults = defaults()
         defaults['components']['main'] = options['components']['main'] if options.dig('components', 'main')
-        defaults.deep_merge(options)
+        data = defaults.deep_merge(options)
+        data['port'] ||= data.dig('supervisors', 0, 'port')
+        data
       end
     end
   end

data/lib/rsmp/options/supervisor_options.rb

@@ -5,6 +5,7 @@ module RSMP
       def defaults
         {
           'port' => 12_111,
+          'connection_role' => 'server',
           'ips' => 'all',
           'default' => {
             'sxls' => {

data/lib/rsmp/proxy/modules/receive.rb

@@ -68,8 +68,10 @@ module RSMP
         def process_packet(json)
           attributes = Message.parse_attributes json
           message = Message.build attributes, json
-          message.validate(schemas) if should_validate_ingoing_message?(message)
+          validate = should_validate_ingoing_message?(message)
+          message.validate(schemas) if validate
           verify_sequence message
+          message.decode_for(schemas) if validate
           with_deferred_distribution do
             distribute message
             process_message message

data/lib/rsmp/proxy/modules/send.rb

@@ -12,21 +12,12 @@ module RSMP
         end
 
         def send_message(message, reason = nil, validate: true, force: false, buffer: true)
-          unless force || connected?
-            error = NotReady.new
-            raise error unless buffer
-
-            return buffer_message(message, error)
+          with_send_ready(message, force: force, buffer: buffer) do
+            write_message(message, validate: validate)
+            expect_acknowledgement message
+            distribute message
+            log_send message, reason
           end
-          raise IOError unless @protocol
-
-          message.direction = :out
-          message.generate_json
-          message.validate schemas unless validate == false
-          @protocol.write_lines message.json
-          expect_acknowledgement message
-          distribute message
-          log_send message, reason
         rescue NotReady, IOError => e
           raise e unless buffer
 
@@ -35,6 +26,25 @@ module RSMP
           handle_send_schema_error(message, e)
         end
 
+        def with_send_ready(message, force:, buffer:)
+          return yield if force || connected?
+
+          error = NotReady.new
+          raise error unless buffer
+
+          buffer_message(message, error)
+        end
+
+        def write_message(message, validate:)
+          raise IOError unless @protocol
+
+          message.direction = :out
+          message.encode_for(schemas) unless validate == false
+          message.generate_json
+          message.validate schemas unless validate == false
+          @protocol.write_lines message.json
+        end
+
         def buffer_message(message, error = nil)
           str = "Cannot send #{message.type} because the connection is closed."
           log str, message: message, level: :error
@@ -67,6 +77,8 @@ module RSMP
         end
 
         def apply_nts_message_attributes(message)
+          return if core_3_3?
+
           message.attributes['ntsOId'] = main && main.ntsoid ? main.ntsoid : ''
           message.attributes['xNId'] = main && main.xnid ? main.xnid : ''
         end

data/lib/rsmp/proxy/proxy.rb

@@ -234,6 +234,23 @@ module RSMP
       sxl_interface resolved.first
     end
 
+    def command_items(message)
+      key = message.is_a?(CommandResponse) ? 'rvs' : 'arg'
+      message.attributes[key] || []
+    end
+
+    def command_codes(message)
+      command_items(message).map { |item| item['cCI'] }.compact.uniq
+    end
+
+    def multiple_command_codes?(message)
+      command_codes(message).size > 1
+    end
+
+    def reject_multiple_command_codes(message)
+      dont_acknowledge message, 'Rejected', 'more than one command code in a single command message'
+    end
+
     # Use Gem class to check version requirement
     # Requirement must be a string like '1.1', '>=1.0.3' or '<2.1.4',
     # or list of strings, like ['<=1.4','<1.5']

data/lib/rsmp/proxy/site/connection.rb

@@ -0,0 +1,79 @@
+module RSMP
+  # Connection management for supervisor-side site proxies.
+  module SiteProxyConnection
+    # handle communication
+    # when we're created, the socket is already open
+    def run
+      if @protocol
+        run_accepted_connection
+      else
+        run_outbound_connection
+      end
+    end
+
+    def run_accepted_connection
+      self.state = :connected
+      start_reader
+      wait_for_reader # run until disconnected
+    rescue RSMP::ConnectionError => e
+      log e, level: :error
+    rescue StandardError => e
+      distribute_error e, level: :internal
+    ensure
+      close
+    end
+
+    def run_outbound_connection
+      loop do
+        setup_site_settings
+        connect
+        start_reader
+        wait_for_reader
+        break unless reconnect_delay?
+      rescue Restart
+        @logger.mute @ip, @port
+        raise
+      rescue RSMP::ConnectionError => e
+        log e, level: :error
+        break unless reconnect_delay?
+      rescue StandardError => e
+        distribute_error e, level: :internal
+        break unless reconnect_delay?
+      ensure
+        close
+        stop_subtasks
+      end
+    end
+
+    def connect
+      log "Connecting to site #{@site_id} at #{@ip}:#{@port}", level: :info
+      self.state = :connecting
+      open_socket
+      self.state = :connected
+      @logger.unmute @ip, @port
+      log "Connected to site #{@site_id} at #{@ip}:#{@port}", level: :info
+    rescue SystemCallError => e
+      raise ConnectionError, "Could not connect to site #{@site_id} at #{@ip}:#{@port}: Errno #{e.errno} #{e}"
+    rescue StandardError => e
+      raise ConnectionError, "Error while connecting to site #{@site_id} at #{@ip}:#{@port}: #{e}"
+    end
+
+    def open_socket
+      endpoint = IO::Endpoint.tcp(@ip, @port)
+      timeout = @site_settings.dig('timeouts', 'connect') || 1.1
+      task.with_timeout(timeout) { @socket = endpoint.connect }
+      @stream = IO::Stream::Buffered.new(@socket)
+      @protocol = RSMP::Protocol.new(@stream)
+    end
+
+    def reconnect_delay?
+      return false if @site_settings['intervals']['reconnect'] == :no
+
+      interval = @site_settings['intervals']['reconnect'] || 0.1
+      log "Will try to reconnect again every #{interval} seconds...", level: :info
+      @logger.mute @ip, @port
+      @task.sleep interval
+      true
+    end
+  end
+end

data/lib/rsmp/proxy/site/modules/commands.rb

@@ -24,17 +24,40 @@ module RSMP
           validate_ready 'send command'
           component ||= main.c_id
           m_id = RSMP::Message.make_m_id
+          collector_list = command_collector_list(command_list)
           message = RSMP::CommandRequest.new({
                                                'cId' => component,
                                                'arg' => command_list,
                                                'mId' => m_id
                                              })
           apply_nts_message_attributes message
-          collector = CommandResponseCollector.new(self, command_list, timeout: within, initiator: message)
+          collector = CommandResponseCollector.new(self, collector_list, timeout: within, initiator: message)
           send_message_and_collect(message, collector, validate: validate)[:collector]
         end
 
+        def command_collector_list(command_list)
+          list = JSON.parse(JSON.generate(command_list))
+          resolved = RSMP::Schema.resolve_sxl({ 'type' => 'CommandRequest', 'arg' => list }, schemas: schemas)
+          return list unless resolved
+
+          type, version = resolved
+          list.each do |item|
+            next unless item.key?('v')
+
+            descriptor = RSMP::Schema.sxl_argument_descriptor(type, version, :commands, item['cCI'], item['n'])
+            next unless descriptor
+
+            encoded = RSMP::Message.encode_sxl_value(item['v'], descriptor)
+            item['v'] = RSMP::Message.decode_sxl_value(encoded, descriptor)
+          end
+          list
+        rescue RSMP::Schema::Error
+          list
+        end
+
         def process_command_response(message)
+          return reject_multiple_command_codes(message) if core_3_3? && multiple_command_codes?(message)
+
           log "Received #{message.type}", message: message, level: :log
           acknowledge message
         end

data/lib/rsmp/proxy/site/site_proxy.rb

@@ -6,6 +6,7 @@ module RSMP
     include Modules::AggregatedStatus
     include Modules::Alarms
     include Modules::Commands
+    include SiteProxyConnection
     include SiteSxlSelection
 
     attr_reader :supervisor, :site_id
@@ -16,27 +17,15 @@ module RSMP
       @supervisor = options[:supervisor]
       @settings = @supervisor.supervisor_settings.clone
       @site_id = options[:site_id]
+      @configured_site_settings = options[:site_settings]
       @status_subscriptions = {}
     end
 
-    # handle communication
-    # when we're created, the socket is already open
-    def run
-      self.state = :connected
-      start_reader
-      wait_for_reader # run until disconnected
-    rescue RSMP::ConnectionError => e
-      log e, level: :error
-    rescue StandardError => e
-      distribute_error e, level: :internal
-    ensure
-      close
-    end
-
     def revive(options)
       super
       @supervisor = options[:supervisor]
       @settings = @supervisor.supervisor_settings.clone
+      @configured_site_settings = options[:site_settings]
     end
 
     def node
@@ -170,6 +159,7 @@ module RSMP
       return extraneous_version message if @version_determined
 
       check_site_ids message
+      check_core_version message
       check_sxl_version message
       version_accepted message
     end
@@ -177,6 +167,7 @@ module RSMP
     def check_site_ids(message)
       # RSMP support multiple site ids. we don't support this yet. instead we use the first id only
       site_id = message.attribute('siteId').map { |item| item['sId'] }.first
+      @site_id ||= site_id
       @supervisor.check_site_id site_id
       site_ids_changed
     end
@@ -202,7 +193,7 @@ module RSMP
     end
 
     def setup_site_settings
-      @site_settings = find_site_settings @site_id
+      @site_settings = @configured_site_settings || find_site_settings(@site_id)
       if @site_settings
         @sxls = configured_sxls
         @accepted_sxls = @sxls.dup

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

@@ -20,11 +20,63 @@ module RSMP
           end
         end
 
+        def command_catalogue_item(command_code)
+          accepted_sxls.each do |sxl|
+            item = command_catalogue_match(sxl, command_code)
+            return item if item
+          end
+          nil
+        end
+
+        def command_catalogue_match(sxl, command_code)
+          version = RSMP::Schema.sanitize_version(sxl['version'].to_s)
+          catalogue = RSMP::Schema.sxl_catalogue(sxl['name'], version, :commands)
+          prefix = RSMP::Schema.sxl_prefix(sxl['name'], version, lenient: true)
+          lookup_catalogue_command(catalogue, command_code, prefix)
+        end
+
+        def lookup_catalogue_command(catalogue, command_code, prefix)
+          unprefixed = prefix && command_code.start_with?(prefix) ? command_code[prefix.length..] : command_code
+          catalogue[command_code] || catalogue[command_code.to_sym] ||
+            catalogue[unprefixed] || catalogue[unprefixed.to_sym]
+        end
+
+        def required_command_argument_names(command_code)
+          item = command_catalogue_item command_code
+          return [] unless item
+
+          RSMP::Schema.argument_names(item['required'])
+        end
+
+        def check_required_command_arguments(message)
+          return unless core_3_3?
+
+          command_codes(message).each do |command_code|
+            provided = message.attributes['arg'].select { |item| item['cCI'] == command_code }.map { |item| item['n'] }
+            missing = required_command_argument_names(command_code) - provided
+            next if missing.empty?
+
+            raise MissingAttribute, "Missing required command argument(s) #{missing.join(', ')} for #{command_code}"
+          end
+        end
+
+        def mark_command_unknown(rvs, command_code)
+          rvs.each do |item|
+            next unless item['cCI'] == command_code
+
+            item['age'] = 'unknown'
+            item['v'] = nil
+          end
+        end
+
         def execute_commands(message, component_id, rvs)
           component = @site.find_component component_id
           commands = simplify_command_requests message.attributes['arg']
           commands.each_pair do |command_code, arg|
             component.handle_command command_code, arg
+          rescue UnknownCommand => e
+            log e.to_s, message: message, level: :warning
+            mark_command_unknown rvs, command_code
           end
           log "Received #{message.type}", message: message, level: :log
         rescue UnknownComponent
@@ -34,6 +86,9 @@ module RSMP
         end
 
         def process_command_request(message)
+          return reject_multiple_command_codes(message) if core_3_3? && multiple_command_codes?(message)
+
+          check_required_command_arguments message
           component_id = message.attributes['cId']
           rvs = build_command_rvs(message.attributes['arg'])
           execute_commands(message, component_id, rvs)

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

@@ -7,10 +7,6 @@ module RSMP
           @site_settings['message_buffer'] || {}
         end
 
-        def message_buffer_enabled?
-          message_buffer_settings['enabled'] != false
-        end
-
         def message_buffer_max_messages
           message_buffer_settings['max_messages'] || 10_000
         end
@@ -79,7 +75,6 @@ module RSMP
         end
 
         def prepare_message_for_buffer(message, core_version: @core_version, for_send: false)
-          return unless message_buffer_enabled?
           return unless site_originated_buffer_candidate? message
           return false if message.is_a?(RSMP::StatusUpdate) && status_buffer_selectors == false
           return false if message.is_a?(RSMP::Alarm) && !receive_alarms?

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

@@ -3,23 +3,30 @@ module RSMP
     module Modules
       # Status request and subscription handling
       module Status
+        include StatusUpdates
+
         def rsmpify_value(value, quality)
-          if value.is_a?(Array) || value.is_a?(Set)
-            value
-          elsif %w[undefined unknown].include?(quality.to_s)
+          if %w[undefined unknown].include?(quality.to_s)
             nil
           else
-            value.to_s
+            value
           end
         end
 
         def fetch_status_values(component, args)
           args.map do |arg|
-            value, quality = component.get_status arg['sCI'], arg['n'], { sxl_version: sxl_version }
-            { 's' => rsmpify_value(value, quality), 'q' => quality.to_s }.merge arg
+            fetch_status_value component, arg
           end
         end
 
+        def fetch_status_value(component, arg)
+          value, quality = component.get_status arg['sCI'], arg['n'], { sxl_version: sxl_version }
+          { 's' => rsmpify_value(value, quality), 'q' => quality.to_s }.merge arg
+        rescue UnknownStatus => e
+          log e.to_s, level: :warning
+          { 's' => nil, 'q' => 'unknown' }.merge arg
+        end
+
         def build_undefined_statuses(args)
           args.map { |arg| arg.dup.merge('q' => 'undefined', 's' => nil) }
         end
@@ -115,104 +122,6 @@ module RSMP
             @status_subscriptions.delete(component_id) if by_code.empty?
           end
         end
-
-        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 do |item|
-            sci = item['sCI']
-            n = item['n']
-            s = item['s']
-            @last_status_sent[component_id][sci] ||= {}
-            @last_status_sent[component_id][sci][n] = s
-          end
-        end
-
-        def check_on_change_update(subscription, component, code, name)
-          return [nil, false] unless subscription[:interval].zero?
-
-          current = nil
-          if component
-            current, quality = *(component.get_status code, name)
-            current = rsmpify_value(current, quality)
-          end
-          last_sent = fetch_last_sent_status component.c_id, code, name
-          [current, current != last_sent]
-        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)
-          update_list = {}
-
-          @status_subscriptions.each_pair do |component_id, by_code|
-            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
-
-                update_list[component_id] ||= {}
-                update_list[component_id][code] ||= {}
-                update_list[component_id][code][name] = current
-              end
-            end
-          end
-          send_status_updates update_list
-        end
-
-        def build_status_list(component, by_code)
-          ss = []
-          by_code.each_pair do |code, names|
-            names.map do |status_name, value|
-              if value
-                quality = 'recent'
-              else
-                value, quality = component.get_status code, status_name
-              end
-              ss << { 'sCI' => code,
-                      'n' => status_name,
-                      's' => rsmpify_value(value, quality),
-                      'q' => quality }
-            end
-          end
-          ss
-        end
-
-        def send_status_updates(update_list)
-          now = clock.to_s
-          update_list.each_pair do |component_id, by_code|
-            component = @site.find_component component_id
-            ss = build_status_list(component, by_code)
-            update = StatusUpdate.new({
-                                        'cId' => component_id,
-                                        'sTs' => now,
-                                        'sS' => ss
-                                      })
-            apply_nts_message_attributes update
-            send_message update
-            store_last_sent_status update
-            component.status_updates_sent
-          end
-        end
       end
     end
   end