rsmp 0.43.2 → 0.45.0

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

@@ -0,0 +1,54 @@
+module RSMP
+  # Selects the SXL versions accepted by a supervisor-side site proxy.
+  module SiteSxlSelection
+    def check_sxl_version(message)
+      if core_3_3?
+        select_sxls message
+      else
+        select_legacy_sxl message
+      end
+    rescue RSMP::Schema::UnknownSchemaError => e
+      dont_acknowledge message, "Rejected #{message.type} message,", e.to_s
+    end
+
+    def select_legacy_sxl(message)
+      primary = configured_sxls.first
+      unless primary
+        reason = 'Legacy Version message received, but no SXL is configured'
+        dont_acknowledge message, "Rejected #{message.type} message,", reason
+        raise HandshakeError, reason
+      end
+
+      sanitized_version = RSMP::Schema.sanitize_version(message.attribute('SXL'))
+      RSMP::Schema.find_schema! primary['name'], sanitized_version
+      @accepted_sxls = [{ 'name' => primary['name'], 'version' => message.attribute('SXL') }]
+      @rejected_sxls = []
+    end
+
+    def select_sxls(message)
+      selected_sxls = message.sxls.map { |requested| select_sxl(requested) }
+      @accepted_sxls, @rejected_sxls = selected_sxls.partition { |item| item['rejected'].nil? }
+    end
+
+    def select_sxl(requested)
+      configured = configured_sxls.find { |item| item['name'] == requested['name'] }
+      return rejected_sxl(requested, 1, 'SXL not supported') unless configured
+
+      if configured['version'].to_s == requested['version'].to_s
+        RSMP::Schema.find_schema! requested['name'], requested['version'], lenient: true
+        requested.slice('name', 'version', 'prefix')
+      else
+        rejected_sxl(requested, 2, "Supervisor only supports #{configured['version']}")
+      end
+    end
+
+    def rejected_sxl(requested, code, reason)
+      {
+        'name' => requested['name'],
+        'version' => requested['version'],
+        'rejected' => code,
+        'reason' => reason
+      }.compact
+    end
+  end
+end

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

@@ -17,7 +17,9 @@ module RSMP
       @ip = options[:ip]
       @port = options[:port]
       @status_subscriptions = {}
-      @sxl = @site_settings['sxl']
+      @sxls = configured_sxls
+      @accepted_sxls = @sxls.dup
+      @rejected_sxls = []
       @synthetic_id = Supervisor.build_id_from_ip_port @ip, @port
     end
 
@@ -46,7 +48,7 @@ module RSMP
     end
 
     def start_handshake
-      send_version @site_settings['site_id'], core_versions
+      send_version_request @site_settings['site_id'], core_versions
     end
 
     # connect to the supervisor and initiate handshake supervisor
@@ -87,14 +89,14 @@ module RSMP
     end
 
     def handshake_complete
-      sanitized_sxl_version = RSMP::Schema.sanitize_version(sxl_version)
-      log "Connection to supervisor established, using core #{@core_version}, #{sxl} #{sanitized_sxl_version}",
+      sxl_summary = accepted_sxls.map { |item| "#{item['name']} #{item['version']}" }.join(', ')
+      log "Connection to supervisor established, using core #{@core_version}, SXLs [#{sxl_summary}]",
           level: :info
       self.state = :ready
       start_watchdog
       if @site_settings['send_after_connect']
         send_all_aggregated_status
-        send_active_alarms
+        send_active_alarms if receive_alarms?
       end
       super
     end
@@ -105,10 +107,29 @@ module RSMP
         will_not_handle message
       when AggregatedStatusRequest
         process_aggregated_status_request message
-      when CommandRequest
-        process_command_request message
       when CommandResponse
         process_command_response message
+      when CommandRequest, StatusRequest, StatusSubscribe, StatusUnsubscribe,
+           Alarm, AlarmAcknowledged, AlarmSuspend, AlarmResume, AlarmRequest
+        handle_interface_request message
+      else
+        super
+      end
+    rescue UnknownComponent, UnknownCommand, UnknownStatus,
+           MessageRejected, MissingAttribute => e
+      dont_acknowledge message, '', e.to_s
+    end
+
+    def handle_interface_request(message)
+      interface = sxl_interface_for message
+      interface.validate_message! message
+      interface.process_message message
+    end
+
+    def process_sxl_request(message)
+      case message
+      when CommandRequest
+        process_command_request message
       when StatusRequest
         process_status_request message
       when StatusSubscribe
@@ -117,18 +138,17 @@ module RSMP
         process_status_unsubcribe message
       when Alarm, AlarmAcknowledged, AlarmSuspend, AlarmResume, AlarmRequest
         process_alarm message
-      else
-        super
       end
-    rescue UnknownComponent, UnknownCommand, UnknownStatus,
-           MessageRejected, MissingAttribute => e
-      dont_acknowledge message, '', e.to_s
     end
 
     def acknowledged_first_ingoing(message)
       case message.type
       when 'Watchdog'
-        handshake_complete
+        if core_3_3?
+          send_component_list
+        else
+          handshake_complete
+        end
       end
     end
 
@@ -155,10 +175,6 @@ module RSMP
       status_update_timer now if ready?
     end
 
-    def sxl_version
-      @site_settings['sxl_version'].to_s
-    end
-
     def process_version(message)
       return extraneous_version message if @version_determined
 
@@ -168,7 +184,27 @@ module RSMP
       version_accepted message
     end
 
-    def check_sxl_version(message); end
+    def check_sxl_version(message)
+      if core_3_3?
+        @rejected_sxls, @accepted_sxls = message.sxls.partition { |item| item['rejected'] }
+        @receive_alarms = message.attributes.fetch('receiveAlarms', true)
+      else
+        primary = primary_configured_sxl
+        raise HandshakeError, 'Legacy Version response received, but no SXL is configured' unless primary
+
+        @accepted_sxls = [primary]
+        @rejected_sxls = []
+      end
+      build_sxl_interfaces
+    end
+
+    def send_component_list
+      send_message ComponentList.new('components' => @site.component_list)
+    end
+
+    def component_list_acknowledged
+      handshake_complete
+    end
 
     def main
       @site.main

data/lib/rsmp/schema/message_resolution.rb

@@ -0,0 +1,104 @@
+module RSMP
+  # Resolves SXL schemas from message code ownership.
+  module Schema
+    MESSAGE_CODE_EXTRACTORS = {
+      'StatusRequest' => ->(message) { status_codes(message) },
+      'StatusSubscribe' => ->(message) { status_codes(message) },
+      'StatusUnsubscribe' => ->(message) { status_codes(message) },
+      'StatusResponse' => ->(message) { status_codes(message) },
+      'StatusUpdate' => ->(message) { status_codes(message) },
+      'CommandRequest' => ->(message) { request_command_codes(message) },
+      'CommandResponse' => ->(message) { response_command_codes(message) },
+      'Alarm' => ->(message) { alarm_codes(message) }
+    }.freeze
+
+    MESSAGE_CODE_KINDS = {
+      'StatusRequest' => :statuses,
+      'StatusSubscribe' => :statuses,
+      'StatusUnsubscribe' => :statuses,
+      'StatusResponse' => :statuses,
+      'StatusUpdate' => :statuses,
+      'CommandRequest' => :commands,
+      'CommandResponse' => :commands,
+      'Alarm' => :alarms
+    }.freeze
+
+    def self.message_codes(message)
+      extractor = MESSAGE_CODE_EXTRACTORS[message['type']]
+      extractor ? extractor.call(message).uniq : []
+    end
+
+    def self.status_codes(message)
+      (message['sS'] || []).map { |item| item['sCI'] }.compact
+    end
+
+    def self.request_command_codes(message)
+      (message['arg'] || []).map { |item| item['cCI'] }.compact
+    end
+
+    def self.response_command_codes(message)
+      (message['rvs'] || []).map { |item| item['cCI'] }.compact
+    end
+
+    def self.alarm_codes(message)
+      [message['aCId']].compact
+    end
+
+    def self.message_code_kind(message)
+      MESSAGE_CODE_KINDS[message['type']]
+    end
+
+    def self.sxl_defines_codes?(type, version, kind, codes, options)
+      version = sanitize_version(version.to_s) if options[:lenient]
+      catalogue = sxl_catalogue(type, version, kind)
+      prefix = sxl_prefix(type, version, options)
+      codes.all? do |code|
+        unprefixed = prefix && code.start_with?(prefix) ? code[prefix.length..] : code
+        catalogue.key?(code) || catalogue.key?(code.to_sym) ||
+          catalogue.key?(unprefixed) || catalogue.key?(unprefixed.to_sym)
+      end
+    end
+
+    def self.message_code_kind_name(kind)
+      {
+        statuses: 'status',
+        commands: 'command',
+        alarms: 'alarm'
+      }.fetch(kind) { kind.to_s.delete_suffix('s') }
+    end
+
+    def self.resolve_sxl(message, schemas:, **options)
+      kind = message_code_kind(message)
+      codes = message_codes(message)
+      return nil unless kind && codes.any?
+
+      matches = matching_sxl_schemas(schemas, kind, codes, options)
+      raise_if_no_sxl_match(kind, codes) if matches.empty?
+      raise_if_ambiguous_sxl_match(codes, matches) if matches.size > 1
+
+      matches.first
+    end
+
+    def self.matching_sxl_schemas(schemas, kind, codes, options)
+      sxl_schemas(schemas).select do |type, version|
+        sxl_defines_codes?(type, version, kind, codes, options)
+      rescue UnknownSchemaError
+        false
+      end
+    end
+
+    def self.sxl_schemas(schemas)
+      schemas.reject { |type, _version| type.to_sym == :core }
+    end
+
+    def self.raise_if_no_sxl_match(kind, codes)
+      raise UnknownMessageCodeError,
+            "No accepted SXL defines #{message_code_kind_name(kind)} code(s) #{codes.join(', ')}"
+    end
+
+    def self.raise_if_ambiguous_sxl_match(codes, matches)
+      names = matches.map { |type, version| "#{type} #{version}" }.join(', ')
+      raise AmbiguousMessageCodeError, "Message code(s) #{codes.join(', ')} match multiple accepted SXLs: #{names}"
+    end
+  end
+end

data/lib/rsmp/schema.rb

@@ -1,4 +1,6 @@
 require 'json_schemer'
+require 'json'
+require 'yaml'
 
 # RSMP (Road Side Message Protocol) schema validation library.
 module RSMP
@@ -8,6 +10,7 @@ module RSMP
 
     def self.setup
       @schemas = {}
+      @schema_paths = {}
       schemas_path = File.expand_path(File.join(__dir__, '..', '..', 'schemas'))
       Dir.glob("#{schemas_path}/*").select { |f| File.directory? f }.each do |type_path|
         type = File.basename(type_path).to_sym
@@ -26,23 +29,37 @@ module RSMP
     #
     #  an error is raised if the schema type already exists, and force is not set to true
     def self.load_schema_type(type, type_path, force: false)
-      raise "Schema type #{type} already loaded" if @schemas[type] && force != true
+      type = type.to_sym
+      ensure_schema_type_available(type, force)
 
       @schemas[type] = {}
-      Dir.glob("#{type_path}/*").select { |f| File.directory? f }.each do |schema_path|
-        version = File.basename(schema_path)
-        file_path = File.join(schema_path, 'rsmp.json')
-        next unless File.exist? file_path
-
-        @schemas[type][version] = JSONSchemer.schema(
-          Pathname.new(File.join(schema_path, 'rsmp.json'))
-        )
-      end
+      @schema_paths ||= {}
+      @schema_paths[type] = {}
+      schema_version_paths(type_path).each { |schema_path| load_schema_version(type, schema_path) }
+    end
+
+    def self.ensure_schema_type_available(type, force)
+      raise "Schema type #{type} already loaded" if @schemas[type] && force != true
+    end
+
+    def self.schema_version_paths(type_path)
+      Dir.glob("#{type_path}/*").select { |path| File.directory? path }
+    end
+
+    def self.load_schema_version(type, schema_path)
+      version = File.basename(schema_path)
+      file_path = File.join(schema_path, 'rsmp.json')
+      return unless File.exist? file_path
+
+      @schemas[type][version] = JSONSchemer.schema(Pathname.new(file_path))
+      @schema_paths[type][version] = schema_path
     end
 
     # remove a schema type
     def self.remove_schema_type(type)
+      type = type.to_sym
       schemas.delete type
+      @schema_paths&.delete type
     end
 
     # get schemas types
@@ -174,37 +191,102 @@ module RSMP
       find_schema(type, version, options) != nil
     end
 
+    def self.sxl_metadata(type, version, options = {})
+      version = sanitize_version version if options[:lenient]
+      find_schema! type, version
+
+      path = @schema_paths&.dig(type.to_sym, version)
+      return {} unless path
+
+      yaml_path = File.join(path, 'sxl.yaml')
+      return YAML.load_file(yaml_path).fetch('meta', {}) if File.exist?(yaml_path)
+
+      json_path = File.join(path, 'rsmp.json')
+      File.exist?(json_path) ? JSON.parse(File.read(json_path)) : {}
+    end
+
+    def self.sxl_prefix(type, version, options = {})
+      sxl_metadata(type, version, options)['prefix']
+    end
+
     # return a catalogue of statuses for a particular schema type and version
     # returns a hash of { status_code_id_sym => [arg_name_sym, ...] }
     # raises an error if the schema type/version is not found, or has no sxl.yaml
     def self.status_catalogue(type, version)
+      sxl_catalogue(type, version, :statuses).transform_keys(&:to_sym).transform_values do |status|
+        (status['arguments'] || {}).keys.map(&:to_sym)
+      end
+    end
+
+    def self.sxl_catalogue(type, version, kind)
       find_schema! type, version
-      schemas_path = File.expand_path(File.join(__dir__, '..', '..', 'schemas'))
-      yaml_path = File.join(schemas_path, type.to_s, version, 'sxl.yaml')
-      raise "No sxl.yaml for #{type} #{version}" unless File.exist?(yaml_path)
+      schema_path = @schema_paths&.dig(type.to_sym, version)
+      yaml_path = File.join(schema_path, 'sxl.yaml') if schema_path
+      raise "No sxl.yaml for #{type} #{version}" unless yaml_path && File.exist?(yaml_path)
 
       sxl = RSMP::Convert::Import::YAML.read(yaml_path)
-      sxl[:statuses].transform_keys(&:to_sym).transform_values do |status|
-        (status['arguments'] || {}).keys.map(&:to_sym)
+      sxl.fetch(kind)
+    end
+
+    def self.core_message_type?(message)
+      type = message['type']
+      %w[
+        MessageAck
+        MessageNotAck
+        Version
+        ComponentList
+        AggregatedStatus
+        AggregatedStatusRequest
+        Watchdog
+      ].include?(type)
+    end
+
+    def self.validate_core(message, schemas, options)
+      core_version = schemas[:core] || schemas['core']
+      raise ArgumentError, 'schemas must include core' unless core_version
+
+      schema = find_schema! :core, core_version, options
+      validate_using_schema(message, schema)
+    end
+
+    def self.validate_sxls(message, schemas, options)
+      sxl_schemas = schemas.reject { |type, _version| type.to_sym == :core }
+      return [] if sxl_schemas.empty? || core_message_type?(message)
+
+      resolved = resolve_sxl(message, schemas: schemas, **options)
+      if resolved
+        type, version = resolved
+        schema = find_schema! type, version, options
+        return validate_using_schema(message, schema)
+      end
+
+      all_errors = []
+      sxl_schemas.each do |type, version|
+        schema = find_schema! type, version, options
+        errors = validate_using_schema(message, schema)
+        return [] if errors.empty?
+
+        all_errors.concat errors
       end
+      all_errors
     end
 
-    # validate using a particular schema and version
-    # raises error if schema is not found
-    # return nil if validation succeds, otherwise returns an array of errors
+    # validate using core and optional SXL schemas.
+    # Core must pass. SXL-defined messages pass if at least one SXL schema passes.
+    # returns nil if validation succeeds, otherwise returns an array of errors.
     def self.validate(message, schemas, options = {})
       raise ArgumentError, 'message missing' unless message
       raise ArgumentError, 'schemas missing' unless schemas
       raise ArgumentError, 'schemas must be a Hash' unless schemas.is_a?(Hash)
       raise ArgumentError, 'schemas cannot be empty' unless schemas.any?
 
-      errors = schemas.flat_map do |type, version|
-        schema = find_schema! type, version, options
-        validate_using_schema(message, schema)
-      end
+      errors = validate_core(message, schemas, options)
+      errors.concat validate_sxls(message, schemas, options) if errors.empty?
       return nil if errors.empty?
 
       errors
     end
   end
 end
+
+require_relative 'schema/message_resolution'

data/lib/rsmp/schema_error.rb

@@ -1,6 +1,6 @@
 module RSMP
   module Schema
-    # Base error class for rsmp_schema.
+    # Base error class for schema validation.
     class Error < StandardError
     end
 
@@ -15,5 +15,11 @@ module RSMP
     # Raised when the requested schema version does not exist.
     class UnknownSchemaVersionError < UnknownSchemaError
     end
+
+    class UnknownMessageCodeError < Error
+    end
+
+    class AmbiguousMessageCodeError < Error
+    end
   end
 end

data/lib/rsmp/sxl/interface.rb

@@ -0,0 +1,48 @@
+require 'forwardable'
+
+module RSMP
+  module SXL
+    # Base interface for SXL-specific behavior on a proxy connection.
+    class Interface
+      extend Forwardable
+
+      def_delegators :proxy, :send_message, :send_message_and_collect, :validate_ready, :log
+
+      attr_reader :proxy, :name, :version
+
+      def initialize(proxy:, name:, version:)
+        @proxy = proxy
+        @name = name
+        @version = version
+      end
+
+      def node
+        proxy.node
+      end
+
+      def components
+        proxy.respond_to?(:components) ? proxy.components : proxy.site.components
+      end
+
+      def main
+        proxy.respond_to?(:main) ? proxy.main : proxy.site.main
+      end
+
+      def sxl_version
+        version
+      end
+
+      def core_version
+        proxy.core_version
+      end
+
+      def use_soc?
+        return false unless core_version
+
+        RSMP::Proxy.version_meets_requirement?(core_version, '>=3.1.5')
+      end
+
+      def validate_message!(_message); end
+    end
+  end
+end

data/lib/rsmp/sxl/registry.rb

@@ -0,0 +1,55 @@
+module RSMP
+  module SXL
+    # Registry of SXL interface classes keyed by SXL name and connection side.
+    module Registry
+      @interfaces = {}
+
+      def self.register(name, side, klass)
+        @interfaces[[name.to_s, side.to_sym]] = klass
+      end
+
+      def self.register_interface(klass)
+        register sxl_name_for(klass), side_for(klass), klass
+      end
+
+      def self.fetch(name, side)
+        @interfaces[[name.to_s, side.to_sym]]
+      end
+
+      def self.build(proxy, sxl, side)
+        klass = fetch(sxl['name'], side) || default_class(side)
+        klass.new(proxy: proxy, name: sxl['name'], version: sxl['version'])
+      end
+
+      def self.build_for(proxy, sxl)
+        case proxy
+        when RSMP::SiteProxy
+          build(proxy, sxl, :supervisor)
+        when RSMP::SupervisorProxy
+          build(proxy, sxl, :site)
+        else
+          raise ArgumentError, "Unknown proxy class #{proxy.class}"
+        end
+      end
+
+      def self.default_class(side)
+        side.to_sym == :site ? SiteInterface : SupervisorInterface
+      end
+
+      def self.side_for(klass)
+        return :site if klass < SiteInterface
+        return :supervisor if klass < SupervisorInterface
+
+        raise ArgumentError, "Cannot infer SXL interface side for #{klass}"
+      end
+
+      def self.sxl_name_for(klass)
+        namespace = klass.name.split('::')[0...-1].join('::')
+        owner = Object.const_get(namespace)
+        return owner.sxl_name if owner.respond_to?(:sxl_name)
+
+        raise ArgumentError, "Cannot infer SXL name for #{klass}"
+      end
+    end
+  end
+end

data/lib/rsmp/sxl/site_interface.rb

@@ -0,0 +1,10 @@
+module RSMP
+  module SXL
+    # SXL interface used by a site-side proxy.
+    class SiteInterface < Interface
+      def process_message(message)
+        proxy.process_sxl_request message
+      end
+    end
+  end
+end

data/lib/rsmp/sxl/supervisor_interface.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+
+module RSMP
+  module SXL
+    # SXL interface used by a supervisor-side proxy.
+    class SupervisorInterface < Interface
+      extend Forwardable
+
+      def_delegators :proxy,
+                     :request_status,
+                     :request_status_and_collect,
+                     :subscribe_to_status,
+                     :subscribe_to_status_and_collect,
+                     :unsubscribe_to_status,
+                     :send_command,
+                     :send_command_and_collect
+
+      def process_message(_message); end
+    end
+  end
+end

data/lib/rsmp/tlc/detector_logic.rb

@@ -4,8 +4,8 @@ module RSMP
     class DetectorLogic < Component
       attr_reader :forced, :value
 
-      def initialize(node:, id:)
-        super(node: node, id: id, grouped: false)
+      def initialize(node:, id:, type: nil, name: nil)
+        super(node: node, id: id, type: type, name: name, grouped: false)
         @forced = 0
         @value = 0
       end

data/lib/rsmp/tlc/signal_group.rb

@@ -5,8 +5,8 @@ module RSMP
       attr_reader :plan, :state
 
       # plan is a string, with each character representing a signal phase at a particular second in the cycle
-      def initialize(node:, id:)
-        super(node: node, id: id, grouped: false)
+      def initialize(node:, id:, type: nil, name: nil)
+        super(node: node, id: id, type: type, name: name, grouped: false)
       end
 
       def timer

data/lib/rsmp/tlc/site_interface.rb

@@ -0,0 +1,10 @@
+module RSMP
+  # Traffic Light Controller SXL support.
+  module TLC
+    # Site-side TLC SXL interface.
+    class SiteInterface < RSMP::SXL::SiteInterface
+    end
+
+    RSMP::SXL::Registry.register_interface SiteInterface
+  end
+end