rsmp 0.51.4 → 0.53.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 653475280335ad2b867657cada46ef95d9cb61808cb12f3302762b0e2bcda790
-  data.tar.gz: 2d8b6cfe3c5b46623329cb1dbcb1a01544dd293ab93f5398b650fea8121d31fd
+  metadata.gz: 66bd0079bb76c72ad04ce15f191ac3f33a06bcaf4f941c8d23f10b8239c3f308
+  data.tar.gz: 34f6fb37b13637ffe1bdf3f92064e103fc3b8b798fce11e2764d0ab810f23190
 SHA512:
-  metadata.gz: 82018c56d70a3cfa59db7d60b30c172f324765a01be8d650906d64c92109d68c52d80f75efdf388fd8332a9fa5028bc0ee1bed51e4293a1ffa6c5f441bfec8db
-  data.tar.gz: a1b83604f3b516da1dc0e8a3071cddd71cd4cadbc78f22406fe5ea0f73d21c06663ef1739de1666818d88ea85445cc6cc045ee024987fe2120a4ddc6e179b539
+  metadata.gz: 140f8cd7c0f9f5b542d4b4f47fd4d99095ff7eecaaf784bc6b6ae92e5dee1014b4f0a6338159c21e3bdda86e3ef06764f17b9d0055c3880b213a2c18e0e18708
+  data.tar.gz: ab5da12c73a27485b2e94d73cc2090adce96b69aa97dbb4530b5d5819aad20ecf0fa466d2b3b3f5068e678cbe41fcfefdf9808155c25656ad4fb52e78432ce7c

data/CHANGELOG.md

@@ -729,3 +729,12 @@ Initial release.
 ## 0.51.4
 - don't update subscription list until unsubscribe is acknowledged
 
+## 0.52.0
+- allow the proxy's `collect:` option to accept a Proc that builds a collector or queue before the handshake
+- add optional `predicate:` filtering to collectors, including status collectors
+- add `start` and `stop` aliases to queues for use with proxy collection factories
+- fix status collectors to honor `component:` and `responses:`; the misspelled `reponses:` option is no longer used
+
+## 0.53.0
+- update core 3.3.0 support to sync with latest core 3.3.0 draft
+- allow fractional status subscription intervals for all older core versions to align with their specs.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rsmp (0.51.4)
+    rsmp (0.53.0)
       async (~> 2.45)
       colorize (~> 1.1)
       io-endpoint (~> 0.17)

data/documentation/collecting_message.md

@@ -112,6 +112,118 @@ result = collector.collect do |message|
 end
 ```
 
+### Message predicates
+
+Use `predicate:` for conditions beyond the message type, direction, and component
+handled by `RSMP::Filter`. The Proc receives a whole message after the filter
+accepts it. Returning `false` or `nil` skips the message before collection
+callbacks or state-item matching; earlier item matches remain intact.
+
+```ruby
+collector = RSMP::Collector.new(
+  proxy,
+  filter: RSMP::Filter.new(type: 'StatusUpdate', ingoing: true, outgoing: false),
+  predicate: ->(message) { message.is_a?(RSMP::StatusUpdate) && message.attribute('sS').any? },
+  num: 1,
+  timeout: 5
+)
+```
+
+Predicates also work with `StatusCollector`. They do not suppress failures such
+as a rejection of the initiating request or an invalid peer message. `Filter`
+admits `MessageNotAck` even when a different message type is requested, so a
+predicate that accesses type-specific attributes should check the message type.
+
+### Status collection
+
+`StatusCollector` matches wanted status items within incoming messages. Both
+`StatusUpdate` and `StatusResponse` are accepted by default. Set `responses: false`
+to accept updates only, or `updates: false` to accept responses only.
+
+```ruby
+want = [{ 'sCI' => 'S0001', 'n' => 'signalgroupstatus' }]
+collector = RSMP::StatusCollector.new(
+  proxy, want, component: 'C1', responses: false, timeout: 5
+)
+```
+
+`component:` filters the message's `cId`; the wanted items describe entries in
+`sS`, which do not have their own component ID. Collection completes when all
+wanted items match, rather than after a fixed number of messages.
+
+### Collection during proxy setup
+
+The proxy's `collect:` option accepts the existing collector options hash:
+
+```ruby
+proxy_options = {
+  collect: {
+    filter: RSMP::Filter.new(type: 'StatusUpdate', ingoing: true, outgoing: false),
+    num: 1,
+    timeout: 5
+  }
+}
+```
+
+It also accepts a Proc that receives the new proxy and returns a collector or
+queue. The proxy calls `start` on the returned object and exposes it through
+`proxy.collector`. This starts receiving before the handshake can deliver
+messages. Return an unstarted object; the factory runs before version negotiation
+and should not rely on the proxy being fully initialized or connected.
+
+```ruby
+proxy_options = {
+  collect: proc do |proxy|
+    RSMP::StatusCollector.new(
+      proxy,
+      [{ 'sCI' => 'S0001', 'n' => 'signalgroupstatus' }],
+      component: 'C1', responses: false, timeout: 5
+    )
+  end
+}
+```
+
+Pass these options when creating the proxy. Use `proxy.collector.wait` or
+`wait!` for a collector, or `wait_for_message` or `wait_for_message!` for a queue.
+
+## Queues
+
+`RSMP::Queue` retains accepted messages until consumed, including messages that
+arrive before the caller starts waiting. Each wait returns one message, rather
+than a collection. `start` and `stop` are aliases for `start_receiving` and
+`stop_receiving`, so a queue can also be returned by a proxy's `collect:` factory.
+
+```ruby
+queue = RSMP::Queue.new(proxy, filter: RSMP::Filter.new(type: 'StatusUpdate'))
+queue.start
+begin
+  result = queue.wait_for_message(timeout: 5)
+  puts result.value if result.success?
+ensure
+  queue.stop
+end
+```
+
+A queue stays registered until stopped. Its `timeout:` applies to an individual
+wait: expiry returns a failure with code `:timeout`, or raises
+`RSMP::OperationError` through `wait_for_message!`.
+
+An enclosing Async timeout raised while waiting in the queue is converted in
+the same way, even when no queue timeout is supplied:
+
+```ruby
+begin
+  message = Async::Task.current.with_timeout(5) { queue.wait_for_message! }
+rescue RSMP::OperationError => error
+  raise unless error.failure.code == :timeout
+
+  warn 'The caller deadline expired'
+end
+```
+
+This example assumes the queue is already started. Both timeout sources use the
+same failure code; `failure.cause` retains the original Async exception.
+
 ## Sending and collecting atomically
 
 High-level send methods follow the same non-bang/bang convention:

data/documentation/configuration.md

@@ -21,8 +21,11 @@ and `required_supervisor_settings.json` schemas then check required settings aft
 supervisor site inheritance are resolved:
 
 - Every configured signal plan must have a `cycle_time`.
-- Configured components must include exactly one `main` component. Sites supply a default main
-  component when omitted; supervisor site settings can inherit it from `default`.
+- Before Core 3.3.0, exactly one `main` component is required. Sites supply a default main component
+  when omitted; supervisor site settings can inherit it from `default`. From Core 3.3.0, a main
+  component is not used. With `core_version: "3.3.0"`, no default components are added, even if
+  `components` is omitted. Configurations that allow older Core versions (including an omitted
+  `core_version` or `"all"`) retain the default main component.
 - A site in `server` role must have a `port`, either explicitly or from its first supervisor endpoint.
   With `supervisors: []`, the port must be explicit.
 
@@ -36,6 +39,54 @@ Earlier Core versions retain their historical wire formats for compatibility. In
 
 Legacy SXL strings such as `1.1` and `1.2` remain supported for connections using a Core version before 3.3.0. Their three-part equivalents are used only for internal schema lookup.
 
+## Core 3.3.0
+
+Preliminary Core 3.3.0 support follows `rsmp_core` branch `3.3.0` at commit
+`1aa02faf82da4f47fee57c43c546c092420aa576`, including PR #318. These rules apply only
+when Core 3.3.0 is selected. Earlier Core versions retain their existing behavior.
+
+SXL responses use `ok`, `unsupported`, `mismatch` and `expected`. Only `ok` enables
+an SXL, at the exact offered version. `supported` is diagnostic and does not trigger
+fallback. A connection can become ready even if no SXL is accepted.
+
+Set `use_alarms: false` in the supervisor's `default` or per-site configuration to
+disable every Alarm message in both directions on a 3.3.0 connection. The default
+is true.
+
+The 3.3.0 handshake ends with ComponentList followed by a site-wide AggregatedStatus.
+Readiness follows acknowledgement of that status; either MessageAck or MessageNotAck
+completes this step. The initial status is mandatory even with `send_after_connect: false`.
+
+AggregatedStatus has no `cId`, `fP` or `fS`. All false bits mean normal operation;
+bits 2, 6 and 8 are always false in site messages. Site-wide conditions include all
+components and active alarm priorities, including SXLs rejected on a connection.
+Read received bits through `SiteProxy#site_aggregated_status` and override
+`Supervisor#site_aggregated_status_changed(site_proxy)` for notifications.
+For 3.3.0, call `request_aggregated_status` or `request_aggregated_status_and_collect`
+without a component. A supplied component argument is ignored on the wire. Legacy
+requests remain component-addressed.
+
+Use `add_component`, `remove_component` and `ComponentBase#update_metadata` to update
+the inventory. Ready 3.3.0 connections receive a complete ComponentList after a change;
+disconnected connections receive the current list in their next handshake. The
+supervisor preserves received ordering and retains unchanged component objects.
+Component names are optional on the wire but must be nonempty strings when supplied.
+The supervisor uses the component ID when a list entry omits its name, including
+when a later list removes a previously supplied name.
+Removing the last component is prohibited because the Core 3.3.0 schema requires a
+nonempty ComponentList.
+
+Subscription intervals use `uRt`, an integer or decimal
+number represented as a string, e.g. `"2"` or `"0.5"`. Negative intervals are invalid.
+Zero disables periodic updates and is valid only with `sOc: true`.
+The Core source and vendored 3.3.0 schemas include this correction to the pinned baseline.
+The isolated main-component requirement in `site_configuration.rst` is treated as
+obsolete for 3.3.0 in favor of the component model and site-wide status definitions.
+
+Validator follow-up should cover the new Version statuses and failures, both alarm
+directions, site-wide status bits and fields, final-handshake ACK/NotAck, component
+changes, and accepted-SXL filtering during initial synchronization and buffer replay.
+
 ## Loading a configuration file
 
 Use the option classes to load a YAML configuration file:

data/lib/rsmp/collect/collector.rb

@@ -7,6 +7,9 @@ module RSMP
 
     attr_reader :messages, :m_id, :initiator
 
+    # :predicate optionally receives each message accepted by the filter. A falsey
+    # result skips the message before collection callbacks or item matching.
+    # Rejection and invalid-message failures are handled independently of it.
     def initialize(distributor, options = {})
       initialize_receiver distributor, filter: options[:filter]
       @options = {
@@ -17,6 +20,7 @@ module RSMP
       }.deep_merge(options)
       @timeout = options[:timeout]
       @num = options[:num]
+      @predicate = options[:predicate]
       @initiator = options[:initiator]
       @m_id = options[:m_id] || @initiator&.attributes&.dig('mId')
       make_title(options[:title])
@@ -131,6 +135,8 @@ module RSMP
     def perform_match?(message)
       return false if reject_not_ack?(message)
       return false unless acceptable?(message)
+      return false if @predicate && !@predicate.call(message)
+      return false unless active?
 
       if @block
         status = Array(@block.call(message))

data/lib/rsmp/collect/queue.rb

@@ -7,6 +7,10 @@ module RSMP
 
     attr_reader :messages
 
+    # Allow queues to be started by a proxy's collect factory, like collectors.
+    alias start start_receiving
+    alias stop stop_receiving
+
     def initialize(distributor, filter: nil)
       initialize_receiver distributor, filter: filter
       @condition = Async::Notification.new

data/lib/rsmp/collect/status_collector.rb

@@ -4,11 +4,11 @@ module RSMP
     def initialize(proxy, want, options = {})
       type = []
       type << 'StatusUpdate' unless options[:updates] == false
-      type << 'StatusResponse' unless options[:reponses] == false
+      type << 'StatusResponse' unless options[:responses] == false
 
       super(proxy, want, options.merge(
         title: 'status response',
-        filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: type)
+        filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: type, component: options[:component])
       ))
     end
 

data/lib/rsmp/component/component_base.rb

@@ -41,8 +41,10 @@ module RSMP
     end
 
     def update_metadata(type: nil, name: nil)
+      changed = (type && type != @component_type) || (name && name != @name)
       @component_type = type if type
       @name = name if name
+      @node.component_list_changed if changed
     end
 
     def now
@@ -73,7 +75,14 @@ module RSMP
       raise ArgumentError, 'aggregated status must be an Array' unless status.is_a? Array
 
       input = status & AGGREGATED_STATUS_KEYS
-      return unless input != @aggregated_status
+      if @node.respond_to?(:site_wide_aggregated_status?) && @node.site_wide_aggregated_status?
+        bits = AGGREGATED_STATUS_KEYS.map { |key| input.include?(key) }
+        return if bits == @aggregated_status_bools
+
+        @aggregated_status = input
+      else
+        return unless input != @aggregated_status
+      end
 
       AGGREGATED_STATUS_KEYS.each_with_index do |key, index|
         @aggregated_status_bools[index] = status.include?(key)

data/lib/rsmp/component/component_proxy.rb

@@ -39,7 +39,7 @@ module RSMP
 
     def update_rate_set?(subscription_list, status_code, status_name)
       urt = subscription_list.dig(c_id, status_code, status_name, 'uRt')
-      urt.to_i.positive?
+      urt.to_f.positive?
     end
 
     def should_check_repeats?(subscription_list, status_code, status_name)

data/lib/rsmp/component/components.rb

@@ -13,7 +13,7 @@ module RSMP
     def setup_components(settings)
       return unless settings
 
-      check_main_component settings
+      check_main_component settings unless core_3_3_components?
       settings.each_pair do |type, components_by_type|
         next unless components_by_type
 
@@ -30,6 +30,10 @@ module RSMP
       end
     end
 
+    def core_3_3_components?
+      @site_settings && @site_settings['core_version'] == '3.3.0'
+    end
+
     def check_main_component(settings)
       raise ConfigurationError, 'main component must be defined' unless settings['main'] && settings['main'].size >= 1
       return unless settings['main'].size > 1
@@ -39,11 +43,29 @@ module RSMP
 
     def add_component(component)
       @components[component.c_id] = component
+      component_list_changed
+      component
+    end
+
+    def component_list_changed; end
+
+    def remove_component(id)
+      raise ConfigurationError, 'Cannot remove the legacy main component' if @main&.c_id == id &&
+                                                                             @site_settings['core_version'] != '3.3.0'
+
+      if core_3_3_components? && @components.size == 1 && @components.key?(id)
+        raise ConfigurationError, 'Core 3.3 ComponentList must not be empty'
+      end
+
+      removed = @components.delete(id)
+      @main = nil if removed == @main
+      component_list_changed if removed
+      removed
     end
 
     def natural_sort_key(value)
       value.to_s.split(/(\d+)/).map do |part|
-        part.match?(/\A\d+\z/) ? part.to_i : part
+        part.match?(/\A\d+\z/) ? [0, part.to_i, part.length] : [1, part]
       end
     end
 

data/lib/rsmp/node/site/site.rb

@@ -1,7 +1,10 @@
+require_relative 'status'
+
 module RSMP
   # RSMP site implementation that manages proxies and components.
   class Site < Node
     include Components
+    include SiteStatus
     include SiteConnections
 
     attr_reader :core_version, :site_settings, :logger, :proxies, :ready_condition
@@ -127,12 +130,6 @@ module RSMP
       start_status_timer(parent: parent)
     end
 
-    def aggregated_status_changed(component, _options = {})
-      @proxies.each do |proxy|
-        proxy.send_aggregated_status component
-      end
-    end
-
     def alarm_acknowledged(alarm_state)
       send_alarm AlarmAcknowledged.new(alarm_state.to_hash)
     end
@@ -143,11 +140,28 @@ module RSMP
 
     def alarm_activated_or_deactivated(alarm_state)
       send_alarm AlarmIssue.new(alarm_state.to_hash)
+      notify_site_status_change
     end
 
     def send_alarm(alarm)
+      # Snapshot before any connection encodes the message for its SXL version.
+      independent = @proxies.any? { |proxy| proxy.respond_to?(:core_3_3_0_or_newer?) && proxy.core_3_3_0_or_newer? }
+      attributes = JSON.parse(JSON.generate(alarm.attributes)) if independent
       @proxies.each do |proxy|
-        proxy.send_generated_message alarm if proxy.receive_alarms?
+        next unless proxy.use_alarms?
+
+        send_connection_alarm(proxy, alarm, attributes)
+      end
+    end
+
+    def send_connection_alarm(proxy, alarm, attributes)
+      return if proxy.core_3_3_0_or_newer? && !proxy.sxl_message_allowed?(alarm)
+
+      alarm = alarm.class.new(JSON.parse(JSON.generate(attributes)).merge('mId' => Message.make_m_id)) if attributes
+      if proxy.core_3_3_0_or_newer? && !proxy.ready?
+        proxy.buffer_message alarm
+      else
+        proxy.send_generated_message alarm
       end
     end
 

data/lib/rsmp/node/site/status.rb

@@ -0,0 +1,39 @@
+module RSMP
+  # Site-wide status and component change notifications for Core 3.3.
+  module SiteStatus
+    def aggregated_status_changed(component, _options = {})
+      @proxies.each do |proxy|
+        if proxy.core_3_3_0_or_newer?
+          proxy.send_changed_site_status
+        else
+          proxy.send_aggregated_status component
+        end
+      end
+    end
+
+    def site_wide_aggregated_status?
+      @site_settings['core_version'] == '3.3.0' || @proxies&.any?(&:core_3_3_0_or_newer?)
+    end
+
+    # Core 3.3 status includes every SXL, independently of connection negotiation.
+    def site_aggregated_status
+      bits = Array.new(8, false)
+      @components.each_value do |component|
+        [0, 2, 3, 4, 6].each { |index| bits[index] ||= component.aggregated_status_bools[index] }
+        component.alarms.each_value do |alarm|
+          bits[alarm.priority + 1] = true if alarm.active && (1..3).cover?(alarm.priority)
+        end
+      end
+      bits
+    end
+
+    def notify_site_status_change
+      @proxies.each { |proxy| proxy.send_changed_site_status if proxy.core_3_3_0_or_newer? }
+    end
+
+    def component_list_changed
+      @proxies&.each { |proxy| proxy.send_component_list if proxy.core_3_3_0_or_newer? && proxy.ready? }
+      notify_site_status_change if @proxies
+    end
+  end
+end

data/lib/rsmp/node/supervisor/modules/connection.rb

@@ -92,11 +92,28 @@ module RSMP
             site_id: site_id,
             site_settings: site_settings
           }
+        rescue HandshakeError => e
+          reject_initial_version(protocol, e)
+          raise
+        end
+
+        def reject_initial_version(protocol, error)
+          attributes = Message.parse_attributes(protocol.peek_line)
+          id = attributes['mId']
+          if id.is_a?(String) && /\A[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i.match?(id)
+            protocol.write_lines(JSON.generate('mType' => 'rSMsg', 'type' => 'MessageNotAck',
+                                               'oMId' => id, 'rea' => error.message))
+          end
         end
 
         def retrieve_site_id(protocol)
           version_message = peek_version_message protocol
-          version_message.attribute('siteId').first['sId']
+          ids = version_message.attributes['siteId']
+          unless ids.is_a?(Array) && ids.first.is_a?(Hash) && ids.first['sId'].is_a?(String)
+            raise HandshakeError, 'Invalid siteId in Version request'
+          end
+
+          ids.first['sId']
         end
 
         def setup_proxy(proxy, settings, id)
@@ -112,10 +129,9 @@ module RSMP
           proxy
         end
 
-        def validate_and_start_proxy(proxy, protocol)
+        def validate_and_start_proxy(proxy, _protocol)
           proxy.setup_site_settings
-          proxy.check_core_version peek_version_message(protocol)
-          log "Validating using core version #{proxy.core_version}", level: :debug
+
           proxy.start
           proxy.wait
         ensure

data/lib/rsmp/node/supervisor/modules/sites.rb

@@ -68,6 +68,8 @@ module RSMP
           @site_id_condition.signal
         end
 
+        def site_aggregated_status_changed(site_proxy); end
+
         def aggregated_status_changed(site_proxy, component); end
       end
     end

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

@@ -3,17 +3,7 @@
   "$comment": "Validate after applying defaults and inherited site settings; structural validation uses the other config schemas.",
   "type": "object",
   "properties": {
-    "components": {
-      "type": "object",
-      "required": ["main"],
-      "properties": {
-        "main": {
-          "type": "object",
-          "minProperties": 1,
-          "maxProperties": 1
-        }
-      }
-    },
+    "components": { "type": "object" },
     "signal_plans": {
       "type": "object",
       "additionalProperties": {
@@ -26,5 +16,23 @@
     "required": ["connection_role"],
     "properties": { "connection_role": { "const": "server" } }
   },
-  "then": { "required": ["port"] }
+  "then": { "required": ["port"] },
+  "allOf": [
+    {
+      "if": {
+        "required": ["core_version"],
+        "properties": { "core_version": { "const": "3.3.0" } }
+      },
+      "else": {
+        "properties": {
+          "components": {
+            "required": ["main"],
+            "properties": {
+              "main": { "type": "object", "minProperties": 1, "maxProperties": 1 }
+            }
+          }
+        }
+      }
+    }
+  ]
 }

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

@@ -24,7 +24,7 @@
     "intervals": { "$ref": "config_common.json#/$defs/intervals" },
     "timeouts": { "$ref": "config_common.json#/$defs/timeouts" },
     "send_after_connect": { "type": "boolean" },
-    "receive_alarms": { "type": "boolean" },
+    "use_alarms": { "type": "boolean" },
     "message_buffer": { "$ref": "config_common.json#/$defs/message_buffer" },
     "skip_validation": { "type": "array", "items": { "type": "string" } },
     "security_codes": { "$ref": "config_common.json#/$defs/security_codes" },

data/lib/rsmp/options/site_options.rb

@@ -56,6 +56,7 @@ module RSMP
 
       def apply_defaults(options)
         defaults = defaults()
+        defaults['components'] = {} if options['core_version'] == '3.3.0'
         defaults['components']['main'] = options['components']['main'] if options.dig('components', 'main')
         data = defaults.deep_merge(options)
         port = data.dig('supervisors', 0, 'port')

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

@@ -111,6 +111,7 @@ module RSMP
 
             @acknowledgements[original.m_id] = message
             @acknowledgement_condition.signal message
+            initial_status_acknowledged(original) if respond_to?(:initial_status_acknowledged)
           else
             log_acknowledgement_for_unknown message
           end
@@ -124,6 +125,7 @@ module RSMP
             log_acknowledgement_for_original message, original
             @acknowledgements[original.m_id] = message
             @acknowledgement_condition.signal message
+            initial_status_acknowledged(original) if respond_to?(:initial_status_acknowledged)
           else
             log_acknowledgement_for_unknown message
           end

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

@@ -26,11 +26,12 @@ module RSMP
         def process_packet(json)
           attributes = Message.parse_attributes(json)
           message = Message.build(attributes, json)
+          message.attributes['mId'] = attributes['mId'] if message.is_a?(Version)
           process_incoming_message(message)
         rescue InvalidPacket => e
           reject_invalid_packet(json, e)
         rescue MalformedMessage => e
-          reject_malformed_packet(json, attributes, e)
+          reject_malformed_version_or_packet(json, attributes, e)
         rescue PeerMessageError => e
           reject_processed_message(message, e)
         rescue HandshakeError, FatalError => e
@@ -39,7 +40,28 @@ module RSMP
           @node&.clear_deferred
         end
 
+        def reject_malformed_version_or_packet(json, attributes, error)
+          if attributes.is_a?(Hash) && attributes['type'] == 'Version' && core_3_3_0_or_newer?
+            message = Version.new(attributes)
+            message.attributes['mId'] = attributes['mId']
+            reject_fatal_message(message, error)
+          else
+            reject_malformed_packet(json, attributes, error)
+          end
+        end
+
+        def check_core_3_3_permissions!(message)
+          if core_3_3_0_or_newer? && message.is_a?(Alarm) && !use_alarms?
+            raise MessageRejected,
+                  'Alarm exchange is disabled'
+          end
+          return unless core_3_3_0_or_newer? && @version_determined && !ready? && application_message?(message)
+
+          raise MessageRejected, 'Communication establishment is incomplete'
+        end
+
         def process_incoming_message(message)
+          check_core_3_3_permissions!(message)
           validate = should_validate_ingoing_message?(message)
           if validate
             validation = message.validate(schemas)
@@ -86,6 +108,7 @@ module RSMP
           publish_peer_failure(failure, message: message)
           log(text, message: message, level: :warning)
           dont_acknowledge(message, text, reason)
+          complete_initial_status(message) if respond_to?(:complete_initial_status)
           Result.failure(failure: failure)
         end
 
@@ -109,11 +132,18 @@ module RSMP
           text = "Rejected #{message&.type || 'message'}: #{error.message}"
           failure = peer_failure(:protocol_failure, text, message: message)
           publish_peer_failure(failure, message: message)
-          dont_acknowledge(message, "Rejected #{message.type}", error.message.to_s) if message
+          if message && (!message.is_a?(Version) || valid_received_message_id?(message))
+            dont_acknowledge(message, "Rejected #{message.type}", error.message.to_s)
+          end
           close(reason: :protocol_failure, failure: failure)
           Result.failure(failure: failure)
         end
 
+        def valid_received_message_id?(message)
+          id = message.m_id
+          id.is_a?(String) && /\A[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i.match?(id)
+        end
+
         def peer_failure(code, text, message: nil, **context)
           Failure.new(
             code: code,