rsmp 0.48.4 → 0.51.1

data/lib/rsmp/proxy/proxy.rb

@@ -16,10 +16,11 @@ module RSMP
     include Modules::Receive
     include Modules::Versions
     include Modules::Tasks
+    include Modules::Lifecycle
 
     attr_reader :state, :archive, :connection_info, :sxls, :accepted_sxls, :rejected_sxls,
-                :collector, :ip, :port, :node, :core_version, :sxl_interfaces,
-                :site_settings
+                :collector, :ip, :port, :node, :core_version, :core_version_string, :sxl_interfaces,
+                :site_settings, :session_id
 
     def initialize(options)
       @node = options[:node]
@@ -31,6 +32,8 @@ module RSMP
       clear
       @state = :disconnected
       @state_condition = Async::Notification.new
+      @session_id = 0
+      @session_closed = true
     end
 
     def inspect
@@ -41,67 +44,6 @@ module RSMP
       node.now
     end
 
-    # Connection lifecycle methods
-
-    def disconnect; end
-
-    # wait for the reader task to complete,
-    # which is not expected to happen before the connection is closed
-    def wait_for_reader
-      @reader&.wait
-    end
-
-    # close connection, but keep our main task running so we can reconnect
-    def close
-      log 'Closing connection', level: :warning
-      close_stream
-      close_socket
-      stop_reader
-      self.state = :disconnected
-      distribute_error DisconnectError.new('Connection was closed')
-
-      # stop timer
-      # as we're running inside the timer, code after stop_timer() will not be called,
-      # unless it's in the ensure block
-      stop_timer
-    end
-
-    def stop_subtasks
-      stop_timer
-      stop_reader
-      clear
-      super
-    end
-
-    def stop_timer
-      @timer&.stop
-    ensure
-      @timer = nil
-    end
-
-    def stop_reader
-      @reader&.stop
-    ensure
-      @reader = nil
-    end
-
-    def close_stream
-      @stream&.close
-    ensure
-      @stream = nil
-    end
-
-    def close_socket
-      @socket&.close
-    ensure
-      @socket = nil
-    end
-
-    def stop_task
-      close
-      super
-    end
-
     # State management methods
 
     def ready?
@@ -174,10 +116,6 @@ module RSMP
       @node.clock
     end
 
-    def receive_error(error, options = {})
-      @node.receive_error error, options
-    end
-
     def log(str, options = {})
       super(str, options.merge(ip: @ip, port: @port, site_id: @site_id))
     end
@@ -252,8 +190,8 @@ module RSMP
     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']
+    # Requirement must be a string like '1.1.0', '>=1.0.3' or '<2.1.4',
+    # or list of strings, like ['<=1.4.0','<1.5.0']
     def self.version_meets_requirement?(version, requirement)
       Modules::Versions.version_meets_requirement?(version, requirement)
     end

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

@@ -12,50 +12,46 @@ module RSMP
     end
 
     def run_accepted_connection
+      begin_session
       self.state = :connected
       start_reader
-      wait_for_reader # run until disconnected
-    rescue RSMP::ConnectionError => e
-      log e, level: :error
-    rescue StandardError => e
-      distribute_error e, level: :internal
+      ended = wait_for_reader
+      close_from_result(ended)
     ensure
+      close(reason: :internal_failure) if $ERROR_INFO
       close
     end
 
     def run_outbound_connection
       loop do
         setup_site_settings
-        connect
+        connected = connect
+        unless connected.success?
+          publish_connection_attempt_failure(connected.failure)
+          break unless reconnect_delay?
+
+          next
+        end
         start_reader
-        wait_for_reader
-        break unless reconnect_delay?
-      rescue Restart
-        @logger.mute @ip, @port
-        raise
-      rescue RSMP::ConnectionError => e
-        log e, level: :error
-        break unless reconnect_delay?
-      rescue StandardError => e
-        distribute_error e, level: :internal
+        close_from_result(wait_for_reader)
         break unless reconnect_delay?
       ensure
+        close(reason: :internal_failure) if $ERROR_INFO
         close
-        stop_subtasks
       end
     end
 
     def connect
       log "Connecting to site #{@site_id} at #{@ip}:#{@port}", level: :info
+      begin_session
       self.state = :connecting
-      open_socket
+      opened = open_socket
+      return opened if opened.failure?
+
       self.state = :connected
       @logger.unmute @ip, @port
       log "Connected to site #{@site_id} at #{@ip}:#{@port}", level: :info
-    rescue SystemCallError => e
-      raise ConnectionError, "Could not connect to site #{@site_id} at #{@ip}:#{@port}: Errno #{e.errno} #{e}"
-    rescue StandardError => e
-      raise ConnectionError, "Error while connecting to site #{@site_id} at #{@ip}:#{@port}: #{e}"
+      Result.success(self)
     end
 
     def open_socket
@@ -64,6 +60,15 @@ module RSMP
       task.with_timeout(timeout) { @socket = endpoint.connect }
       @stream = IO::Stream::Buffered.new(@socket)
       @protocol = RSMP::Protocol.new(@stream)
+      Result.success(self)
+    rescue SystemCallError, SocketError, IOError, Async::TimeoutError => e
+      Result.failure(
+        :connection_failed,
+        message: "Could not connect to site #{@site_id} at #{@ip}:#{@port}: #{e.message}",
+        source: :transport,
+        context: { ip: @ip, port: @port, session_id: @session_id },
+        cause: e
+      )
     end
 
     def reconnect_delay?

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

@@ -3,23 +3,29 @@ module RSMP
     module Modules
       # Handles aggregated status requests and responses
       module AggregatedStatus
-        # Build and send an AggregatedStatusRequest. Returns { sent: message }.
+        # Build and send an AggregatedStatusRequest. Returns Result<AggregatedStatusRequest>.
         def request_aggregated_status(component, m_id: nil, validate: true)
-          validate_ready 'request aggregated status'
+          readiness = validate_ready 'request aggregated status'
+          return readiness if readiness.failure?
+
           m_id ||= RSMP::Message.make_m_id
           message = RSMP::AggregatedStatusRequest.new({
                                                         'cId' => component,
                                                         'mId' => m_id
                                                       })
           apply_nts_message_attributes message
-          send_message message, validate: validate
-          { sent: message }
+          send_message(message, validate: validate).map(&:message)
+        end
+
+        def request_aggregated_status!(...)
+          request_aggregated_status(...).value!
         end
 
-        # Build, send an AggregatedStatusRequest and collect the response. Returns the collector.
-        # Call .ok! on the result to raise on NotAck or timeout.
+        # Build, send an AggregatedStatusRequest and collect the response. Returns Result<Exchange>.
         def request_aggregated_status_and_collect(component, within:, m_id: nil, validate: true)
-          validate_ready 'request aggregated status'
+          readiness = validate_ready 'request aggregated status'
+          return readiness if readiness.failure?
+
           m_id ||= RSMP::Message.make_m_id
           message = RSMP::AggregatedStatusRequest.new({
                                                         'cId' => component,
@@ -27,7 +33,11 @@ module RSMP
                                                       })
           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)[:collector]
+          send_message_and_collect(message, collector, validate: validate)
+        end
+
+        def request_aggregated_status_and_collect!(...)
+          request_aggregated_status_and_collect(...).value!
         end
 
         def validate_aggregated_status(message, status_elements)

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

@@ -18,67 +18,74 @@ module RSMP
                                                   'cId' => component,
                                                   'aCId' => alarm_code
                                                 })
-          send_message message, validate: options[:validate]
-          message
+          send_message(message, validate: options[:validate]).map(&:message)
+        end
+
+        def send_alarm_acknowledgement!(...)
+          send_alarm_acknowledgement(...).value!
         end
 
         # Send an AlarmSuspend message and optionally collect the confirming response.
-        # When collect: true, returns [message, response]; when collect: false, returns message.
-        def suspend_alarm(task, c_id:, a_c_id:, collect: false)
+        # Returns Result<Exchange> when collecting and Result<AlarmSuspend> otherwise.
+        def suspend_alarm(c_id:, a_c_id:, collect: false)
           message = RSMP::AlarmSuspend.new(
             'mId' => RSMP::Message.make_m_id,
             'cId' => c_id,
             'aCId' => a_c_id
           )
           if collect
-            collect_task = task.async do
-              RSMP::AlarmCollector.new(self,
-                                       m_id: message.m_id,
-                                       num: 1,
-                                       matcher: {
-                                         'cId' => c_id,
-                                         'aCI' => a_c_id,
-                                         'aSp' => 'Suspend',
-                                         'sS' => /^Suspended/i
-                                       },
-                                       timeout: node.supervisor_settings.dig('default', 'timeouts', 'alarm')).collect!
-            end
-            send_message message
-            [message, collect_task.wait.first]
+            collector = RSMP::AlarmCollector.new(
+              self,
+              m_id: message.m_id,
+              num: 1,
+              matcher: {
+                'cId' => c_id,
+                'aCId' => a_c_id,
+                'aSp' => 'Suspend',
+                'sS' => /^Suspended/i
+              },
+              timeout: node.supervisor_settings.dig('default', 'timeouts', 'alarm')
+            )
+            send_message_and_collect(message, collector)
           else
-            send_message message
-            message
+            send_message(message).map(&:message)
           end
         end
 
+        def suspend_alarm!(...)
+          suspend_alarm(...).value!
+        end
+
         # Send an AlarmResume message and optionally collect the confirming response.
-        # When collect: true, returns [message, response]; when collect: false, returns message.
-        def resume_alarm(task, c_id:, a_c_id:, collect: false)
+        # Returns Result<Exchange> when collecting and Result<AlarmResume> otherwise.
+        def resume_alarm(c_id:, a_c_id:, collect: false)
           message = RSMP::AlarmResume.new(
             'mId' => RSMP::Message.make_m_id,
             'cId' => c_id,
             'aCId' => a_c_id
           )
           if collect
-            collect_task = task.async do
-              RSMP::AlarmCollector.new(self,
-                                       m_id: message.m_id,
-                                       num: 1,
-                                       matcher: {
-                                         'cId' => c_id,
-                                         'aCI' => a_c_id,
-                                         'aSp' => 'Suspend',
-                                         'sS' => /^notSuspended/i
-                                       },
-                                       timeout: node.supervisor_settings.dig('default', 'timeouts', 'alarm')).collect!
-            end
-            send_message message
-            [message, collect_task.wait.first]
+            collector = RSMP::AlarmCollector.new(
+              self,
+              m_id: message.m_id,
+              num: 1,
+              matcher: {
+                'cId' => c_id,
+                'aCId' => a_c_id,
+                'aSp' => 'Suspend',
+                'sS' => /^notSuspended/i
+              },
+              timeout: node.supervisor_settings.dig('default', 'timeouts', 'alarm')
+            )
+            send_message_and_collect(message, collector)
           else
-            send_message message
-            message
+            send_message(message).map(&:message)
           end
         end
+
+        def resume_alarm!(...)
+          resume_alarm(...).value!
+        end
       end
     end
   end

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

@@ -3,9 +3,11 @@ module RSMP
     module Modules
       # Handles command requests and responses
       module Commands
-        # Build and send a CommandRequest. Returns the CommandRequest message.
+        # Build and send a CommandRequest. Returns Result<CommandRequest>.
         def send_command(command_list, component: nil, validate: true)
-          validate_ready 'send command'
+          readiness = validate_ready 'send command'
+          return readiness if readiness.failure?
+
           component ||= main.c_id
           m_id = RSMP::Message.make_m_id
           message = RSMP::CommandRequest.new({
@@ -14,14 +16,18 @@ module RSMP
                                                'mId' => m_id
                                              })
           apply_nts_message_attributes message
-          send_message message, validate: validate
-          message
+          send_message(message, validate: validate).map(&:message)
+        end
+
+        def send_command!(...)
+          send_command(...).value!
         end
 
-        # Build, send a CommandRequest and collect the CommandResponse. Returns the collector.
-        # Raises on NotAck or timeout if ok! is called on the result.
+        # Build, send a CommandRequest and collect its responses. Returns Result<Exchange>.
         def send_command_and_collect(command_list, within:, component: nil, validate: true)
-          validate_ready 'send command'
+          readiness = validate_ready 'send command'
+          return readiness if readiness.failure?
+
           component ||= main.c_id
           m_id = RSMP::Message.make_m_id
           collector_list = command_collector_list(command_list)
@@ -32,7 +38,11 @@ module RSMP
                                              })
           apply_nts_message_attributes message
           collector = CommandResponseCollector.new(self, collector_list, timeout: within, initiator: message)
-          send_message_and_collect(message, collector, validate: validate)[:collector]
+          send_message_and_collect(message, collector, validate: validate)
+        end
+
+        def send_command_and_collect!(...)
+          send_command_and_collect(...).value!
         end
 
         def command_collector_list(command_list)

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

@@ -3,9 +3,11 @@ module RSMP
     module Modules
       # Handles status requests, responses, subscriptions and updates
       module Status
-        # Build and send a StatusRequest. Returns { sent: message }.
+        # Build and send a StatusRequest. Returns Result<StatusRequest>.
         def request_status(status_list, component: nil, m_id: nil, validate: true)
-          validate_ready 'request status'
+          readiness = validate_ready 'request status'
+          return readiness if readiness.failure?
+
           component ||= main.c_id
           m_id ||= RSMP::Message.make_m_id
 
@@ -21,14 +23,18 @@ module RSMP
                                               'mId' => m_id
                                             })
           apply_nts_message_attributes message
-          send_message message, validate: validate
-          { sent: message }
+          send_message(message, validate: validate).map(&:message)
+        end
+
+        def request_status!(...)
+          request_status(...).value!
         end
 
-        # Build, send a StatusRequest and collect the StatusResponse. Returns the collector.
-        # Call .ok! on the result to raise on NotAck or timeout.
+        # Build, send a StatusRequest and collect the StatusResponse. Returns Result<Exchange>.
         def request_status_and_collect(status_list, within:, component: nil, m_id: nil, validate: true)
-          validate_ready 'request status'
+          readiness = validate_ready 'request status'
+          return readiness if readiness.failure?
+
           component ||= main.c_id
           m_id ||= RSMP::Message.make_m_id
 
@@ -45,7 +51,11 @@ module RSMP
                                             })
           apply_nts_message_attributes message
           collector = StatusCollector.new(self, list.to_a, timeout: within, m_id: m_id)
-          send_message_and_collect(message, collector, validate: validate)[:collector]
+          send_message_and_collect(message, collector, validate: validate)
+        end
+
+        def request_status_and_collect!(...)
+          request_status_and_collect(...).value!
         end
 
         def process_status_response(message)
@@ -71,9 +81,11 @@ module RSMP
           end
         end
 
-        # Build and send a StatusSubscribe. Returns { sent: message }.
+        # Build and send a StatusSubscribe. Returns Result<StatusSubscribe>.
         def subscribe_to_status(status_list, component: nil, m_id: nil, validate: true)
-          validate_ready 'subscribe to status'
+          readiness = validate_ready 'subscribe to status'
+          return readiness if readiness.failure?
+
           component ||= main.c_id
           m_id ||= RSMP::Message.make_m_id
 
@@ -89,14 +101,18 @@ module RSMP
                                                 'mId' => m_id
                                               })
           apply_nts_message_attributes message
-          send_message message, validate: validate
-          { sent: message }
+          send_message(message, validate: validate).map(&:message)
         end
 
-        # Build, send a StatusSubscribe and collect the first matching status update. Returns the collector.
-        # Call .ok! on the result to raise on NotAck or timeout.
+        def subscribe_to_status!(...)
+          subscribe_to_status(...).value!
+        end
+
+        # Build, send a StatusSubscribe and collect the first matching status update. Returns Result<Exchange>.
         def subscribe_to_status_and_collect(status_list, within:, component: nil, m_id: nil, validate: true)
-          validate_ready 'subscribe to status'
+          readiness = validate_ready 'subscribe to status'
+          return readiness if readiness.failure?
+
           component ||= main.c_id
           m_id ||= RSMP::Message.make_m_id
 
@@ -113,7 +129,11 @@ module RSMP
                                               })
           apply_nts_message_attributes message
           collector = StatusCollector.new(self, list.to_a, timeout: within, m_id: m_id)
-          send_message_and_collect(message, collector, validate: validate)[:collector]
+          send_message_and_collect(message, collector, validate: validate)
+        end
+
+        def subscribe_to_status_and_collect!(...)
+          subscribe_to_status_and_collect(...).value!
         end
 
         def remove_subscription_item(component_id, code, name)
@@ -131,15 +151,20 @@ module RSMP
             remove_subscription_item(component, item['sCI'], item['n'])
           end
 
-          return unless ready? # if the connection is don't we skip sending
+          # Local subscription state must be cleaned up even when the peer has
+          # already disconnected. In that case there is nothing left to send.
+          return Result.success(nil) unless ready?
 
           message = RSMP::StatusUnsubscribe.new({
                                                   'cId' => component,
                                                   'sS' => status_list
                                                 })
           apply_nts_message_attributes message
-          send_message message, validate: validate
-          message
+          send_message(message, validate: validate).map(&:message)
+        end
+
+        def unsubscribe_to_status!(...)
+          unsubscribe_to_status(...).value!
         end
 
         # unsubscribes to all statuses (with all attributes) defined in the used SXL

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

@@ -56,10 +56,6 @@ module RSMP
       else
         super
       end
-    rescue RSMP::RepeatedAlarmError, RSMP::RepeatedStatusError, RSMP::TimestampError => e
-      str = "Rejected #{message.type} message,"
-      dont_acknowledge message, str, e.to_s
-      distribute_error e.exception("#{str}#{e.message} #{message.json}")
     end
 
     def handled_by_parent?(message)
@@ -115,7 +111,18 @@ module RSMP
     end
 
     def validate_ready(action)
-      raise NotReady, "Can't #{action} because connection is not ready. (Currently #{@state})" unless ready?
+      return Result.success(self) if ready?
+
+      Result.failure(
+        :not_ready,
+        message: "Can't #{action} because connection is not ready. (Currently #{@state})",
+        source: :connection,
+        context: { action: action, state: @state, session_id: session_id }
+      )
+    end
+
+    def validate_ready!(action)
+      validate_ready(action).value!
     end
 
     def version_acknowledged; end
@@ -204,11 +211,6 @@ module RSMP
       end
     end
 
-    def receive_error(error, options = {})
-      @supervisor&.receive_error error, options
-      distribute_error error, options
-    end
-
     def build_component(id:, type:, settings: {})
       settings ||= {}
       if type == 'main'

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

@@ -34,8 +34,13 @@ module RSMP
       configured = configured_sxls.find { |item| item['name'] == requested['name'] }
       return rejected_sxl(requested, 1, 'SXL not supported') unless configured
 
-      if configured['version'].to_s == requested['version'].to_s
-        RSMP::Schema.find_schema! requested['name'], requested['version'], lenient: true
+      unless RSMP::Schema.strict_version?(requested['version'])
+        return rejected_sxl(requested, 2, 'Core 3.3 requires SXL versions to use MAJOR.MINOR.PATCH')
+      end
+
+      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')
       else
         rejected_sxl(requested, 2, "Supervisor only supports #{configured['version']}")

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

@@ -29,7 +29,7 @@ module RSMP
                                                })
 
           apply_nts_message_attributes message
-          send_message message
+          send_generated_message message
         end
 
         def process_aggregated_status_request(message)

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

@@ -8,7 +8,7 @@ module RSMP
             component.alarms.each_pair do |_alarm_code, alarm_state|
               if alarm_state.active
                 alarm = AlarmIssue.new(alarm_state.to_hash.merge('aSp' => 'Issue'))
-                send_message alarm
+                send_generated_message alarm
               end
             end
           end

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

@@ -107,7 +107,7 @@ module RSMP
                                          })
           apply_nts_message_attributes response
           acknowledge message
-          send_message response
+          send_generated_message response
         end
       end
     end

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

@@ -88,7 +88,7 @@ module RSMP
           end
         end
 
-        def buffer_message(message, error = nil)
+        def buffer_message(message)
           prepared = prepare_message_for_buffer message, core_version: @core_version
           if prepared
             enqueue_buffered_message prepared
@@ -97,8 +97,6 @@ module RSMP
           else
             super
           end
-        rescue NotReady, IOError
-          raise error if error
         end
 
         def enqueue_buffered_message(message)
@@ -118,19 +116,20 @@ module RSMP
           @message_buffer = []
           log "Sending #{queued.size} buffered message(s)", level: :info
           queued.each_with_index do |message, index|
-            break unless flush_buffered_message(message, queued, index)
+            break unless flush_buffered_message?(message, queued, index)
           end
         end
 
-        def flush_buffered_message(message, queued, index)
+        def flush_buffered_message?(message, queued, index)
           prepared = prepare_message_for_buffer message, core_version: @core_version, for_send: true
           return true unless prepared
 
-          send_message prepared, 'from buffer', buffer: false
-          true
-        rescue NotReady, IOError
+          result = send_message(prepared, 'from buffer', buffer: false)
+          return true if result.success?
+
           @message_buffer = queued[index..] + @message_buffer
-          log "Stopped sending buffered messages; #{message_buffer.size} message(s) remain queued", level: :warning
+          log "Stopped sending buffered messages (#{result.failure.code}); " \
+              "#{message_buffer.size} message(s) remain queued", level: :warning
           false
         end
       end