rsmp 0.48.3 → 0.51.0

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/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

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

@@ -54,7 +54,7 @@ module RSMP
 
           apply_nts_message_attributes response
           acknowledge message
-          send_message response
+          send_generated_message response
         end
 
         def add_status_subscription(component_id, subs, update_list, arg, now)

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

@@ -138,7 +138,7 @@ module RSMP
                                       'sS' => build_status_list(component, by_code)
                                     })
           apply_nts_message_attributes update
-          send_message update
+          send_generated_message update
           store_last_sent_status update
           component.status_updates_sent
         end

data/lib/rsmp/proxy/supervisor/supervisor_proxy.rb

@@ -34,45 +34,39 @@ module RSMP
       end
 
       loop do
-        connect
+        connected = connect
+        unless connected.success?
+          publish_connection_attempt_failure(connected.failure)
+          break unless reconnect_delay?
+
+          next
+        end
         start_reader
         start_handshake
-        wait_for_reader # run until disconnected
-        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 run_accepted_connection
+      begin_session
       self.state = :connected
       start_reader
       start_handshake
-      wait_for_reader
-    rescue RSMP::ConnectionError => e
-      log e, level: :error
-    rescue StandardError => e
-      distribute_error e, level: :internal
+      close_from_result(wait_for_reader)
     ensure
+      close(reason: :internal_failure) if $ERROR_INFO
       close
-      stop_subtasks
     end
 
     def start_handshake
       send_version_request @site_settings['site_id'], core_versions
     end
 
-    def close
+    def close(...)
       prune_unbuffered_status_subscriptions
       super
     end
@@ -80,14 +74,15 @@ module RSMP
     # connect to the supervisor and initiate handshake supervisor
     def connect
       log "Connecting to supervisor at #{@ip}:#{@port}", level: :info
+      begin_session
       self.state = :connecting
-      connect_tcp
+      opened = connect_tcp
+      return opened if opened.failure?
+
+      self.state = :connected
       @logger.unmute @ip, @port
       log "Connected to supervisor at #{@ip}:#{@port}", level: :info
-    rescue SystemCallError => e
-      raise ConnectionError, "Could not connect to supervisor at #{@ip}:#{@port}: Errno #{e.errno} #{e}"
-    rescue StandardError => e
-      raise ConnectionError, "Error while connecting to supervisor at #{@ip}:#{@port}: #{e}"
+      Result.success(self)
     end
 
     def stop_task
@@ -108,10 +103,22 @@ module RSMP
 
       @stream = IO::Stream::Buffered.new(@socket)
       @protocol = RSMP::Protocol.new(@stream) # rsmp messages are json terminated with a form-feed
-      self.state = :connected
+      Result.success(self)
     rescue Errno::ECONNREFUSED => e # rescue to avoid log output
       log 'Connection refused', level: :warning
-      raise e
+      failed_connection_result(e)
+    rescue SystemCallError, SocketError, IOError, Async::TimeoutError => e
+      failed_connection_result(e)
+    end
+
+    def failed_connection_result(error)
+      Result.failure(
+        :connection_failed,
+        message: "Could not connect to supervisor at #{@ip}:#{@port}: #{error.message}",
+        source: :transport,
+        context: { ip: @ip, port: @port, session_id: @session_id },
+        cause: error
+      )
     end
 
     def handshake_complete
@@ -142,9 +149,6 @@ module RSMP
       else
         super
       end
-    rescue UnknownComponent, UnknownCommand, UnknownStatus,
-           MessageRejected, MissingAttribute => e
-      dont_acknowledge message, '', e.to_s
     end
 
     def handle_interface_request(message)
@@ -221,7 +225,7 @@ module RSMP
     end
 
     def send_component_list
-      send_message ComponentList.new('components' => @site.component_list)
+      send_generated_message ComponentList.new('components' => @site.component_list)
     end
 
     def component_list_acknowledged

data/lib/rsmp/result.rb

@@ -0,0 +1,95 @@
+module RSMP
+  # Result values represent the expected outcome of finite operations.
+  module Result
+    # A successfully completed operation.
+    Success = Data.define(:value) do
+      def success?
+        true
+      end
+
+      def failure?
+        false
+      end
+
+      def failure
+        nil
+      end
+
+      def value!
+        value
+      end
+
+      def map
+        Result.success(yield(value))
+      end
+
+      def and_then
+        yield(value)
+      end
+    end
+
+    # An expected operational failure.
+    Failure = Data.define(:failure) do
+      def initialize(failure:)
+        raise ArgumentError, 'failure must be an RSMP::Failure' unless failure.is_a?(RSMP::Failure)
+
+        super
+      end
+
+      def success?
+        false
+      end
+
+      def failure?
+        true
+      end
+
+      def value
+        nil
+      end
+
+      def value!
+        exception = OperationError.new(failure)
+        raise exception, cause: failure.cause if failure.cause
+
+        raise exception
+      end
+
+      def map
+        self
+      end
+
+      def and_then
+        self
+      end
+    end
+
+    module_function
+
+    def success(value = nil)
+      Success.new(value)
+    end
+
+    def failure(code = nil, failure: nil, **details)
+      Failure.new(
+        failure: failure || RSMP::Failure.new(
+          code: code,
+          message: details.fetch(:message, code),
+          source: details.fetch(:source, :operation),
+          context: details.fetch(:context, {}),
+          cause: details[:cause]
+        )
+      )
+    end
+  end
+
+  # Raised by bang APIs when an expected failure result is explicitly unwrapped.
+  class OperationError < Error
+    attr_reader :failure
+
+    def initialize(failure)
+      @failure = failure
+      super(failure.message)
+    end
+  end
+end

data/lib/rsmp/schema/validation.rb

@@ -41,6 +41,8 @@ module RSMP
     end
 
     # Core must pass. SXL-defined messages pass if at least one SXL schema passes.
+    # A message which does not satisfy its schemas is an ordinary validation
+    # outcome. Invalid API arguments and unavailable schemas still raise.
     def self.validate(message, schemas, options = {})
       raise ArgumentError, 'message missing' unless message
       raise ArgumentError, 'schemas missing' unless schemas
@@ -49,9 +51,9 @@ module RSMP
 
       errors = validate_core(message, schemas, options)
       errors.concat validate_sxls(message, schemas, options) if errors.empty?
-      return nil if errors.empty?
-
-      errors
+      Validation.new(violations: errors)
+    rescue UnknownMessageCodeError => e
+      Validation.new(violations: [['', 'unknown_message_code', e.message]])
     end
   end
 end

data/lib/rsmp/sxl/interface.rb

@@ -6,7 +6,14 @@ module RSMP
     class Interface
       extend Forwardable
 
-      def_delegators :proxy, :send_message, :send_message_and_collect, :validate_ready, :log
+      def_delegators :proxy,
+                     :send_message,
+                     :send_message!,
+                     :send_message_and_collect,
+                     :send_message_and_collect!,
+                     :validate_ready,
+                     :validate_ready!,
+                     :log
 
       attr_reader :proxy, :name, :version
 

data/lib/rsmp/sxl/processing/catalogue.rb

@@ -0,0 +1,61 @@
+module RSMP
+  module SXL
+    module Processing
+      # Indexes locally available SXL definitions by name and exact version.
+      class Catalogue
+        def initialize(paths = [])
+          @documents = Hash.new { |hash, key| hash[key] = {} }
+          Array(paths).each { |path| add_path(path) }
+        end
+
+        def add_path(path)
+          expanded_path = File.expand_path(path)
+          raise Error, "SXL source #{path} not found" unless File.exist?(expanded_path)
+
+          if File.directory?(expanded_path)
+            pattern = File.join(expanded_path, '**', '{sxl.yaml,sxl.yml}')
+            files = Dir.glob(pattern)
+            raise Error, "No sxl.yaml or sxl.yml files found under #{path}" if files.empty?
+
+            files.each { |file| add_file(file) }
+          else
+            add_file(expanded_path)
+          end
+          self
+        end
+
+        def add_document(document)
+          existing = @documents[document.name][document.version_string]
+          if existing && existing.path != document.path
+            raise Error,
+                  "Duplicate SXL #{document.name} #{document.version_string} in #{existing.path} and #{document.path}"
+          end
+
+          @documents[document.name][document.version_string] = document
+          document
+        end
+
+        def candidates(name, requirements = [])
+          versions = @documents.fetch(name, {}).values.sort_by(&:version).reverse
+          versions.select do |document|
+            requirements.all? { |requirement| requirement.satisfied_by?(document.version) }
+          end
+        end
+
+        def versions(name)
+          @documents.fetch(name, {}).values.map(&:version_string).sort_by { |version| Gem::Version.new(version) }
+        end
+
+        def fetch(name, version)
+          @documents.fetch(name, {})[version.to_s]
+        end
+
+        private
+
+        def add_file(path)
+          add_document(Document.load(path))
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/sxl/processing/conflict_checker.rb

@@ -0,0 +1,30 @@
+module RSMP
+  module SXL
+    module Processing
+      # Rejects component types or message codes owned by more than one SXL.
+      module ConflictChecker
+        def self.check!(documents)
+          check_definitions!(documents, :component_types, 'component type')
+          check_definitions!(documents, :message_codes, 'message code')
+        end
+
+        def self.check_definitions!(documents, collection, label)
+          owners = {}
+          documents.each do |document|
+            document.public_send(collection).each do |definition|
+              previous = owners[definition.id]
+              if previous
+                raise Error,
+                      "Conflicting #{label} #{definition.id.inspect} in " \
+                      "#{previous[:document].name} and #{document.name}"
+              end
+              owners[definition.id] = { document: document, definition: definition }
+            end
+          end
+        end
+
+        private_class_method :check_definitions!
+      end
+    end
+  end
+end

data/lib/rsmp/sxl/processing/dependency_graph.rb

@@ -0,0 +1,37 @@
+module RSMP
+  module SXL
+    module Processing
+      # Dependency graph validation shared by resolution and manifest verification.
+      module DependencyGraph
+        def self.cycle(documents)
+          by_name = documents.to_h { |document| [document.name, document] }
+          visited = {}
+          stack = []
+          by_name.each_key do |name|
+            found = visit(name, by_name, visited, stack)
+            return found if found
+          end
+          nil
+        end
+
+        def self.visit(name, documents, visited, stack)
+          return stack[stack.index(name)..] + [name] if stack.include?(name)
+          return nil if visited[name]
+
+          visited[name] = true
+          stack << name
+          documents.fetch(name).dependencies.each_key do |dependency|
+            next unless documents.key?(dependency)
+
+            found = visit(dependency, documents, visited, stack)
+            return found if found
+          end
+          stack.pop
+          nil
+        end
+
+        private_class_method :visit
+      end
+    end
+  end
+end