rsmp 0.48.4 → 0.51.1

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
+      send_version_request @site_settings['site_id'], advertised_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)
@@ -209,6 +213,7 @@ module RSMP
     def check_sxl_version(message)
       if core_3_3?
         @rejected_sxls, @accepted_sxls = message.sxls.partition { |item| item['rejected'] }
+        validate_sxl_response! @accepted_sxls
         @receive_alarms = message.attributes.fetch('receiveAlarms', true)
       else
         primary = primary_configured_sxl
@@ -221,7 +226,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/schema/version.rb

@@ -0,0 +1,27 @@
+module RSMP
+  # Provides JSON Schema validation for RSMP messages across core and SXL versions.
+  module Schema
+    STRICT_VERSION_PATTERN = /\A(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\z/
+    LEGACY_SHORT_VERSION_PATTERN = /\A(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\z/
+
+    # Return the schema version for a supported Core version string.
+    # Before Core 3.3, some releases used a two-part version on the wire.
+    # Only accept such a version when adding .0 identifies a known legacy
+    # schema unambiguously. Core 3.3 and later require all three parts.
+    def self.normalize_core_version(version)
+      return unless version.is_a?(String)
+      return version if core_versions.include? version
+      return unless LEGACY_SHORT_VERSION_PATTERN.match? version
+
+      normalized = "#{version}.0"
+      return unless core_versions.include? normalized
+      return unless Gem::Version.new(normalized) < Gem::Version.new('3.3.0')
+
+      normalized
+    end
+
+    def self.strict_version?(version)
+      version.is_a?(String) && STRICT_VERSION_PATTERN.match?(version)
+    end
+  end
+end

data/lib/rsmp/schema.rb

@@ -299,4 +299,5 @@ end
 
 require_relative 'schema/core_sxl_resolution'
 require_relative 'schema/message_resolution'
+require_relative 'schema/version'
 require_relative 'schema/validation'

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

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

@@ -0,0 +1,158 @@
+require 'psych'
+
+module RSMP
+  module SXL
+    module Processing
+      # A validated SXL YAML document with a normalized component structure.
+      class Document
+        NAME = %r{\A[a-z0-9][a-z0-9_/-]*\z}
+        PREFIX = %r{\A[a-zA-Z0-9_/-]+/\z}
+        MESSAGE_KINDS = %w[alarms statuses commands].freeze
+
+        SymbolDefinition = Struct.new(:id, :kind, :location, keyword_init: true)
+
+        attr_reader :path, :data, :name, :version, :version_string, :minimum_core_version,
+                    :dependencies, :component_types, :message_codes
+
+        def self.load(path)
+          expanded_path = File.expand_path(path)
+          raise Error, "SXL source #{path} not found" unless File.exist?(expanded_path)
+          raise Error, "SXL source #{path} is not a file" unless File.file?(expanded_path)
+
+          parse(File.read(expanded_path, encoding: 'UTF-8'), path: expanded_path)
+        rescue EncodingError => e
+          raise Error, "Cannot read SXL source #{path}: #{e.message}"
+        end
+
+        def self.parse(source, path: '(SXL source)')
+          data = Psych.safe_load(source, permitted_classes: [], permitted_symbols: [], aliases: false)
+          new(path: path, data: data)
+        rescue Psych::Exception => e
+          raise Error, "Cannot read SXL source #{path}: #{e.message}"
+        end
+
+        def self.validate_name!(value, label: 'SXL name')
+          return value if value.is_a?(String) && NAME.match?(value)
+
+          raise Error, "Invalid #{label} #{value.inspect}"
+        end
+
+        def initialize(path:, data:)
+          @path = path
+          @data = normalize_document(require_hash(data, 'document'))
+          read_metadata
+          read_dependencies
+          read_symbols
+        rescue Error => e
+          raise Error, "#{path}: #{e.message}"
+        end
+
+        private
+
+        def normalize_document(document)
+          components = component_definitions(document)
+          document.except('objects').merge('components' => components)
+        end
+
+        def component_definitions(document)
+          if document.key?('components') && document.key?('objects')
+            raise Error, 'Invalid document; use either components or objects, not both'
+          end
+
+          key = document.key?('components') ? 'components' : 'objects'
+          require_hash(document[key], key)
+        end
+
+        def read_metadata
+          meta = require_hash(data['meta'], 'meta')
+          @name = self.class.validate_name!(meta['name'])
+          @version_string = meta['version'].to_s
+          @version = VersionRequirement.exact_version(meta['version'], label: 'SXL version')
+          @minimum_core_version = read_minimum_core_version(meta)
+          @prefix = data['prefix']
+          validate_prefix!
+        end
+
+        def read_minimum_core_version(meta)
+          minimum = meta['minimum_core_version']
+          return unless minimum
+
+          VersionRequirement.exact_version(minimum, label: 'minimum Core version')
+        end
+
+        def validate_prefix!
+          return if @prefix.nil? || (@prefix.is_a?(String) && PREFIX.match?(@prefix))
+
+          raise Error, "Invalid SXL prefix #{@prefix.inspect}; it must end with /"
+        end
+
+        def read_dependencies
+          dependency_data = data['dependencies'] || {}
+          require_hash(dependency_data, 'dependencies')
+          @dependencies = dependency_data.to_h do |dependency_name, requirement|
+            self.class.validate_name!(dependency_name, label: 'dependency name')
+            unless requirement.is_a?(String)
+              raise Error, "Invalid requirement for #{dependency_name.inspect}; expected a string"
+            end
+
+            [dependency_name, VersionRequirement.new(requirement)]
+          end
+        end
+
+        def read_symbols
+          components = data['components']
+          @component_types = []
+          @message_codes = []
+          seen_components = {}
+          seen_messages = {}
+
+          components.each_pair do |component_id, component|
+            component_id = require_identifier(component_id, 'component type')
+            full_component_id = prefixed(component_id)
+            ensure_unique!(seen_components, full_component_id, 'component type')
+            @component_types << SymbolDefinition.new(id: full_component_id, kind: :component,
+                                                     location: component_id)
+            read_component_messages(component_id, component, seen_messages)
+          end
+        end
+
+        def read_component_messages(component_id, component, seen_messages)
+          component = require_hash(component, "component #{component_id.inspect}")
+          MESSAGE_KINDS.each do |kind|
+            messages = component[kind] || {}
+            require_hash(messages, "#{kind} for component #{component_id.inspect}")
+            messages.each_key do |code|
+              code = require_identifier(code, 'message code')
+              full_code = prefixed(code)
+              ensure_unique!(seen_messages, full_code, 'message code')
+              @message_codes << SymbolDefinition.new(id: full_code, kind: kind.delete_suffix('s').to_sym,
+                                                     location: "#{component_id}/#{kind}/#{code}")
+            end
+          end
+        end
+
+        def require_hash(value, label)
+          return value if value.is_a?(Hash)
+
+          raise Error, "Invalid #{label}; expected a mapping"
+        end
+
+        def require_identifier(value, label)
+          return value if value.is_a?(String) && !value.empty?
+
+          raise Error, "Invalid #{label} #{value.inspect}; expected a non-empty string"
+        end
+
+        def prefixed(identifier)
+          "#{@prefix}#{identifier}"
+        end
+
+        def ensure_unique!(seen, identifier, label)
+          raise Error, "Duplicate #{label} #{identifier.inspect}" if seen[identifier]
+
+          seen[identifier] = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module RSMP
+  module SXL
+    module Processing
+      # Base error for SXL dependency and manifest processing.
+      class Error < StandardError; end
+    end
+  end
+end