rsmp 0.48.4 → 0.51.0

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

@@ -1,103 +1,129 @@
 module RSMP
   class Proxy
     module Modules
-      # Reader and timer task management
-      # Handles async tasks for reading from socket and running periodic timers
+      # Reader and timer tasks are siblings in one supervised session barrier.
       module Tasks
-        # run an async task that reads from @socket
+        def session_active?(id = @session_id)
+          id == @session_id && !@session_closed
+        end
+
+        def session_tasks
+          @session_tasks ||= Async::Barrier.new(parent: @task)
+        end
+
         def start_reader
-          @reader = @task.async do |task|
-            task.annotate 'reader'
-            run_reader
+          id = @session_id
+          @reader = session_tasks.async do |task|
+            task.annotate "reader session #{id}"
+            run_reader(id)
           end
         end
 
-        def run_reader
+        def run_reader(id)
           @stream ||= IO::Stream::Buffered.new(@socket)
-          @protocol ||= RSMP::Protocol.new(@stream) # rsmp messages are json terminated with a form-feed
-          loop do
-            read_line
+          @protocol ||= RSMP::Protocol.new(@stream)
+          while session_active?(id)
+            line = read_protocol_line
+            return line if line.failure?
+
+            process_received_line(line.value)
           end
-        rescue Restart
-          log 'Closing connection', level: :warning
-          raise
-        rescue EOFError, Async::Stop
-          log 'Connection closed', level: :warning
-        rescue IOError => e
-          log "IOError: #{e}", level: :debug
-        rescue Errno::ECONNRESET
-          log 'Connection reset by peer', level: :warning
-        rescue Errno::EPIPE
-          log 'Broken pipe', level: :warning
-        rescue StandardError => e
-          distribute_error e, level: :internal
+          Result.success(:closed)
         end
 
-        def read_line
+        def read_protocol_line
           json = @protocol.read_line
+          raise EOFError, 'Connection closed by peer' unless json
+
+          Result.success(json)
+        rescue EOFError => e
+          connection_read_failure(:peer_closed, 'Connection closed by peer', e)
+        rescue IOError, Errno::ECONNRESET, Errno::EPIPE => e
+          connection_read_failure(:transport_failure, e.message, e)
+        end
+
+        def connection_read_failure(reason, text, error)
+          log(text, level: :warning)
+          Result.failure(
+            :disconnected,
+            message: text,
+            source: reason == :peer_closed ? :peer : :transport,
+            context: { reason: reason, session_id: @session_id },
+            cause: error
+          )
+        end
+
+        # Wait for the reader while observing every sibling. A failed timer task
+        # raises here with its original exception and backtrace.
+        def wait_for_session
+          reader = @reader
+          observed = session_tasks.wait do |finished|
+            result = finished.wait
+            break result if finished.equal?(reader)
+            break result if result.is_a?(Result::Failure)
+            next if finished.cancelled? || !session_active?
+
+            raise "#{finished.annotation} ended while its connection session was active"
+          end
+          observed.is_a?(Result::Success) || observed.is_a?(Result::Failure) ? observed : Result.success(:closed)
+        ensure
+          @session_tasks.cancel if @session_tasks && !@session_tasks.empty?
+          @session_tasks = nil
+        end
+
+        def process_received_line(json)
           beginning = Time.now
-          message = process_packet json
+          result = process_packet(json)
+          log_processing_statistics(result, beginning)
+          result
+        end
+
+        def log_processing_statistics(result, beginning)
+          message = result.success? ? result.value : result.failure.context[:message]
           duration = Time.now - beginning
-          ms = (duration * 1000).round(4)
-          per_second = if duration.positive?
-                         (1.0 / duration).round
-                       else
-                         Float::INFINITY
-                       end
-          if message
-            type = message.type
-            m_id = Logger.shorten_message_id(message.m_id)
-          else
-            type = 'Unknown'
-            m_id = nil
-          end
-          str = [type, m_id, "processed in #{ms}ms, #{per_second}req/s"].compact.join(' ')
-          log str, level: :statistics
+          type = message.respond_to?(:type) ? message.type : 'Unknown'
+          m_id = message.respond_to?(:m_id) ? Logger.shorten_message_id(message.m_id) : nil
+          log([type, m_id, processing_speed(duration)].compact.join(' '), level: :statistics)
+        end
+
+        def processing_speed(duration)
+          milliseconds = (duration * 1000).round(4)
+          per_second = duration.positive? ? (1.0 / duration).round : Float::INFINITY
+          "processed in #{milliseconds}ms, #{per_second}req/s"
         end
 
         def start_timer
-          return if @timer
+          return if @timer&.running?
 
-          name = 'timer'
+          id = @session_id
           interval = @site_settings['intervals']['timer'] || 1
-          log "Starting #{name} with interval #{interval} seconds", level: :debug
+          log "Starting timer with interval #{interval} seconds", level: :debug
           @latest_watchdog_received = Clock.now
-          @timer = @task.async do |task|
-            task.annotate 'timer'
-            run_timer task, interval
+          @timer = session_tasks.async do |task|
+            task.annotate "timer session #{id}"
+            run_timer(task, interval, id)
           end
         end
 
-        def run_timer(task, interval)
+        def run_timer(task, interval, id)
           next_time = Time.now.to_f
-          loop do
-            begin
-              now = Clock.now
-              timer(now)
-            rescue RSMP::Schema::Error => e
-              log "Timer: Schema error: #{e}", level: :warning
-            rescue EOFError => e
-              log "Timer: Connection closed: #{e}", level: :warning
-            rescue IOError
-              log 'Timer: IOError', level: :warning
-            rescue Errno::ECONNRESET
-              log 'Timer: Connection reset by peer', level: :warning
-            rescue Errno::EPIPE
-              log 'Timer: Broken pipe', level: :warning
-            rescue StandardError => e
-              distribute_error e, level: :internal
-            end
-          ensure
+          while session_active?(id)
+            result = timer(Clock.now)
+            return result if result.failure?
+
             next_time += interval
-            duration = next_time - Time.now.to_f
-            task.sleep duration
+            task.sleep([next_time - Time.now.to_f, 0].max) if session_active?(id)
           end
+          Result.success(:closed)
         end
 
         def timer(now)
-          watchdog_send_timer now
-          check_ack_timeout now
-          check_watchdog_timeout now
+          watchdog_send_timer(now)
+          acknowledgement = check_ack_timeout(now)
+          return acknowledgement if acknowledgement.failure?
+
+          check_watchdog_timeout(now)
+          Result.success
         end
       end
     end

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

@@ -66,13 +66,13 @@ module RSMP
 
         def send_version_response(site_id, core_versions)
           if core_3_3?
-            send_message Version.new({
-                                       'step' => 'Response',
-                                       'RSMP' => [{ 'vers' => core_version }],
-                                       'supervisorId' => site_id,
-                                       'SXLS' => version_response_sxls,
-                                       'receiveAlarms' => @site_settings['receive_alarms'] != false
-                                     }), validate: false
+            send_generated_message Version.new({
+                                                 'step' => 'Response',
+                                                 'RSMP' => [{ 'vers' => core_version }],
+                                                 'supervisorId' => site_id,
+                                                 'SXLS' => version_response_sxls,
+                                                 'receiveAlarms' => @site_settings['receive_alarms'] != false
+                                               }), validate: false
           else
             send_version_message(site_id, core_versions, step: nil)
           end
@@ -81,7 +81,7 @@ 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'
-          send_message Version.new(attributes), validate: false
+          send_generated_message Version.new(attributes), validate: false
         end
 
         def version_message_attributes(site_id, core_versions)

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

@@ -40,7 +40,7 @@ module RSMP
 
         def send_watchdog(now = Clock.now)
           message = RSMP::Watchdog.new({ 'wTs' => clock.to_s })
-          send_message message
+          send_generated_message message
           @latest_watchdog_send_at = now
         end
 
@@ -52,7 +52,20 @@ module RSMP
 
           str = "No Watchdog received within #{timeout} seconds"
           log str, level: :warning
-          distribute MissingWatchdog.new(str)
+          failure = Failure.new(
+            code: :missing_watchdog,
+            message: str,
+            source: :peer,
+            context: { session_id: session_id }
+          )
+          distribute_event(
+            Event.new(
+              type: :missing_watchdog,
+              source: self,
+              session_id: session_id,
+              failure: failure
+            )
+          )
         end
 
         def process_watchdog(message)

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
+                :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

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)