rsmp 0.48.4 → 0.51.0

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

@@ -5,16 +5,16 @@ module RSMP
       # Manages sending/receiving acks and nacks, and tracking acknowledged messages
       module Acknowledgements
         def acknowledge(original)
-          raise InvalidArgument unless original
+          raise ArgumentError, 'original message is required' unless original
 
           ack = MessageAck.build_from(original)
           ack.original = original.clone
-          send_message ack, "for #{ack.original.type} #{original.m_id_short}"
+          send_generated_message ack, "for #{ack.original.type} #{original.m_id_short}"
           check_ingoing_acknowledged original
         end
 
         def dont_acknowledge(original, prefix = nil, reason = nil, force: true)
-          raise InvalidArgument unless original
+          raise ArgumentError, 'original message is required' unless original
 
           str = [prefix, reason].join(' ')
           log str, message: original, level: :warning if reason
@@ -23,7 +23,7 @@ module RSMP
                                         'rea' => reason || 'Unknown reason'
                                       })
           message.original = original.clone
-          send_message message, "for #{original.type} #{original.m_id_short}", force: force
+          send_generated_message message, "for #{original.type} #{original.m_id_short}", force: force
         end
 
         def expect_acknowledgement(message)
@@ -45,12 +45,25 @@ module RSMP
 
             str = "No acknowledgements for #{message.type} #{message.m_id_short} within #{timeout} seconds"
             log str, level: :error
-            begin
-              close
-            ensure
-              distribute_error MissingAcknowledgment.new(str)
-            end
+            failure = Failure.new(
+              code: :missing_acknowledgement,
+              message: str,
+              source: :peer,
+              context: { message: message, reason: :missing_acknowledgement, session_id: session_id }
+            )
+            distribute_event(
+              Event.new(
+                type: :missing_acknowledgement,
+                source: self,
+                session_id: session_id,
+                message: message,
+                failure: failure
+              )
+            )
+            return Result.failure(failure: failure)
           end
+
+          Result.success
         end
 
         def find_original_for_message(message)

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

@@ -0,0 +1,134 @@
+module RSMP
+  class Proxy
+    module Modules
+      # Owns one connection session and translates expected termination into
+      # lifecycle events without swallowing unexpected task exceptions.
+      module Lifecycle
+        def disconnect
+          close(reason: :local_stop)
+          Result.success(self)
+        end
+
+        def disconnect!
+          disconnect.value!
+        end
+
+        def connect!
+          connect.value!
+        end
+
+        def wait_for_reader
+          wait_for_session
+        end
+
+        def begin_session
+          clear
+          @session_id += 1
+          @session_closed = false
+          @session_id
+        end
+
+        def close(reason: :peer_closed, failure: nil, session_id: @session_id)
+          return if session_id != @session_id || @session_closed
+
+          @session_closed = true
+          log 'Closing connection', level: :warning
+          close_stream
+          close_socket
+          stop_reader
+          self.state = :disconnected
+          publish_connection_end(reason, failure, session_id)
+          stop_timer
+        end
+
+        def stop_subtasks
+          stop_timer
+          stop_reader
+          clear
+          super
+        end
+
+        def stop_timer
+          current = Async::Task.current?
+          @timer&.cancel unless @timer.equal?(current)
+        ensure
+          @timer = nil
+        end
+
+        def stop_reader
+          current = Async::Task.current?
+          @reader&.cancel unless @reader.equal?(current)
+        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(reason: :local_stop)
+          super
+        end
+
+        def distribute_event(event)
+          super
+          @node&.publish_event(event)
+          event
+        end
+
+        def connection_end_failure(reason)
+          local = reason == :local_stop
+          Failure.new(
+            code: local ? :cancelled : :disconnected,
+            message: "Connection ended (#{reason})",
+            source: local ? :local : :connection,
+            context: { reason: reason, session_id: @session_id }
+          )
+        end
+
+        def close_from_result(result)
+          return close(reason: :peer_closed) if result.nil? || result.success?
+
+          reason = result.failure.context[:reason] || :transport_failure
+          close(reason: reason, failure: result.failure)
+        end
+
+        def publish_connection_attempt_failure(failure)
+          log failure.message, level: :warning
+          distribute_event(
+            Event.new(
+              type: :connection_attempt_failed,
+              source: self,
+              session_id: @session_id,
+              failure: failure
+            )
+          )
+        end
+
+        private
+
+        def publish_connection_end(reason, failure, session_id)
+          failure ||= connection_end_failure(reason)
+          distribute_event(
+            Event.new(
+              type: :connection_ended,
+              source: self,
+              session_id: session_id,
+              failure: failure,
+              context: { reason: reason }
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -1,12 +1,11 @@
 module RSMP
   class Proxy
     module Modules
-      # Message processing functionality
-      # Handles receiving and processing incoming messages
+      # Message processing functionality. Peer-controlled invalid input is
+      # represented by Result::Failure; unexpected implementation errors escape.
       module Receive
         def should_validate_ingoing_message?(message)
           return false if message.is_a?(Version) && !@version_determined
-
           return true unless @site_settings
 
           skip = @site_settings['skip_validation']
@@ -24,93 +23,137 @@ module RSMP
           expect_version_message(message) unless @version_determined
         end
 
-        def handle_invalid_packet(json, error)
-          str = "Received invalid package, must be valid JSON but got #{json.size} bytes: #{error.message}"
-          distribute_error error.exception(str)
-          log str, level: :warning
-          nil
+        def process_packet(json)
+          attributes = Message.parse_attributes(json)
+          message = Message.build(attributes, json)
+          process_incoming_message(message)
+        rescue InvalidPacket => e
+          reject_invalid_packet(json, e)
+        rescue MalformedMessage => e
+          reject_malformed_packet(json, attributes, e)
+        rescue PeerMessageError => e
+          reject_processed_message(message, e)
+        rescue HandshakeError, FatalError => e
+          reject_fatal_message(message, e)
+        ensure
+          @node&.clear_deferred
         end
 
-        def handle_malformed_message(attributes, error)
-          str = "Received malformed message, #{error.message}"
-          distribute_error error.exception(str)
-          log str, message: Malformed.new(attributes), level: :warning
-          nil
+        def process_incoming_message(message)
+          validate = should_validate_ingoing_message?(message)
+          if validate
+            validation = message.validate(schemas)
+            return reject_invalid_message(message, validation) if validation.invalid?
+          end
+
+          verify_sequence(message)
+          message.decode_for(schemas) if validate
+          with_deferred_distribution do
+            distribute(message)
+            process_message(message)
+          end
+          process_deferred
+          Result.success(message)
         end
 
-        def handle_schema_error(message, error)
-          failed_schemas = error.respond_to?(:schemas) && error.schemas ? error.schemas : schemas
-          schemas_string = failed_schemas.map { |schema| "#{schema.first}: #{schema.last}" }.join(', ')
-          reason = "schema errors (#{schemas_string}): #{error.message}"
-          str = "Received invalid #{message.type}"
-          distribute_error error.exception(str), message: message
-          dont_acknowledge message, str, reason
-          message
+        def reject_invalid_packet(json, error)
+          reject_packet(
+            :invalid_packet,
+            "Received invalid packet, expected JSON but got #{json.size} bytes: #{error.message}",
+            raw: json
+          )
         end
 
-        def handle_invalid_message(message, error)
-          reason = error.message.to_s
-          str = "Received invalid #{message.type},"
-          distribute_error error.exception("#{str} #{message.json}"), message: message
-          dont_acknowledge message, str, reason
-          message
+        def reject_malformed_packet(json, attributes, error)
+          reject_packet(
+            :malformed_message,
+            "Received malformed message: #{error.message}",
+            raw: json,
+            message: Malformed.new(attributes || {})
+          )
         end
 
-        def handle_fatal_error(message, error)
-          reason = error.message
-          str = "Rejected #{message.type},"
-          distribute_error error.exception(str), message: message
-          dont_acknowledge message, str, reason
-          close
-          message
+        def reject_invalid_message(message, validation)
+          schemas_string = schemas.map { |schema| "#{schema.first}: #{schema.last}" }.join(', ')
+          reason = "schema errors (#{schemas_string}): #{validation.message}"
+          text = "Received invalid #{message.type}"
+          failure = peer_failure(
+            :invalid_peer_message,
+            "#{text}: #{validation.message}",
+            message: message,
+            validation: validation
+          )
+          publish_peer_failure(failure, message: message)
+          log(text, message: message, level: :warning)
+          dont_acknowledge(message, text, reason)
+          Result.failure(failure: failure)
         end
 
-        def process_packet(json)
-          attributes = Message.parse_attributes json
-          message = Message.build attributes, json
-          validate = should_validate_ingoing_message?(message)
-          message.validate(schemas) if validate
-          verify_sequence message
-          message.decode_for(schemas) if validate
-          with_deferred_distribution do
-            distribute message
-            process_message message
-          end
-          process_deferred
-          message
-        rescue InvalidPacket => e
-          handle_invalid_packet(json, e)
-        rescue MalformedMessage => e
-          handle_malformed_message(attributes, e)
-        rescue SchemaError, RSMP::Schema::Error => e
-          handle_schema_error(message, e)
-        rescue InvalidMessage, MessageRejected => e
-          handle_invalid_message(message, e)
-        rescue FatalError => e
-          handle_fatal_error(message, e)
-        ensure
-          @node.clear_deferred
+        def reject_packet(code, text, raw:, message: nil)
+          failure = peer_failure(code, text, message: message, raw: raw)
+          publish_peer_failure(failure, message: message)
+          log(text, message: message, level: :warning)
+          Result.failure(failure: failure)
+        end
+
+        def reject_processed_message(message, error)
+          code = error.is_a?(MessageRejected) ? :message_rejected : :invalid_peer_message
+          text = "Received invalid #{message.type}: #{error.message}"
+          failure = peer_failure(code, text, message: message)
+          publish_peer_failure(failure, message: message)
+          dont_acknowledge(message, "Received invalid #{message.type}", error.message.to_s)
+          Result.failure(failure: failure)
+        end
+
+        def reject_fatal_message(message, error)
+          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
+          close(reason: :protocol_failure, failure: failure)
+          Result.failure(failure: failure)
+        end
+
+        def peer_failure(code, text, message: nil, **context)
+          Failure.new(
+            code: code,
+            message: text,
+            source: :peer,
+            context: context.merge(message: message).compact
+          )
+        end
+
+        def publish_peer_failure(failure, message:)
+          distribute_event(
+            Event.new(
+              type: :invalid_message,
+              source: self,
+              session_id: session_id,
+              message: message,
+              failure: failure
+            )
+          )
         end
 
         def process_message(message)
           case message
           when MessageAck
-            process_ack message
+            process_ack(message)
           when MessageNotAck
-            process_not_ack message
+            process_not_ack(message)
           when Version
-            process_version message
+            process_version(message)
           when RSMP::Watchdog
-            process_watchdog message
+            process_watchdog(message)
           else
-            dont_acknowledge message, 'Received', "unknown message (#{message.type})"
+            dont_acknowledge(message, 'Received', "unknown message (#{message.type})")
           end
         end
 
         def will_not_handle(message)
-          reason ||= "since we're a #{self.class.name.downcase}"
+          reason = "since we're a #{self.class.name.downcase}"
           log "Ignoring #{message.type}, #{reason}", message: message, level: :warning
-          dont_acknowledge message, nil, reason
+          dont_acknowledge(message, nil, reason)
         end
 
         def expect_version_message(message)

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

@@ -1,79 +1,137 @@
 module RSMP
   class Proxy
     module Modules
-      # Message sending functionality
-      # Handles sending messages, validation, and buffering
+      # Message sending functionality. Expected operational failures are returned
+      # as Result::Failure; unexpected implementation errors are not rescued.
       module Send
-        def handle_send_schema_error(message, error)
-          schemas_string = error.schemas.map { |schema| "#{schema.first}: #{schema.last}" }.join(', ')
-          str = "Could not send #{message.type} because schema validation failed (#{schemas_string}): #{error.message}"
-          log str, message: message, level: :error
-          distribute_error error.exception("#{str} #{message.json}")
-        end
-
         def send_message(message, reason = nil, validate: true, force: false, buffer: true)
-          with_send_ready(message, force: force, buffer: buffer) do
-            write_message(message, validate: validate)
-            expect_acknowledgement message
-            distribute message
-            log_send message, reason
-          end
-        rescue NotReady, IOError => e
-          raise e unless buffer
+          return buffer_or_fail(message, buffer: buffer) unless force || connected?
 
-          buffer_message message, e
-        rescue SchemaError, RSMP::Schema::Error => e
-          handle_send_schema_error(message, e)
-        end
+          written = write_message(message, validate: validate)
+          return recover_write_failure(message, written, buffer: buffer) if written.failure?
 
-        def with_send_ready(message, force:, buffer:)
-          return yield if force || connected?
+          expect_acknowledgement(message)
+          distribute(message)
+          log_send(message, reason)
+          Result.success(Delivery.new(message: message, state: :sent))
+        end
 
-          error = NotReady.new
-          raise error unless buffer
+        def send_message!(...)
+          send_message(...).value!
+        end
 
-          buffer_message(message, error)
+        # Messages constructed by RSMP itself should never fail local schema
+        # validation. Surface that as an implementation defect while preserving
+        # connection and transport failures as ordinary Result values.
+        def send_generated_message(...)
+          result = send_message(...)
+          result.value! if result.failure&.source == :local
+          result
         end
 
         def write_message(message, validate:)
-          raise IOError unless @protocol
+          return disconnected_send_result(message) unless @protocol
+
+          prepared = prepare_message(message, validate: validate)
+          return prepared if prepared.failure?
 
+          write_protocol(message)
+        end
+
+        def prepare_message(message, validate:)
           message.direction = :out
           message.encode_for(schemas) unless validate == false
           message.generate_json
-          message.validate schemas unless validate == false
-          @protocol.write_lines message.json
+          unless validate == false
+            validation = message.validate(schemas)
+            return invalid_outbound_result(message, validation.message, validation: validation) if validation.invalid?
+          end
+          Result.success(message)
+        rescue RSMP::Schema::UnknownMessageCodeError => e
+          invalid_outbound_result(message, e.message, cause: e)
+        end
+
+        def write_protocol(message)
+          @protocol.write_lines(message.json)
+          Result.success(message)
+        rescue IOError, SystemCallError => e
+          Result.failure(
+            :disconnected,
+            message: "Could not send #{message.type}: #{e.message}",
+            source: :transport,
+            context: { message: message, session_id: session_id },
+            cause: e
+          )
+        end
+
+        def recover_write_failure(message, result, buffer:)
+          return result unless result.failure.code == :disconnected
+
+          buffered = buffer_message(message) if buffer
+          return Result.success(Delivery.new(message: buffered, state: :buffered)) if buffered
+
+          result
         end
 
-        def buffer_message(message, error = nil)
-          str = "Cannot send #{message.type} because the connection is closed."
-          log str, message: message, level: :error
-          raise error if error
+        def buffer_or_fail(message, buffer:)
+          buffered = buffer_message(message) if buffer
+          return Result.success(Delivery.new(message: buffered, state: :buffered)) if buffered
+
+          Result.failure(
+            :not_ready,
+            message: "Cannot send #{message.type}: connection is #{@state}",
+            source: :connection,
+            context: { message: message, state: @state, session_id: session_id }
+          )
+        end
+
+        # Base proxies do not buffer. SupervisorProxy's MessageBuffer override
+        # returns a cloned queued message when its explicit policy accepts it.
+        def buffer_message(message)
+          log "Discarded #{message.type}; connection is #{@state}", message: message, level: :warning
+          nil
+        end
+
+        def disconnected_send_result(message)
+          Result.failure(
+            :disconnected,
+            message: "Cannot send #{message.type}: connection transport is closed",
+            source: :transport,
+            context: { message: message, session_id: session_id }
+          )
+        end
+
+        def invalid_outbound_result(message, detail, validation: nil, cause: nil)
+          text = "Could not send #{message.type}: #{detail}"
+          log(text, message: message, level: :error)
+          Result.failure(
+            :invalid_outbound_message,
+            message: text,
+            source: :local,
+            context: { message: message, validation: validation }.compact,
+            cause: cause
+          )
         end
 
         def log_send(message, reason = nil)
-          str = if reason
-                  "Sent #{message.type} #{reason}"
-                else
-                  "Sent #{message.type}"
-                end
-
-          if message.type == 'MessageNotAck'
-            log str, message: message, level: :warning
-          else
-            log str, message: message, level: :log
-          end
+          text = reason ? "Sent #{message.type} #{reason}" : "Sent #{message.type}"
+          level = message.type == 'MessageNotAck' ? :warning : :log
+          log(text, message: message, level: level)
         end
 
         def send_message_and_collect(message, collector, validate: true)
-          task = @task.async do |t|
-            t.annotate 'send_message_and_collect'
-            collector.collect
-            collector
+          collector.start
+          delivery = send_message(message, validate: validate, buffer: false)
+          collector.fail(delivery.failure) if delivery.failure?
+          collector.wait.map do |collection|
+            Exchange.new(request: message, collection: collection)
           end
-          send_message message, validate: validate
-          collector = task.wait
-          { sent: message, collector: collector }
+        ensure
+          collector.stop
+        end
+
+        def send_message_and_collect!(...)
+          send_message_and_collect(...).value!
         end
 
         def apply_nts_message_attributes(message)

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

@@ -6,14 +6,24 @@ module RSMP
       module State
         def wait_for_state(state, timeout:)
           states = [state].flatten
-          return true if states.include?(@state)
+          return Result.success(@state) if states.include?(@state)
 
-          wait_for_condition(@state_condition, timeout: timeout) do
+          result = wait_for_condition(@state_condition, timeout: timeout) do
             states.include?(@state)
           end
-          true
-        rescue RSMP::TimeoutError
-          raise RSMP::TimeoutError, "Did not reach state #{state} within #{timeout}s"
+          return Result.success(@state) if result.success?
+
+          Result.failure(
+            :timeout,
+            message: "Did not reach state #{state} within #{timeout}s",
+            source: :timeout,
+            context: { expected: states, actual: @state },
+            cause: result.failure.cause
+          )
+        end
+
+        def wait_for_state!(...)
+          wait_for_state(...).value!
         end
 
         def handshake_complete