rsmp 0.52.0 → 0.53.0

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,7 +108,7 @@ 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
       collect = options[:collect]
       return unless collect
@@ -135,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
 

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

@@ -60,7 +60,8 @@ module RSMP
         def add_status_subscription(component_id, subs, update_list, arg, now)
           sci = arg['sCI']
           name = arg['n']
-          subcription = { interval: arg['uRt'].to_i, last_sent_at: now }
+          subcription = { interval: arg['uRt'].to_f, last_sent_at: now }
+          subcription[:on_change] = arg['sOc'] if core_3_3_0_or_newer?
           subs[sci] ||= {}
           subs[sci][name] = subcription
           update_list[component_id][sci] ||= []
@@ -70,6 +71,8 @@ module RSMP
         def process_status_subcribe(message)
           log "Received #{message.type}", message: message, level: :log
 
+          return process_core_3_3_subscription(message) if core_3_3_0_or_newer?
+
           update_list = {}
           component_id = message.attributes['cId']
           @status_subscriptions[component_id] ||= {}
@@ -84,6 +87,48 @@ module RSMP
           send_status_updates update_list
         end
 
+        def process_core_3_3_subscription(message)
+          validate_core_3_3_subscription!(message)
+          id = message.attributes['cId']
+          args = message.attributes['sS']
+          component = @site.find_component(id, build: false)
+          values = component ? fetch_status_values(component, args) : build_undefined_statuses(args)
+          subs = (@status_subscriptions[id] ||= {})
+          update_core_3_3_subscriptions(id, args, values, subs)
+          @status_subscriptions.delete(id) if subs.empty?
+          acknowledge message
+          update = core_3_3_subscription_update(id, values)
+          send_generated_message update
+          store_last_sent_status update
+        end
+
+        def core_3_3_subscription_update(id, values)
+          values = values.map { |value| value.except('uRt', 'sOc') }
+          StatusUpdate.new('cId' => id, 'sTs' => clock.to_s, 'sS' => values)
+        end
+
+        def update_core_3_3_subscriptions(id, args, values, subs)
+          updates = { id => {} }
+          values.each_with_index do |value, index|
+            arg = args[index]
+            if %w[unknown undefined].include?(value['q'])
+              remove_status_subscription(subs, arg)
+            else
+              add_status_subscription(id, subs, updates, arg, Time.now)
+            end
+          end
+        end
+
+        def validate_core_3_3_subscription!(message)
+          invalid = message.attributes['sS'].any? do |arg|
+            interval = arg['uRt'].to_f
+            interval.negative? || (interval.zero? && !arg['sOc'])
+          end
+          return unless invalid
+
+          raise MessageRejected, 'Subscription interval must be nonnegative and enable interval or sendOnChange'
+        end
+
         def get_status_subscribe_interval(component_id, sci, name)
           @status_subscriptions.dig component_id, sci, name
         end

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

@@ -22,7 +22,8 @@ module RSMP
         end
 
         def check_on_change_update(subscription, component, code, name)
-          return [nil, false] unless subscription[:interval].zero?
+          enabled = core_3_3_0_or_newer? ? subscription[:on_change] : subscription[:interval].zero?
+          return [nil, false] unless enabled
 
           current = current_status_value(component, code, name)
           last_sent = fetch_last_sent_status component.c_id, code, name
@@ -34,6 +35,10 @@ module RSMP
 
           value, quality = *(component.get_status code, name)
           rsmpify_value(value, quality)
+        rescue UnknownStatus
+          raise unless core_3_3_0_or_newer?
+
+          nil
         end
 
         def encode_status_value(code, name, value)
@@ -59,6 +64,8 @@ module RSMP
         end
 
         def status_update_timer(now)
+          return if core_3_3_0_or_newer? && connected? && !ready?
+
           send_status_updates status_updates_due(now)
         end
 
@@ -71,8 +78,15 @@ module RSMP
         end
 
         def collect_component_status_updates(update_list, component_id, by_code, now)
+          if core_3_3_0_or_newer? && !@site.components.key?(component_id)
+            @status_subscriptions.delete(component_id)
+            return
+          end
           component = @site.find_component component_id
           by_code.each_pair do |code, by_name|
+            probe = StatusUpdate.new('sS' => [{ 'sCI' => code }])
+            next if core_3_3_0_or_newer? && !sxl_message_allowed?(probe)
+
             by_name.each_pair do |name, subscription|
               current, should_send = check_status_subscription(subscription, component, code, name, now)
               next unless should_send
@@ -90,6 +104,8 @@ module RSMP
         end
 
         def precomputed_status_value(subscription, current)
+          return if core_3_3_0_or_newer? # Fetch value and quality together; do not replace quality with recent.
+
           PrecomputedStatusValue.new(current) if subscription[:interval].zero?
         end