rsmp 0.43.2 → 0.45.0

data/lib/rsmp/options/options.rb

@@ -25,9 +25,9 @@ module RSMP
       options = extra if options.nil? && extra.any?
       @source = source
       @log_settings = normalize(log_settings || {})
-      normalized = normalize(options || {})
-      @data = apply_defaults(normalized)
-      validate! if validate
+      config = normalize_config(options || {})
+      validate!(config) if validate
+      @data = normalize(apply_defaults(config))
     end
 
     def defaults
@@ -44,11 +44,11 @@ module RSMP
       File.join(SCHEMAS_PATH, schema_file)
     end
 
-    def validate!
+    def validate!(data = @data)
       return unless schema_path && File.exist?(schema_path)
 
       schemer = JSONSchemer.schema(Pathname.new(schema_path))
-      errors = schemer.validate(@data).to_a
+      errors = schemer.validate(data).to_a
       return if errors.empty?
 
       message = errors.map { |error| format_error(error) }.join("\n")
@@ -82,7 +82,8 @@ module RSMP
       case value
       when Hash
         value.each_with_object({}) do |(key, val), memo|
-          memo[key.to_s] = normalize(val)
+          normalized_key = key.to_s
+          memo[normalized_key] = normalized_key == 'sxls' ? normalize_sxls(val) : normalize(val)
         end
       when Array
         value.map { |item| normalize(item) }
@@ -91,6 +92,54 @@ module RSMP
       end
     end
 
+    def normalize_sxls(value)
+      case value
+      when Hash
+        value.map do |name, details|
+          normalize_sxl_item(name.to_s, details)
+        end
+      when Array
+        value.map { |item| normalize(item) }
+      else
+        value
+      end
+    end
+
+    def normalize_config(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, val), memo|
+          normalized_key = key.to_s
+          memo[normalized_key] = normalized_key == 'sxls' ? normalize_config_sxls(val) : normalize_config(val)
+        end
+      when Array
+        value.map { |item| normalize_config(item) }
+      else
+        value
+      end
+    end
+
+    def normalize_config_sxls(value)
+      raise RSMP::ConfigurationError, 'sxls must be a hash of SXL names to versions' unless value.is_a?(Hash)
+
+      value.each_with_object({}) do |(name, details), memo|
+        raise RSMP::ConfigurationError, "sxls/#{name} must be a version string" if details.is_a?(Hash)
+
+        memo[name.to_s] = details.to_s
+      end
+    end
+
+    def normalize_sxl_item(name, details)
+      case details
+      when Hash
+        raise RSMP::ConfigurationError, "sxls/#{name} must be a version string"
+      when nil
+        { 'name' => name }
+      else
+        { 'name' => name, 'version' => details.to_s }
+      end
+    end
+
     def format_error(error)
       pointer = error_pointer(error)
       details = error_details(error)

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

@@ -17,8 +17,11 @@
         "additionalProperties": true
       }
     },
-    "sxl": { "type": "string" },
-    "sxl_version": { "type": "string" },
+    "sxls": {
+      "type": "object",
+      "propertyNames": { "not": { "const": "core" } },
+      "additionalProperties": { "type": "string" }
+    },
     "core_version": { "type": "string" },
     "intervals": {
       "type": "object",
@@ -46,4 +49,4 @@
     "live_output": { "type": ["string", "null"] }
   },
   "additionalProperties": true
-}
+}

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

@@ -15,8 +15,11 @@
     "default": {
       "type": "object",
       "properties": {
-        "sxl": { "type": "string" },
-        "sxl_version": { "type": "string" },
+        "sxls": {
+          "type": "object",
+          "propertyNames": { "not": { "const": "core" } },
+          "additionalProperties": { "type": "string" }
+        },
         "core_version": { "type": "string" },
         "intervals": {
           "type": "object",

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

@@ -3,8 +3,11 @@
   "$id": "supervisor_site.json",
   "type": "object",
   "properties": {
-    "sxl": { "type": "string" },
-    "sxl_version": { "type": "string" },
+    "sxls": {
+      "type": "object",
+      "propertyNames": { "not": { "const": "core" } },
+      "additionalProperties": { "type": "string" }
+    },
     "type": { "type": "string" },
     "components": { "type": "object" },
     "supervisors": {

data/lib/rsmp/options/site_options.rb

@@ -8,8 +8,9 @@ module RSMP
           'supervisors' => [
             { 'ip' => '127.0.0.1', 'port' => 12_111 }
           ],
-          'sxl' => 'tlc',
-          'sxl_version' => RSMP::Schema.latest_version(:tlc),
+          'sxls' => {
+            'tlc' => RSMP::Schema.latest_version(:tlc)
+          },
           'intervals' => {
             'timer' => 0.1,
             'watchdog' => 1,

data/lib/rsmp/options/supervisor_options.rb

@@ -7,7 +7,9 @@ module RSMP
           'port' => 12_111,
           'ips' => 'all',
           'default' => {
-            'sxl' => 'tlc',
+            'sxls' => {
+              'tlc' => RSMP::Schema.latest_version(:tlc)
+            },
             'intervals' => {
               'timer' => 1,
               'watchdog' => 1

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

@@ -86,6 +86,8 @@ module RSMP
             case original.type
             when 'Version'
               version_acknowledged
+            when 'ComponentList'
+              component_list_acknowledged
             when 'StatusSubscribe'
               status_subscribe_acknowledged original
             end

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

@@ -5,6 +5,8 @@ module RSMP
       # Handles receiving and processing incoming messages
       module Receive
         def should_validate_ingoing_message?(message)
+          return false if message.is_a?(Version) && !@version_determined
+
           return true unless @site_settings
 
           skip = @site_settings['skip_validation']
@@ -37,7 +39,8 @@ module RSMP
         end
 
         def handle_schema_error(message, error)
-          schemas_string = error.schemas.map { |schema| "#{schema.first}: #{schema.last}" }.join(', ')
+          failed_schemas = error.respond_to?(:schemas) && error.schemas ? error.schemas : schemas
+          schemas_string = failed_schemas.map { |schema| "#{schema.first}: #{schema.last}" }.join(', ')
           reason = "schema errors (#{schemas_string}): #{error.message}"
           str = "Received invalid #{message.type}"
           distribute_error error.exception(str), message: message
@@ -79,7 +82,7 @@ module RSMP
           handle_malformed_message(attributes, e)
         rescue SchemaError, RSMP::Schema::Error => e
           handle_schema_error(message, e)
-        rescue InvalidMessage => e
+        rescue InvalidMessage, MessageRejected => e
           handle_invalid_message(message, e)
         rescue FatalError => e
           handle_fatal_error(message, e)

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

@@ -17,6 +17,7 @@ module RSMP
         end
 
         def handshake_complete
+          build_sxl_interfaces
           self.state = :ready
         end
       end

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