rsmp 0.43.2 → 0.45.1

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

@@ -15,6 +15,27 @@ module RSMP
           end
         end
 
+        def core_3_3?
+          core_version && version_meets_requirement?(core_version, '>=3.3.0')
+        end
+
+        def configured_sxls
+          (@site_settings['sxls'] || []).map { |item| item.transform_keys(&:to_s) }
+        end
+
+        def primary_configured_sxl
+          configured_sxls.first
+        end
+
+        def sxl_request_items
+          configured_sxls.map do |sxl|
+            item = { 'name' => sxl['name'], 'version' => sxl['version'].to_s }
+            prefix = RSMP::Schema.sxl_prefix(sxl['name'], sxl['version'], lenient: true)
+            item['prefix'] = prefix if prefix
+            item
+          end
+        end
+
         def check_core_version(message)
           versions = core_versions
           # find versions that both we and the client support
@@ -36,33 +57,87 @@ module RSMP
         end
 
         def send_version(site_id, core_versions)
-          versions = if core_versions == 'latest'
-                       [RSMP::Schema.latest_core_version]
-                     elsif core_versions == 'all'
-                       RSMP::Schema.core_versions
-                     else
-                       [core_versions].flatten
-                     end
-          versions_array = versions.map { |v| { 'vers' => v } }
+          send_version_message(site_id, core_versions, step: nil)
+        end
+
+        def send_version_request(site_id, core_versions)
+          send_version_message(site_id, core_versions, step: 'Request')
+        end
+
+        def send_version_response(site_id, core_versions)
+          if core_3_3?
+            send_message Version.new({
+                                       'step' => 'Response',
+                                       'RSMP' => [{ 'vers' => core_version }],
+                                       'supervisorId' => site_id,
+                                       'SXLS' => version_response_sxls,
+                                       'receiveAlarms' => @site_settings['receive_alarms'] != false
+                                     }), validate: false
+          else
+            send_version_message(site_id, core_versions, step: nil)
+          end
+        end
+
+        def send_version_message(site_id, core_versions, step:)
+          attributes = version_message_attributes(site_id, core_versions)
+          attributes.merge!(version_request_attributes) if step == 'Request'
+          send_message Version.new(attributes), validate: false
+        end
 
-          site_id_array = [site_id].flatten.map { |id| { 'sId' => id } }
+        def version_message_attributes(site_id, core_versions)
+          primary = primary_configured_sxl
+          attributes = {
+            'RSMP' => version_items(core_versions),
+            'siteId' => site_id_items(site_id)
+          }
+          attributes['SXL'] = primary['version'].to_s if primary
+          attributes
+        end
 
-          version_response = Version.new({
-                                           'RSMP' => versions_array,
-                                           'siteId' => site_id_array,
-                                           'SXL' => sxl_version.to_s
-                                         })
-          send_message version_response
+        def version_items(core_versions)
+          normalized_core_versions(core_versions).map { |version| { 'vers' => version } }
+        end
+
+        def normalized_core_versions(core_versions)
+          case core_versions
+          when 'latest'
+            [RSMP::Schema.latest_core_version]
+          when 'all'
+            RSMP::Schema.core_versions
+          else
+            [core_versions].flatten
+          end
+        end
+
+        def site_id_items(site_id)
+          [site_id].flatten.map { |id| { 'sId' => id } }
+        end
+
+        def version_request_attributes
+          {
+            'step' => 'Request',
+            'SXLS' => sxl_request_items
+          }
+        end
+
+        def version_response_sxls
+          accepted_sxls + rejected_sxls
         end
 
         def version_acknowledged; end
 
+        def component_list_acknowledged; 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']
         def self.version_meets_requirement?(version, requirement)
           Gem::Requirement.new(requirement).satisfied_by?(Gem::Version.new(version))
         end
+
+        def version_meets_requirement?(version, requirement)
+          RSMP::Proxy::Modules::Versions.version_meets_requirement?(version, requirement)
+        end
       end
     end
   end

data/lib/rsmp/proxy/proxy.rb

@@ -17,7 +17,9 @@ module RSMP
     include Modules::Versions
     include Modules::Tasks
 
-    attr_reader :state, :archive, :connection_info, :sxl, :collector, :ip, :port, :node, :core_version
+    attr_reader :state, :archive, :connection_info, :sxls, :accepted_sxls, :rejected_sxls,
+                :collector, :ip, :port, :node, :core_version, :sxl_interfaces,
+                :site_settings
 
     def initialize(options)
       @node = options[:node]
@@ -136,6 +138,9 @@ module RSMP
       @ingoing_acknowledged = {}
       @outgoing_acknowledged = {}
       @latest_watchdog_send_at = nil
+      @component_list_received = false
+      @outgoing_watchdog_acknowledged = false
+      @sxl_interfaces = {}
 
       @acknowledgements = {}
       @acknowledgement_condition = Async::Notification.new
@@ -154,7 +159,10 @@ module RSMP
       @ip = options[:ip]
       @port = options[:port]
       @connection_info = options[:info]
-      @sxl = nil
+      @sxls = []
+      @accepted_sxls = []
+      @rejected_sxls = []
+      @receive_alarms = true
       @site_settings = nil # can't pick until we know the site id
       return unless options[:collect]
 
@@ -177,14 +185,55 @@ module RSMP
     def schemas
       schemas = { core: RSMP::Schema.latest_core_version } # use latest core
       schemas[:core] = core_version if core_version
-      schemas[sxl] = RSMP::Schema.sanitize_version(sxl_version.to_s) if sxl && sxl_version
+      accepted_sxls.each do |sxl|
+        schemas[sxl['name'].to_sym] = RSMP::Schema.sanitize_version(sxl['version'].to_s)
+      end
       schemas
     end
 
+    def receive_alarms?
+      @receive_alarms != false
+    end
+
+    def primary_sxl
+      accepted_sxls.first || sxls.first
+    end
+
+    def sxl
+      primary_sxl && primary_sxl['name']
+    end
+
+    def sxl_version
+      primary_sxl && primary_sxl['version']
+    end
+
     def author
       @node.site_id
     end
 
+    def build_sxl_interfaces
+      @sxl_interfaces = accepted_sxls.to_h do |sxl|
+        [sxl['name'], RSMP::SXL::Registry.build_for(self, sxl)]
+      end
+    end
+
+    def sxl_interface(name)
+      sxl_interfaces.fetch(name.to_s) do
+        raise RSMP::Schema::UnknownSchemaTypeError, "SXL #{name} is not accepted on this connection"
+      end
+    end
+
+    def tlc
+      sxl_interface 'tlc'
+    end
+
+    def sxl_interface_for(message)
+      resolved = RSMP::Schema.resolve_sxl(message.attributes, schemas: schemas)
+      return unless resolved
+
+      sxl_interface resolved.first
+    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/modules/status.rb

@@ -125,14 +125,13 @@ module RSMP
         end
 
         def unsubscribe_to_status(status_list, component: nil, validate: nil)
+          validate_ready 'unsubscribe to status'
           component ||= main.c_id
 
           status_list.each do |item|
             remove_subscription_item(component, item['sCI'], item['n'])
           end
 
-          return unless ready? # if the connection is don't we skip sending
-
           message = RSMP::StatusUnsubscribe.new({
                                                   'cId' => component,
                                                   'sS' => status_list
@@ -145,7 +144,10 @@ module RSMP
         # unsubscribes to all statuses (with all attributes) defined in the used SXL
         def unsubscribe_from_all(component: nil)
           component ||= main.c_id
-          catalogue = RSMP::Schema.status_catalogue(@sxl, RSMP::Schema.sanitize_version(sxl_version))
+          catalogue = accepted_sxls.each_with_object({}) do |sxl, memo|
+            version = RSMP::Schema.sanitize_version(sxl['version'].to_s)
+            memo.merge! RSMP::Schema.status_catalogue(sxl['name'], version)
+          end
           status_list = catalogue.flat_map do |status_code_id, names|
             names.map { |name| { 'sCI' => status_code_id.to_s, 'n' => name.to_s } }
           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 SiteSxlSelection
 
     attr_reader :supervisor, :site_id
 
@@ -44,7 +45,8 @@ module RSMP
 
     def handshake_complete
       super
-      log "Connection to site #{@site_id} established, using core #{@core_version}, #{@sxl} #{@site_sxl_version}",
+      sxl_summary = accepted_sxls.map { |item| "#{item['name']} #{item['version']}" }.join(', ')
+      log "Connection to site #{@site_id} established, using core #{@core_version}, SXLs [#{sxl_summary}]",
           level: :info
       start_watchdog
     end
@@ -55,16 +57,13 @@ module RSMP
       case message
       when StatusUnsubscribe, AggregatedStatusRequest
         will_not_handle message
+      when ComponentList
+        process_component_list message
       when AggregatedStatus
         process_aggregated_status message
-      when AlarmIssue, AlarmSuspended, AlarmResumed, AlarmAcknowledged
-        process_alarm message
-      when CommandResponse
-        process_command_response message
-      when StatusResponse
-        process_status_response message
-      when StatusUpdate
-        process_status_update message
+      when AlarmIssue, AlarmSuspended, AlarmResumed, AlarmAcknowledged,
+           CommandResponse, StatusResponse, StatusUpdate
+        handle_interface_message message
       else
         super
       end
@@ -78,11 +77,32 @@ module RSMP
       message.is_a?(CommandRequest) || message.is_a?(StatusRequest) || message.is_a?(StatusSubscribe)
     end
 
+    def handle_interface_message(message)
+      interface = sxl_interface_for message
+      interface.validate_message! message
+      record_interface_message message
+      interface.process_message message
+    end
+
+    def record_interface_message(message)
+      case message
+      when AlarmIssue, AlarmSuspended, AlarmResumed, AlarmAcknowledged
+        process_alarm message
+      when CommandResponse
+        process_command_response message
+      when StatusResponse
+        process_status_response message
+      when StatusUpdate
+        process_status_update message
+      end
+    end
+
     def version_accepted(message)
       log "Received Version message for site #{@site_id}", message: message, level: :log
       start_timer
       acknowledge message
-      send_version @site_id, core_versions
+      response_id = core_3_3? ? (@supervisor.site_id || @site_id) : @site_id
+      send_version_response response_id, core_versions
       @version_determined = true
     end
 
@@ -96,7 +116,12 @@ module RSMP
     def acknowledged_first_outgoing(message)
       case message.type
       when 'Watchdog'
-        handshake_complete
+        if core_3_3?
+          @outgoing_watchdog_acknowledged = true
+          handshake_complete if @component_list_received
+        else
+          handshake_complete
+        end
       end
     end
 
@@ -106,6 +131,33 @@ module RSMP
 
     def version_acknowledged; end
 
+    def process_component_list(message)
+      log "Received #{message.type}", message: message, level: :log
+      rebuild_components_from_list message.attributes['components']
+      build_sxl_interfaces
+      acknowledge message
+      @component_list_received = true
+      handshake_complete if @outgoing_watchdog_acknowledged
+    end
+
+    def rebuild_components_from_list(items)
+      main_id = @site_settings.dig('components', 'main')&.keys&.first
+      @components = {}
+      @main = nil
+      items.each do |item|
+        grouped = item['id'] == main_id
+        component = ComponentProxy.new(
+          id: item['id'],
+          node: self,
+          type: item['type'],
+          name: item['name'],
+          grouped: grouped
+        )
+        @components[component.c_id] = component
+        @main = component if grouped
+      end
+    end
+
     def site_ids_changed
       @supervisor.site_ids_changed
     end
@@ -114,27 +166,6 @@ module RSMP
       @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 = @site_settings['sxl']
-      sanitized_version = RSMP::Schema.sanitize_version(message.attribute('SXL'))
-      RSMP::Schema.find_schema! type, sanitized_version
-
-      # store raw sxl version from site (may be 2-part like "1.2"), so we echo it back unchanged
-      # TODO should check agaist site settings
-      @site_sxl_version = message.attribute('SXL')
-    rescue RSMP::Schema::UnknownSchemaError => e
-      dont_acknowledge message, "Rejected #{message.type} message,", e.to_s
-    end
-
-    def sxl_version
-      # a supervisor does not maintain it's own sxl version
-      # instead we use what the site requests
-      @site_sxl_version
-    end
-
     def process_version(message)
       return extraneous_version message if @version_determined
 
@@ -173,7 +204,9 @@ module RSMP
     def setup_site_settings
       @site_settings = find_site_settings @site_id
       if @site_settings
-        @sxl = @site_settings['sxl']
+        @sxls = configured_sxls
+        @accepted_sxls = @sxls.dup
+        build_sxl_interfaces
         setup_components @site_settings['components']
       else
         dont_acknowledge message, 'Rejected', "No config found for site #{@site_id}"
@@ -188,10 +221,10 @@ module RSMP
     def build_component(id:, type:, settings: {})
       settings ||= {}
       if type == 'main'
-        ComponentProxy.new id: id, node: self, grouped: true,
+        ComponentProxy.new id: id, node: self, type: type, name: settings['name'], grouped: true,
                            ntsoid: settings['ntsOId'], xnid: settings['xNId']
       else
-        ComponentProxy.new id: id, node: self, grouped: false
+        ComponentProxy.new id: id, node: self, type: type, name: settings['name'], grouped: false
       end
     end
 

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/core_sxl_resolution.rb

@@ -0,0 +1,69 @@
+module RSMP
+  # Provides JSON Schema validation for RSMP messages across core and SXL versions.
+  module Schema
+    def self.clear_core_sxl_schemas(type = nil, version = nil)
+      @core_sxl_schemas ||= {}
+      return @core_sxl_schemas.clear unless type
+
+      type = type.to_sym
+      @core_sxl_schemas.delete_if do |(cached_type, cached_version, _core_version), _schema|
+        cached_type == type && (!version || cached_version == version.to_s)
+      end
+    end
+
+    def self.schema_core_version(schemas)
+      schemas[:core] || schemas['core']
+    end
+
+    def self.validate_resolved_sxl(message, resolved, schemas, options)
+      type, version = resolved
+      schema = find_core_sxl_schema! type, version, schema_core_version(schemas), options
+      validate_using_schema(message, schema)
+    end
+
+    def self.find_core_sxl_schema!(type, version, core_version, options = {})
+      raise ArgumentError, 'core version missing' unless core_version
+
+      version = sanitize_version(version.to_s) if options[:lenient]
+      core_version = sanitize_version(core_version.to_s) if options[:lenient]
+      find_schema! type, version
+      find_schema! :core, core_version
+
+      key = [type.to_sym, version.to_s, core_version.to_s]
+      @core_sxl_schemas ||= {}
+      @core_sxl_schemas[key] ||= build_core_sxl_schema(type, version, core_version)
+    end
+
+    def self.build_core_sxl_schema(type, version, core_version)
+      schema_path = @schema_paths&.dig(type.to_sym, version.to_s)
+      raise UnknownSchemaVersionError, "Unknown schema version #{type} #{version}" unless schema_path
+
+      file_path = File.join(schema_path, 'rsmp.json')
+      JSONSchemer.schema(
+        Pathname.new(file_path),
+        ref_resolver: core_sxl_ref_resolver(core_version)
+      )
+    end
+
+    def self.core_sxl_ref_resolver(core_version)
+      proc do |uri|
+        if sxl_definitions_ref?(uri)
+          JSON.parse(File.read(core_definitions_path(core_version), encoding: 'UTF-8'))
+        else
+          JSONSchemer::FILE_URI_REF_RESOLVER.call(uri)
+        end
+      end
+    end
+
+    def self.sxl_definitions_ref?(uri)
+      uri.scheme == 'file' && uri.path.end_with?('/defs/definitions.json')
+    end
+
+    def self.core_definitions_path(core_version)
+      path = File.join(schema_root_path, 'core', core_version.to_s, 'definitions.json')
+      return path if File.exist?(path)
+
+      raise UnknownSchemaVersionError, "Missing core definitions for RSMP #{core_version}"
+    end
+  end
+end