rsmp 0.51.4 → 0.53.0

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

@@ -38,8 +38,24 @@ module RSMP
           write_protocol(message)
         end
 
+        def core_3_3_send_failure(message)
+          return unless core_3_3_0_or_newer?
+          return 'Alarm exchange is disabled' if message.is_a?(Alarm) && !use_alarms?
+
+          'Communication establishment is incomplete' if !ready? && application_message?(message)
+        end
+
+        def nts_attributes?(message)
+          message.attributes.key?('cId') || message.is_a?(Alarm) ||
+            message.is_a?(AggregatedStatus) || message.is_a?(AggregatedStatusRequest)
+        end
+
         def prepare_message(message, validate:)
+          permission = core_3_3_send_failure(message)
+          return invalid_outbound_result(message, permission) if permission
+
           message.direction = :out
+          apply_nts_message_attributes(message) if core_3_3_0_or_newer? && nts_attributes?(message)
           message.encode_for(schemas) unless validate == false
           message.generate_json
           unless validate == false
@@ -135,10 +151,14 @@ module RSMP
         end
 
         def apply_nts_message_attributes(message)
-          return if core_3_3?
+          if core_3_3_0_or_newer?
+            message.attributes['ntsOId'] = ''
+            message.attributes['xNId'] = ''
+            return
+          end
 
-          message.attributes['ntsOId'] = main && main.ntsoid ? main.ntsoid : ''
-          message.attributes['xNId'] = main && main.xnid ? main.xnid : ''
+          message.attributes['ntsOId'] = main&.ntsoid || ''
+          message.attributes['xNId'] = main&.xnid || ''
         end
       end
     end

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

@@ -0,0 +1,76 @@
+module RSMP
+  class Proxy
+    module Modules
+      # Shape and cross-message constraints for version negotiation.
+      module VersionValidation
+        def validate_version_array!(message)
+          items = message.attributes['RSMP']
+          valid = items.is_a?(Array) && !items.empty? && items.all? do |item|
+            item.is_a?(Hash) && item['vers'].is_a?(String) &&
+              (RSMP::Schema.strict_version?(item['vers']) || RSMP::Schema.normalize_core_version(item['vers']))
+          end
+          raise HandshakeError, 'Invalid RSMP version array' unless valid
+        end
+
+        def validate_version!(message, step:)
+          validation = message.validate(core: core_version)
+          raise HandshakeError, validation.message if validation.invalid?
+          return unless core_3_3_0_or_newer?
+
+          raise HandshakeError, "Expected Version #{step}" unless message.step == step
+
+          validate_sxl_names!(message.sxls)
+          validate_primary_sxl!(message) if step == 'Request'
+        end
+
+        def validate_sxl_names!(items)
+          names = items.map { |item| item['name'] }
+          raise HandshakeError, 'Duplicate SXL names' unless names.uniq == names
+
+          items.each do |item|
+            version = item['version']
+            if version && !RSMP::Schema.strict_version?(version)
+              raise HandshakeError, 'SXL version must use MAJOR.MINOR.PATCH'
+            end
+          end
+        end
+
+        def validate_primary_sxl!(message)
+          primary = message.attributes['SXL']
+          return unless primary && !primary.empty? && message.sxls.none? { |item| item['version'] == primary }
+
+          raise HandshakeError, 'Primary SXL version does not match SXLS'
+        end
+
+        def validate_sxl_response!(sxls)
+          offered = sxl_request_items
+          names = offered.map { |item| item['name'] }
+          returned = sxls.reject { |item| item['status'] == 'expected' }.map { |item| item['name'] }
+          raise HandshakeError, 'SXLS must report every offered SXL exactly once' unless returned.sort == names.sort
+
+          sxls.each { |item| validate_sxl_status!(item, names) }
+        end
+
+        def validate_sxl_status!(item, names)
+          case item['status']
+          when 'ok'
+            raise HandshakeError, 'SXL version must match the request exactly' unless valid_sxl_response?(item)
+          when 'expected'
+            raise HandshakeError, 'Expected SXL was offered' if names.include?(item['name'])
+          when 'mismatch'
+            supported = item['supported']
+            unless supported == supported.sort_by { |version| Gem::Version.new(version) }
+              raise HandshakeError, 'Supported SXL versions must be sorted'
+            end
+          end
+        end
+
+        def valid_sxl_response?(accepted)
+          requested = sxl_request_items.find { |item| item['name'] == accepted['name'] }
+          RSMP::Schema.strict_version?(accepted['version']) && requested &&
+            requested['version'] == accepted['version']
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,13 @@
+require_relative 'version_validation'
+
 module RSMP
   class Proxy
     module Modules
       # Version negotiation and handling
       # Manages RSMP version handshake between sites and supervisors
       module Versions
+        include VersionValidation
+
         def core_versions
           version = @site_settings['core_version']
           if version == 'latest'
@@ -25,8 +29,10 @@ module RSMP
           versions.uniq
         end
 
-        def core_3_3?
-          core_version && version_meets_requirement?(core_version, '>=3.3.0')
+        def core_3_3_0_or_newer?
+          return false unless core_version
+
+          version_meets_requirement?(core_version, '>=3.3.0')
         end
 
         def configured_sxls
@@ -48,7 +54,8 @@ module RSMP
         end
 
         def check_core_version(message)
-          versions = core_versions
+          validate_version_array!(message)
+          versions = @offered_core_versions || core_versions
           candidates = message.versions.filter_map do |wire_version|
             normalized = RSMP::Schema.normalize_core_version(wire_version)
             [wire_version, normalized] if normalized && versions.include?(normalized)
@@ -60,7 +67,6 @@ module RSMP
           else
             reason = "RSMP versions [#{message.versions.join(', ')}] requested, " \
                      "but only [#{versions.join(', ')}] supported."
-            dont_acknowledge message, 'Version message rejected', reason, force: true
             raise HandshakeError, reason
           end
         end
@@ -80,13 +86,13 @@ module RSMP
         end
 
         def send_version_response(site_id, core_versions)
-          if core_3_3?
+          if core_3_3_0_or_newer?
             send_generated_message Version.new({
                                                  'step' => 'Response',
                                                  'RSMP' => [{ 'vers' => core_version }],
                                                  'supervisorId' => site_id,
                                                  'SXLS' => version_response_sxls,
-                                                 'receiveAlarms' => @site_settings['receive_alarms'] != false
+                                                 'useAlarms' => @site_settings['use_alarms'] != false
                                                }), validate: false
           else
             send_legacy_version_response(site_id, core_versions)
@@ -106,7 +112,14 @@ module RSMP
 
         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'
+          if step == 'Request'
+            @offered_core_versions = normalized_core_versions(core_versions).filter_map do |version|
+              RSMP::Schema.normalize_core_version(version)
+            end
+            legacy_sxl = attributes['SXL']
+            attributes.merge!(version_request_attributes)
+            attributes['SXL'] = legacy_sxl unless @offered_core_versions.include?('3.3.0')
+          end
           send_generated_message Version.new(attributes), validate: false
         end
 
@@ -151,6 +164,7 @@ module RSMP
         def version_request_attributes
           {
             'step' => 'Request',
+            'SXL' => primary_configured_sxl ? sxl_request_items.first['version'] : '',
             'SXLS' => sxl_request_items
           }
         end
@@ -159,21 +173,6 @@ module RSMP
           accepted_sxls + rejected_sxls
         end
 
-        def validate_sxl_response!(sxls)
-          invalid = sxls.find { |accepted| !valid_sxl_response?(accepted) }
-          return unless invalid
-
-          raise HandshakeError,
-                "Invalid SXL version #{invalid['name']} #{invalid['version']}; " \
-                'Core 3.3 requires an exact MAJOR.MINOR.PATCH match'
-        end
-
-        def valid_sxl_response?(accepted)
-          requested = sxl_request_items.find { |item| item['name'] == accepted['name'] }
-          RSMP::Schema.strict_version?(accepted['version']) && requested &&
-            requested['version'] == accepted['version']
-        end
-
         def version_acknowledged; end
 
         def component_list_acknowledged; end

data/lib/rsmp/proxy/proxy.rb

@@ -80,6 +80,10 @@ module RSMP
       @ingoing_acknowledged = {}
       @outgoing_acknowledged = {}
       @latest_watchdog_send_at = nil
+      @last_site_status = nil
+      @last_component_list = nil
+      @initial_aggregated_status_id = nil
+      @site_aggregated_status = nil
       @component_list_received = false
       @outgoing_watchdog_acknowledged = false
       @sxl_interfaces = {}
@@ -104,11 +108,17 @@ module RSMP
       @sxls = []
       @accepted_sxls = []
       @rejected_sxls = []
-      @receive_alarms = true
+      @use_alarms = true
       @site_settings = nil # can't pick until we know the site id
-      return unless options[:collect]
+      collect = options[:collect]
+      return unless collect
+
+      @collector = if collect.is_a?(Proc)
+                     collect.call(self)
+                   else
+                     RSMP::Collector.new self, collect
+                   end
 
-      @collector = RSMP::Collector.new self, options[:collect]
       @collector.start
     end
 
@@ -129,8 +139,22 @@ module RSMP
       schemas
     end
 
-    def receive_alarms?
-      @receive_alarms != false
+    def application_message?(message)
+      !%w[Version Watchdog MessageAck MessageNotAck ComponentList AggregatedStatus].include?(message.type)
+    end
+
+    def sxl_message_allowed?(message)
+      return true unless core_3_3_0_or_newer?
+      return false if message.is_a?(Alarm) && !use_alarms?
+      return true if RSMP::Schema.core_message_type?(message.attributes)
+
+      !RSMP::Schema.resolve_sxl(message.attributes, schemas: schemas).nil?
+    rescue RSMP::Schema::UnknownMessageCodeError
+      false
+    end
+
+    def use_alarms?
+      !core_3_3_0_or_newer? || @use_alarms != false
     end
 
     def primary_sxl

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

@@ -4,7 +4,7 @@ module RSMP
       # Handles aggregated status requests and responses
       module AggregatedStatus
         # Build and send an AggregatedStatusRequest. Returns Result<AggregatedStatusRequest>.
-        def request_aggregated_status(component, m_id: nil, validate: true)
+        def request_aggregated_status(component = nil, m_id: nil, validate: true)
           readiness = validate_ready 'request aggregated status'
           return readiness if readiness.failure?
 
@@ -13,6 +13,7 @@ module RSMP
                                                         'cId' => component,
                                                         'mId' => m_id
                                                       })
+          message.attributes.delete('cId') if core_3_3_0_or_newer?
           apply_nts_message_attributes message
           send_message(message, validate: validate).map(&:message)
         end
@@ -22,7 +23,7 @@ module RSMP
         end
 
         # Build, send an AggregatedStatusRequest and collect the response. Returns Result<Exchange>.
-        def request_aggregated_status_and_collect(component, within:, m_id: nil, validate: true)
+        def request_aggregated_status_and_collect(component = nil, within:, m_id: nil, validate: true)
           readiness = validate_ready 'request aggregated status'
           return readiness if readiness.failure?
 
@@ -31,6 +32,7 @@ module RSMP
                                                         'cId' => component,
                                                         'mId' => m_id
                                                       })
+          message.attributes.delete('cId') if core_3_3_0_or_newer?
           apply_nts_message_attributes message
           collector = AggregatedStatusCollector.new(self, timeout: within, m_id: m_id, num: 1)
           send_message_and_collect(message, collector, validate: validate)
@@ -48,6 +50,8 @@ module RSMP
         end
 
         def process_aggregated_status(message)
+          return process_site_aggregated_status(message) if core_3_3_0_or_newer?
+
           status_elements = message.attribute('se')
           validate_aggregated_status(message, status_elements)
           c_id = message.attributes['cId']
@@ -64,6 +68,22 @@ module RSMP
           acknowledge message
         end
 
+        def process_site_aggregated_status(message)
+          @site_aggregated_status = message.attribute('se').dup.freeze
+          acknowledge message
+          @supervisor.site_aggregated_status_changed(self)
+          complete_initial_status(message)
+        end
+
+        attr_reader :site_aggregated_status
+
+        def complete_initial_status(message)
+          return unless core_3_3_0_or_newer? && !ready? && @component_list_received && @outgoing_watchdog_acknowledged
+          return unless message.is_a?(RSMP::AggregatedStatus)
+
+          handshake_complete
+        end
+
         def aggregated_status_changed(component, _options = {})
           @supervisor.aggregated_status_changed self, component
         end

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

@@ -66,7 +66,7 @@ module RSMP
         end
 
         def process_command_response(message)
-          return reject_multiple_command_codes(message) if core_3_3? && multiple_command_codes?(message)
+          return reject_multiple_command_codes(message) if core_3_3_0_or_newer? && multiple_command_codes?(message)
 
           log "Received #{message.type}", message: message, level: :log
           acknowledge message

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

@@ -86,8 +86,9 @@ module RSMP
       log "Received Version message for site #{@site_id}", message: message, level: :log
       start_timer
       acknowledge message
-      response_id = core_3_3? ? (@supervisor.site_id || @site_id) : @site_id
+      response_id = core_3_3_0_or_newer? ? (@supervisor.site_id || @site_id) : @site_id
       send_version_response response_id, core_versions
+      @use_alarms = @site_settings['use_alarms'] != false if core_3_3_0_or_newer?
       @version_determined = true
     end
 
@@ -101,9 +102,9 @@ module RSMP
     def acknowledged_first_outgoing(message)
       case message.type
       when 'Watchdog'
-        if core_3_3?
+        if core_3_3_0_or_newer?
           @outgoing_watchdog_acknowledged = true
-          handshake_complete if @component_list_received
+
         else
           handshake_complete
         end
@@ -130,30 +131,35 @@ module RSMP
     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
+      ids = items.map { |item| item['id'] }
+      raise MessageRejected, 'Duplicate component IDs' unless ids.uniq == ids
+
+      previous = @components
       @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
-        )
+        component = listed_component(item, previous[item['id']], grouped)
         @components[component.c_id] = component
         @main = component if grouped
       end
     end
 
+    def listed_component(item, previous, grouped)
+      if previous && previous.component_type == item['type']
+        previous.update_metadata(name: item['name'] || item['id'])
+        return previous
+      end
+
+      ComponentProxy.new(id: item['id'], node: self, type: item['type'], name: item['name'], grouped: grouped)
+    end
+
     def site_ids_changed
       @supervisor.site_ids_changed
     end
@@ -165,8 +171,9 @@ module RSMP
     def process_version(message)
       return extraneous_version message if @version_determined
 
-      check_site_ids message
       check_core_version message
+      validate_version! message, step: 'Request'
+      check_site_ids message
       check_sxl_version message
       version_accepted message
     end
@@ -174,6 +181,8 @@ 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
+      raise HandshakeError, 'Unexpected site identity' if core_3_3_0_or_newer? && @site_id && @site_id != site_id
+
       @site_id ||= site_id
       @supervisor.check_site_id site_id
       site_ids_changed

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

@@ -2,7 +2,7 @@ module RSMP
   # Selects the SXL versions accepted by a supervisor-side site proxy.
   module SiteSxlSelection
     def check_sxl_version(message)
-      if core_3_3?
+      if core_3_3_0_or_newer?
         select_sxls message
       else
         select_legacy_sxl message
@@ -26,34 +26,25 @@ module RSMP
     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? }
+      selected = message.sxls.map { |requested| select_sxl(requested) }
+      offered = message.sxls.map { |item| item['name'] }
+      configured_sxls.each do |item|
+        selected << { 'name' => item['name'], 'status' => 'expected' } unless offered.include?(item['name'])
+      end
+      @accepted_sxls, @rejected_sxls = selected.partition { |item| item['status'] == 'ok' }
     end
 
     def select_sxl(requested)
       configured = configured_sxls.find { |item| item['name'] == requested['name'] }
-      return rejected_sxl(requested, 1, 'SXL not supported') unless configured
-
-      unless RSMP::Schema.strict_version?(requested['version'])
-        return rejected_sxl(requested, 2, 'Core 3.3 requires SXL versions to use MAJOR.MINOR.PATCH')
-      end
+      return { 'name' => requested['name'], 'status' => 'unsupported' } unless configured
 
-      configured_version = RSMP::Schema.sanitize_version(configured['version'].to_s)
-      if configured_version == requested['version']
-        RSMP::Schema.find_schema! requested['name'], requested['version']
-        requested.slice('name', 'version', 'prefix')
+      version = RSMP::Schema.sanitize_version(configured['version'].to_s)
+      if version == requested['version']
+        RSMP::Schema.find_schema! requested['name'], version
+        { 'name' => requested['name'], 'status' => 'ok', 'version' => version }
       else
-        rejected_sxl(requested, 2, "Supervisor only supports #{configured['version']}")
+        { 'name' => requested['name'], 'status' => 'mismatch', 'supported' => [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/modules/aggregated_status.rb

@@ -3,14 +3,44 @@ module RSMP
     module Modules
       # Handles aggregated status messages
       module AggregatedStatus
+        def send_component_list
+          components = @site.component_list
+          result = send_generated_message ComponentList.new('components' => components)
+          @last_component_list = JSON.parse(JSON.generate(components)) if result.success?
+          result
+        end
+
+        def synchronize_site_state
+          send_component_list if @site.component_list != @last_component_list
+          send_changed_site_status
+        end
+
+        def component_list_acknowledged
+          return if ready? || @initial_aggregated_status_id
+
+          @initial_aggregated_status_id = Message.make_m_id
+          send_aggregated_status(nil, m_id: @initial_aggregated_status_id)
+        end
+
+        def initial_status_acknowledged(original)
+          return unless core_3_3_0_or_newer? && original.m_id == @initial_aggregated_status_id
+
+          @initial_aggregated_status_id = nil
+          handshake_complete unless ready?
+        end
+
         def send_all_aggregated_status
+          return send_site_aggregated_status if core_3_3_0_or_newer?
+
           @site.components.each_pair do |_c_id, component|
             send_aggregated_status component if component.grouped
           end
         end
 
         # Send aggregated status for a component
-        def send_aggregated_status(component, m_id: nil)
+        def send_aggregated_status(component = nil, m_id: nil)
+          return send_site_aggregated_status(m_id: m_id) if core_3_3_0_or_newer?
+
           m_id ||= RSMP::Message.make_m_id
 
           se = if core_version && Proxy.version_meets_requirement?(core_version, '<=3.1.2')
@@ -32,8 +62,33 @@ module RSMP
           send_generated_message message
         end
 
+        def send_changed_site_status
+          bits = @site.site_aggregated_status
+          return if bits == @last_site_status
+          return if connected? && !ready?
+
+          result = send_site_aggregated_status
+          @last_site_status = bits if result.success?
+          result
+        end
+
+        def send_site_aggregated_status(m_id: nil)
+          message = RSMP::AggregatedStatus.new(
+            'mId' => m_id, 'aSTS' => clock.to_s, 'se' => @site.site_aggregated_status
+          )
+          apply_nts_message_attributes message
+          result = send_generated_message message
+          @last_site_status = message.attributes['se'].dup if result.success?
+          result
+        end
+
         def process_aggregated_status_request(message)
           log "Received #{message.type}", message: message, level: :log
+          if core_3_3_0_or_newer?
+            acknowledge message
+            return send_site_aggregated_status
+          end
+
           component_id = message.attributes['cId']
           component = @site.find_component component_id
           acknowledge message

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

@@ -6,14 +6,21 @@ module RSMP
         def send_active_alarms
           @site.components.each_pair do |_c_id, component|
             component.alarms.each_pair do |_alarm_code, alarm_state|
-              if alarm_state.active
-                alarm = AlarmIssue.new(alarm_state.to_hash.merge('aSp' => 'Issue'))
-                send_generated_message alarm
-              end
+              next unless alarm_state.active || core_3_3_0_or_newer?
+
+              alarm = AlarmIssue.new(alarm_state.to_hash.merge('aSp' => 'Issue'))
+              next if core_3_3_0_or_newer? && !sxl_message_allowed?(alarm)
+
+              send_generated_message alarm
+              @initial_alarm_events << alarm_event_key(alarm) if core_3_3_0_or_newer? && @initial_alarm_events
             end
           end
         end
 
+        def alarm_event_key(message)
+          message.attributes.except('mId', 'ntsOId', 'xNId')
+        end
+
         def process_alarm(message)
           case message
           when AlarmAcknowledge

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

@@ -49,7 +49,7 @@ module RSMP
         end
 
         def check_required_command_arguments(message)
-          return unless core_3_3?
+          return unless core_3_3_0_or_newer?
 
           command_codes(message).each do |command_code|
             provided = message.attributes['arg'].select { |item| item['cCI'] == command_code }.map { |item| item['n'] }
@@ -93,11 +93,12 @@ module RSMP
         end
 
         def process_command_request(message)
-          return reject_multiple_command_codes(message) if core_3_3? && multiple_command_codes?(message)
+          return reject_multiple_command_codes(message) if core_3_3_0_or_newer? && multiple_command_codes?(message)
 
           check_required_command_arguments message
           component_id = message.attributes['cId']
           rvs = build_command_rvs(message.attributes['arg'])
+          acknowledge message if core_3_3_0_or_newer?
           execute_commands(message, component_id, rvs)
 
           response = CommandResponse.new({
@@ -106,7 +107,7 @@ module RSMP
                                            'rvs' => rvs
                                          })
           apply_nts_message_attributes response
-          acknowledge message
+          acknowledge message unless core_3_3_0_or_newer?
           send_generated_message response
         end
       end

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

@@ -76,8 +76,9 @@ module RSMP
 
         def prepare_message_for_buffer(message, core_version: @core_version, for_send: false)
           return unless site_originated_buffer_candidate? message
+          return unless sxl_message_allowed?(message)
           return false if message.is_a?(RSMP::StatusUpdate) && status_buffer_selectors == false
-          return false if message.is_a?(RSMP::Alarm) && !receive_alarms?
+          return false if message.is_a?(RSMP::Alarm) && !use_alarms?
 
           if message.is_a? RSMP::AggregatedStatus
             prepare_aggregated_status_for_buffer message, core_version: core_version, for_send: for_send
@@ -121,6 +122,10 @@ module RSMP
         end
 
         def flush_buffered_message?(message, queued, index)
+          if core_3_3_0_or_newer? && message.is_a?(Alarm) && @initial_alarm_events&.include?(alarm_event_key(message))
+            return true
+          end
+
           prepared = prepare_message_for_buffer message, core_version: @core_version, for_send: true
           return true unless prepared