rsmp 0.47.0 → 0.48.0

data/lib/rsmp/convert/export/json_schema/index.rb

@@ -0,0 +1,64 @@
+module RSMP
+  module Convert
+    module Export
+      # Converts SXL definitions to JSON Schema files.
+      module JSONSchema
+        def self.output_sxl_index(out, sxl)
+          out['sxl_index.json'] = output_json({
+                                                'meta' => sxl[:meta],
+                                                'statuses' => index_items(sxl[:statuses]),
+                                                'commands' => index_items(sxl[:commands]),
+                                                'alarms' => index_items(sxl[:alarms])
+                                              })
+        end
+
+        def self.index_items(items)
+          items.keys.sort.to_h do |key|
+            [key, index_item(items[key])]
+          end
+        end
+
+        def self.index_item(item)
+          arguments = item['arguments'] || {}
+          entry = {}
+          required = typed_arguments(arguments.reject { |_name, argument| argument['optional'] == true })
+          optional = typed_arguments(arguments.select { |_name, argument| argument['optional'] == true })
+          entry['required'] = required unless required.empty?
+          entry['optional'] = optional unless optional.empty?
+          entry
+        end
+
+        def self.typed_arguments(arguments)
+          arguments.keys.sort.to_h do |name|
+            [name, argument_type_descriptor(arguments[name])]
+          end
+        end
+
+        def self.argument_type_descriptor(argument)
+          type = argument['type']
+          case type
+          when 'array'
+            argument_array_descriptor(argument)
+          when 'object'
+            argument_object_descriptor(argument)
+          else
+            type
+          end
+        end
+
+        def self.argument_array_descriptor(argument)
+          descriptor = { 'type' => argument['type'] }
+          descriptor['items'] = typed_arguments(argument['items']) if argument['items'].is_a?(Hash)
+          descriptor
+        end
+
+        def self.argument_object_descriptor(argument)
+          descriptor = { 'type' => argument['type'] }
+          properties = argument['properties'] || argument['items']
+          descriptor['properties'] = typed_arguments(properties) if properties.is_a?(Hash)
+          descriptor
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/convert/export/json_schema/items.rb

@@ -42,12 +42,20 @@ module RSMP
               'then' => { 'properties' => { property_key => build_value(argument) } }
             }
           end
-          {
+          schema = {
             '$schema' => 'https://json-schema.org/draft/2020-12/schema',
             'description' => item['description'],
             'properties' => { 'n' => { 'enum' => arguments.keys.sort } },
             'allOf' => rules
           }
+          return schema unless property_key == 'v'
+
+          schema.delete 'allOf'
+          schema.merge(
+            'if' => { '$ref' => '../defs/guards.json#/$defs/age_unknown_or_undefined' },
+            'then' => {},
+            'else' => { 'allOf' => rules }
+          )
         end
       end
     end

data/lib/rsmp/convert/export/json_schema/outputs.rb

@@ -11,6 +11,12 @@ module RSMP
                 { 'required' => ['q'] },
                 { 'properties' => { 'q' => { 'enum' => %w[undefined unknown] } } }
               ]
+            },
+            'age_unknown_or_undefined' => {
+              'allOf' => [
+                { 'required' => ['age'] },
+                { 'properties' => { 'age' => { 'enum' => %w[undefined unknown] } } }
+              ]
             }
           }
         }.freeze
@@ -67,6 +73,15 @@ module RSMP
 
         # convert commands to json schema
         def self.output_commands(out, items)
+          out['defs/guards.json'] ||= output_json(GUARDS_JSON)
+          out['commands/commands.json'] = output_json commands_schema(items)
+          out['commands/command_requests.json'] = output_json command_requests_schema(items)
+          out['commands/command_responses.json'] = output_json command_responses_schema
+
+          items.each_pair { |key, item| output_command out, key, item }
+        end
+
+        def self.commands_schema(items)
           list = [{ 'properties' => { 'cCI' => { 'enum' => items.keys.sort } } }]
           items.keys.sort.each do |key|
             list << {
@@ -74,25 +89,67 @@ module RSMP
               'then' => { '$ref' => "#{key}.json" }
             }
           end
-          json = {
+          {
             '$schema' => 'https://json-schema.org/draft/2020-12/schema',
             'items' => { 'allOf' => list }
           }
-          out['commands/commands.json'] = output_json json
+        end
 
-          json = {
+        def self.command_requests_schema(items)
+          {
             '$schema' => 'https://json-schema.org/draft/2020-12/schema',
-            'properties' => { 'arg' => { '$ref' => 'commands.json' } }
+            'properties' => { 'arg' => command_request_arg_schema(items) }
           }
-          out['commands/command_requests.json'] = output_json json
+        end
 
-          json = {
+        def self.command_responses_schema
+          {
             '$schema' => 'https://json-schema.org/draft/2020-12/schema',
             'properties' => { 'rvs' => { '$ref' => 'commands.json' } }
           }
-          out['commands/command_responses.json'] = output_json json
+        end
 
-          items.each_pair { |key, item| output_command out, key, item }
+        def self.command_request_arg_schema(items)
+          schema = { '$ref' => 'commands.json' }
+          required_rules = command_required_argument_rules(items)
+          return schema if required_rules.empty?
+
+          { 'allOf' => [schema] + required_rules }
+        end
+
+        def self.command_required_argument_rules(items)
+          items.keys.sort.filter_map do |key|
+            required = required_argument_names(items[key])
+            next if required.empty?
+
+            {
+              'if' => {
+                'contains' => {
+                  'required' => ['cCI'],
+                  'properties' => { 'cCI' => { 'const' => key } }
+                }
+              },
+              'then' => {
+                'allOf' => required.map { |name| command_argument_contains_rule(key, name) }
+              }
+            }
+          end
+        end
+
+        def self.command_argument_contains_rule(command_code, name)
+          {
+            'contains' => {
+              'required' => %w[cCI n],
+              'properties' => {
+                'cCI' => { 'const' => command_code },
+                'n' => { 'const' => name }
+              }
+            }
+          }
+        end
+
+        def self.required_argument_names(item)
+          (item['arguments'] || {}).reject { |_name, argument| argument['optional'] == true }.keys.sort
         end
 
         # convert a command to json schema
@@ -103,23 +160,6 @@ module RSMP
           out["commands/#{key}.json"] = output_json json
         end
 
-        def self.output_sxl_index(out, sxl)
-          out['sxl_index.json'] = output_json({
-                                                'meta' => sxl[:meta],
-                                                'statuses' => index_items(sxl[:statuses]),
-                                                'commands' => index_items(sxl[:commands]),
-                                                'alarms' => index_items(sxl[:alarms])
-                                              })
-        end
-
-        def self.index_items(items)
-          items.keys.sort.to_h do |key|
-            [key, {
-              'arguments' => (items[key]['arguments'] || {}).keys.sort
-            }]
-          end
-        end
-
         # output the json schema root
         def self.output_root(out, meta)
           json = {

data/lib/rsmp/convert/export/json_schema/values.rb

@@ -3,6 +3,21 @@ module RSMP
     module Export
       # Converts SXL definitions to JSON Schema files.
       module JSONSchema
+        DIRECT_JSON_TYPES = {
+          'boolean' => 'boolean',
+          'integer' => 'integer',
+          'number' => 'number',
+          'object' => 'object',
+          'null' => 'null'
+        }.freeze
+
+        DEFINITION_REFS = {
+          'boolean_as_string' => '../defs/definitions.json#/boolean',
+          'timestamp' => '../defs/definitions.json#/timestamp',
+          'integer_as_string' => '../defs/definitions.json#/integer',
+          'long_as_string' => '../defs/definitions.json#/integer'
+        }.freeze
+
         # convert a yaml item to json schema
         def self.build_value(item)
           out = {}
@@ -19,20 +34,27 @@ module RSMP
 
         # convert an item which is not a string-list, to json schema
         def self.handle_types(item, out)
-          case item['type']
-          when 'boolean'
-            out['$ref'] = '../defs/definitions.json#/boolean'
-          when 'timestamp'
-            out['$ref'] = '../defs/definitions.json#/timestamp'
-          when 'integer', 'ordinal', 'unit', 'scale', 'long'
-            out['$ref'] = '../defs/definitions.json#/integer'
-          when 'array' # a json array
+          type = item['type']
+          return build_json_array_type(item, out) if type == 'array'
+          return build_number_as_string_type(out) if type == 'number_as_string'
+          return out['$ref'] = DEFINITION_REFS[type] if DEFINITION_REFS.key?(type)
+
+          out['type'] = DIRECT_JSON_TYPES.fetch(type, 'string')
+        end
+
+        def self.build_json_array_type(item, out)
+          if item['items']
             build_json_array item['items'], out
-          else # string, base64, and any unknown types
-            out['type'] = 'string'
+          else
+            out['type'] = 'array'
           end
         end
 
+        def self.build_number_as_string_type(out)
+          out['type'] = 'string'
+          out['pattern'] = '^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?$'
+        end
+
         # convert an yaml item with type: array to json schema
         def self.build_json_array(item, out)
           required = item.reject { |_k, v| v['optional'] == true }.keys.sort
@@ -83,7 +105,14 @@ module RSMP
         def self.handle_enum(item, out)
           return unless item['values']
 
-          out['enum'] = stringify_values(enum_keys(item))
+          values = enum_keys(item)
+          values = stringify_values(values) if string_type? item
+          out['enum'] = values
+        end
+
+        def self.string_type?(item)
+          type = item['type'].to_s
+          type == 'string' || type.end_with?('_as_string') || %w[base64 timestamp].include?(type)
         end
 
         def self.enum_keys(item)

data/lib/rsmp/convert/export/json_schema.rb

@@ -7,6 +7,7 @@ require 'fileutils'
 require_relative 'json_schema/values'
 require_relative 'json_schema/items'
 require_relative 'json_schema/outputs'
+require_relative 'json_schema/index'
 
 module RSMP
   module Convert
@@ -19,7 +20,8 @@ module RSMP
           object_nl: "\n",
           indent: '  ',
           space_before: ' ',
-          space: ' '
+          space: ' ',
+          ascii_only: true
         }.freeze
 
         def self.output_json(item)

data/lib/rsmp/message/sxl_codec.rb

@@ -0,0 +1,194 @@
+module RSMP
+  # Encodes and decodes SXL argument values for message payloads.
+  module MessageSxlCodec
+    SXL_ITEM_SHAPES = {
+      'StatusResponse' => { kind: :statuses, list: 'sS', code: 'sCI', name: 'n', value: 's' },
+      'StatusUpdate' => { kind: :statuses, list: 'sS', code: 'sCI', name: 'n', value: 's' },
+      'CommandRequest' => { kind: :commands, list: 'arg', code: 'cCI', name: 'n', value: 'v' },
+      'CommandResponse' => { kind: :commands, list: 'rvs', code: 'cCI', name: 'n', value: 'v' },
+      'Alarm' => { kind: :alarms, list: 'rvs', code: nil, name: 'n', value: 'v' }
+    }.freeze
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def encode_for(schemas)
+      transform_sxl_items(schemas, :encode_sxl_value)
+      self
+    end
+
+    def decode_for(schemas)
+      transform_sxl_items(schemas, :decode_sxl_value)
+      self
+    end
+
+    private
+
+    def transform_sxl_items(schemas, transformer)
+      shape = SXL_ITEM_SHAPES[type]
+      return unless shape
+
+      resolved = RSMP::Schema.resolve_sxl(@attributes, schemas: schemas)
+      return unless resolved
+
+      sxl_type, version = resolved
+      Array(@attributes[shape[:list]]).each do |item|
+        transform_sxl_item(item, shape, sxl_type, version, transformer)
+      end
+    end
+
+    def transform_sxl_item(item, shape, sxl_type, version, transformer)
+      item_code = shape[:code] ? item[shape[:code]] : @attributes['aCId']
+      name = item[shape[:name]]
+      return unless item_code && name && item.key?(shape[:value])
+
+      descriptor = RSMP::Schema.sxl_argument_descriptor(sxl_type, version, shape[:kind], item_code, name)
+      return unless descriptor
+
+      item[shape[:value]] = self.class.public_send(transformer, item[shape[:value]], descriptor)
+    end
+
+    # Class-level value transforms used by Message and command collectors.
+    module ClassMethods
+      STRING_TYPES = %w[string base64 timestamp].freeze
+      INTEGER_AS_STRING_TYPES = %w[integer_as_string long_as_string].freeze
+
+      def encode_sxl_value(value, descriptor)
+        return nil if value.nil?
+
+        type = descriptor_type(descriptor)
+        return encode_sxl_boolean(value) if type == 'boolean_as_string'
+        return encode_sxl_list(value) if list_type?(type)
+        return value.is_a?(String) ? value : value.to_s if encode_string_type?(type)
+        return encode_sxl_array(value, descriptor) if type == 'array'
+        return encode_sxl_object(value, descriptor['properties']) if type == 'object'
+
+        value
+      end
+
+      def decode_sxl_value(value, descriptor)
+        return nil if value.nil?
+
+        type = descriptor_type(descriptor)
+        return decode_sxl_boolean(value) if type == 'boolean_as_string'
+        return decode_sxl_integer(value) if INTEGER_AS_STRING_TYPES.include?(type)
+        return decode_sxl_number(value) if type == 'number_as_string'
+        return decode_sxl_list(value, type) if list_type?(type)
+        return decode_sxl_array(value, descriptor) if type == 'array'
+        return decode_sxl_object(value, descriptor['properties']) if type == 'object'
+
+        value
+      end
+
+      def descriptor_type(descriptor)
+        descriptor.is_a?(Hash) ? descriptor['type'] : descriptor.to_s
+      end
+
+      def list_type?(type)
+        type.match?(/_list(_as_string)?\z/)
+      end
+
+      def encode_string_type?(type)
+        STRING_TYPES.include?(type) || INTEGER_AS_STRING_TYPES.include?(type) || type == 'number_as_string'
+      end
+
+      def encode_sxl_boolean(value)
+        case value
+        when true
+          'True'
+        when false
+          'False'
+        else
+          value
+        end
+      end
+
+      def encode_sxl_list(value)
+        return value if value.is_a?(String)
+        return encode_sxl_boolean(value).to_s unless value.is_a?(Array)
+
+        value.map { |item| encode_sxl_boolean(item) }.join(',')
+      end
+
+      def encode_sxl_array(value, descriptor)
+        return value unless value.is_a?(Array)
+
+        items = descriptor['items']
+        return value unless items.is_a?(Hash)
+
+        value.map { |item| encode_sxl_object(item, items) }
+      end
+
+      def encode_sxl_object(value, properties)
+        transform_sxl_object(value, properties, :encode_sxl_value)
+      end
+
+      def decode_sxl_boolean(value)
+        case value
+        when 'True'
+          true
+        when 'False'
+          false
+        else
+          value
+        end
+      end
+
+      def decode_sxl_integer(value)
+        return value unless value.is_a?(String) && value.match?(/\A[+-]?\d+\z/)
+
+        value.to_i
+      end
+
+      def decode_sxl_number(value)
+        return value unless value.is_a?(String)
+
+        Float(value)
+      rescue ArgumentError
+        value
+      end
+
+      def decode_sxl_list(value, type)
+        items = value.is_a?(String) ? value.split(',') : Array(value)
+        descriptor = list_item_descriptor(type)
+        items.map { |item| decode_sxl_value(item, descriptor) }
+      end
+
+      def list_item_descriptor(type)
+        case type
+        when /\Aboolean_list/ then 'boolean_as_string'
+        when /\Ainteger_list/ then 'integer_as_string'
+        when /\Anumber_list/ then 'number_as_string'
+        else 'string'
+        end
+      end
+
+      def decode_sxl_array(value, descriptor)
+        return value unless value.is_a?(Array)
+
+        items = descriptor['items']
+        return value unless items.is_a?(Hash)
+
+        value.map { |item| decode_sxl_array_item(item, items) }
+      end
+
+      def decode_sxl_array_item(item, descriptor)
+        descriptor['type'] ? decode_sxl_value(item, descriptor) : decode_sxl_object(item, descriptor)
+      end
+
+      def decode_sxl_object(value, properties)
+        transform_sxl_object(value, properties, :decode_sxl_value)
+      end
+
+      def transform_sxl_object(value, properties, transformer)
+        return value unless value.is_a?(Hash) && properties.is_a?(Hash)
+
+        value.each_with_object({}) do |(key, item_value), memo|
+          descriptor = properties[key] || properties[key.to_sym]
+          memo[key] = descriptor ? public_send(transformer, item_value, descriptor) : item_value
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/message.rb

@@ -2,6 +2,8 @@
 module RSMP
   # Base RSMP message class used to represent parsed and built messages.
   class Message
+    include MessageSxlCodec
+
     attr_reader :now, :attributes, :out, :timestamp # this is an internal timestamp recording when we receive/send
     attr_accessor :json, :direction
 

data/lib/rsmp/node/site/connections.rb

@@ -0,0 +1,80 @@
+module RSMP
+  # Connection handling for site instances.
+  module SiteConnections
+    def build_proxies
+      return if server_role?
+
+      @site_settings['supervisors'].each do |supervisor_settings|
+        @proxies << SupervisorProxy.new(supervisor_proxy_options(supervisor_settings))
+      end
+    end
+
+    def listen_for_supervisors
+      ip = @site_settings['ip'] || '0.0.0.0'
+      port = @site_settings['port']
+      log "Starting #{site_type_name} listener on #{ip}:#{port}", level: :info, timestamp: @clock.now
+      @endpoint = IO::Endpoint.tcp(ip, port)
+      @accept_task = Async::Task.current.async do |task|
+        task.annotate 'site accept loop'
+        accept_supervisor_connections
+      end
+
+      @ready_condition.signal
+      @accept_task.wait
+    end
+
+    def accept_supervisor_connections
+      @endpoint.accept do |socket|
+        accept_supervisor_connection socket
+      rescue StandardError => e
+        distribute_error e, level: :internal
+      end
+    rescue Async::Stop
+      # Expected during shutdown - no action needed
+    rescue StandardError => e
+      distribute_error e, level: :internal
+    end
+
+    def accept_supervisor_connection(socket)
+      remote_port = socket.remote_address.ip_port
+      remote_ip = socket.remote_address.ip_address
+      proxy = SupervisorProxy.new(accepted_supervisor_options(socket, remote_ip, remote_port))
+      @proxies << proxy
+      @proxies_condition.signal
+      proxy.start
+      proxy.wait
+    end
+
+    def connect_to_supervisor(_task, supervisor_settings)
+      proxy = build_proxy(supervisor_proxy_options(supervisor_settings))
+      @proxies << proxy
+      proxy.start
+      @proxies_condition.signal
+    end
+
+    private
+
+    def supervisor_proxy_options(supervisor_settings)
+      {
+        site: self,
+        task: @task,
+        settings: @site_settings,
+        ip: supervisor_settings['ip'],
+        port: supervisor_settings['port'],
+        logger: @logger,
+        archive: @archive,
+        collect: @collect
+      }
+    end
+
+    def accepted_supervisor_options(socket, remote_ip, remote_port)
+      stream = IO::Stream::Buffered.new(socket)
+      supervisor_proxy_options('ip' => remote_ip, 'port' => remote_port).merge(
+        socket: socket,
+        stream: stream,
+        protocol: RSMP::Protocol.new(stream),
+        info: { ip: remote_ip, port: remote_port, hostname: remote_ip, now: Clock.now }
+      )
+    end
+  end
+end