rsmp 0.48.4 → 0.51.1

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

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

@@ -8,13 +8,23 @@ module RSMP
           version = @site_settings['core_version']
           if version == 'latest'
             [RSMP::Schema.latest_core_version]
-          elsif version
-            [version]
-          else
+          elsif version.nil? || version == 'all'
             RSMP::Schema.core_versions
+          else
+            [RSMP::Schema.normalize_core_version(version)].compact
           end
         end
 
+        # Version strings to advertise before a Core version has been selected.
+        # Include known legacy spellings so peers using exact string matching
+        # can find a common pre-3.3 version.
+        def advertised_core_versions
+          versions = core_versions.flat_map { |version| wire_core_version_aliases(version) }
+          configured = @site_settings['core_version']
+          versions.unshift configured if RSMP::Schema.normalize_core_version(configured)
+          versions.uniq
+        end
+
         def core_3_3?
           core_version && version_meets_requirement?(core_version, '>=3.3.0')
         end
@@ -29,8 +39,9 @@ module RSMP
 
         def sxl_request_items
           configured_sxls.map do |sxl|
-            item = { 'name' => sxl['name'], 'version' => sxl['version'].to_s }
-            prefix = RSMP::Schema.sxl_prefix(sxl['name'], sxl['version'], lenient: true)
+            version = RSMP::Schema.sanitize_version(sxl['version'].to_s)
+            item = { 'name' => sxl['name'], 'version' => version }
+            prefix = RSMP::Schema.sxl_prefix(sxl['name'], version)
             item['prefix'] = prefix if prefix
             item
           end
@@ -38,10 +49,14 @@ module RSMP
 
         def check_core_version(message)
           versions = core_versions
-          # find versions that both we and the client support
-          candidates = message.versions & versions
+          candidates = message.versions.filter_map do |wire_version|
+            normalized = RSMP::Schema.normalize_core_version(wire_version)
+            [wire_version, normalized] if normalized && versions.include?(normalized)
+          end
           if candidates.any?
-            @core_version = candidates.max_by { |v| Gem::Version.new(v) } # pick latest version
+            @core_version_string, @core_version = candidates.max_by do |_wire_version, normalized|
+              Gem::Version.new(normalized)
+            end
           else
             reason = "RSMP versions [#{message.versions.join(', ')}] requested, " \
                      "but only [#{versions.join(', ')}] supported."
@@ -66,22 +81,33 @@ 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)
+            send_legacy_version_response(site_id, core_versions)
           end
         end
 
+        def send_legacy_version_response(site_id, core_versions)
+          response_versions = normalized_core_versions(core_versions).map do |version|
+            normalized = RSMP::Schema.normalize_core_version(version)
+            normalized == core_version ? core_version_string : version
+          end.uniq
+          attributes = version_message_attributes(site_id, response_versions)
+          primary = accepted_sxls.first
+          attributes['SXL'] = primary['version'].to_s if primary
+          send_message Version.new(attributes), validate: false
+        end
+
         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)
@@ -109,6 +135,15 @@ module RSMP
           end
         end
 
+        def wire_core_version_aliases(version)
+          normalized = RSMP::Schema.normalize_core_version(version)
+          return [version] unless normalized
+          return [normalized] if Gem::Version.new(normalized) >= Gem::Version.new('3.3.0')
+          return [normalized] unless normalized.end_with?('.0')
+
+          [normalized, normalized.delete_suffix('.0')]
+        end
+
         def site_id_items(site_id)
           [site_id].flatten.map { |id| { 'sId' => id } }
         end
@@ -124,13 +159,28 @@ module RSMP
           accepted_sxls + rejected_sxls
         end
 
+        def validate_sxl_response!(sxls)
+          invalid = sxls.find { |accepted| !valid_sxl_response?(accepted) }
+          return unless invalid
+
+          raise HandshakeError,
+                "Invalid SXL version #{invalid['name']} #{invalid['version']}; " \
+                'Core 3.3 requires an exact MAJOR.MINOR.PATCH match'
+        end
+
+        def valid_sxl_response?(accepted)
+          requested = sxl_request_items.find { |item| item['name'] == accepted['name'] }
+          RSMP::Schema.strict_version?(accepted['version']) && requested &&
+            requested['version'] == accepted['version']
+        end
+
         def version_acknowledged; end
 
         def component_list_acknowledged; end
 
         # 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)
           Gem::Requirement.new(requirement).satisfied_by?(Gem::Version.new(version))
         end

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)