rsmp 0.47.0 → 0.48.0

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

@@ -2,8 +2,9 @@ module RSMP
   # RSMP site implementation that manages proxies and components.
   class Site < Node
     include Components
+    include SiteConnections
 
-    attr_reader :core_version, :site_settings, :logger, :proxies
+    attr_reader :core_version, :site_settings, :logger, :proxies, :ready_condition
 
     def self.options_class
       RSMP::Site::Options
@@ -16,6 +17,7 @@ module RSMP
       @proxies = []
       @sleep_condition = Async::Notification.new
       @proxies_condition = Async::Notification.new
+      @ready_condition = Async::Notification.new
       build_proxies
     end
 
@@ -35,6 +37,14 @@ module RSMP
       @site_settings['site_id']
     end
 
+    def client_role?
+      @site_settings['connection_role'] != 'server'
+    end
+
+    def server_role?
+      @site_settings['connection_role'] == 'server'
+    end
+
     def handle_site_settings(options = {})
       options_class = self.class.options_class
       settings = options[:site_settings] || {}
@@ -97,22 +107,11 @@ module RSMP
     def run
       log_site_starting
       start_status_timer
-      @proxies.each(&:start)
-      @proxies.each(&:wait)
-    end
-
-    def build_proxies
-      @site_settings['supervisors'].each do |supervisor_settings|
-        @proxies << SupervisorProxy.new({
-                                          site: self,
-                                          task: @task,
-                                          settings: @site_settings,
-                                          ip: supervisor_settings['ip'],
-                                          port: supervisor_settings['port'],
-                                          logger: @logger,
-                                          archive: @archive,
-                                          collect: @collect
-                                        })
+      if server_role?
+        listen_for_supervisors
+      else
+        @proxies.each(&:start)
+        @proxies.each(&:wait)
       end
     end
 
@@ -177,36 +176,23 @@ module RSMP
 
     def stop_subtasks
       stop_status_timer
+      @accept_task&.stop
+      @accept_task = nil
+      @endpoint = nil
       super
     end
 
-    def connect_to_supervisor(_task, supervisor_settings)
-      proxy = build_proxy({
-                            site: self,
-                            task: @task,
-                            settings: @site_settings,
-                            ip: supervisor_settings['ip'],
-                            port: supervisor_settings['port'],
-                            logger: @logger,
-                            archive: @archive,
-                            collect: @collect
-                          })
-      @proxies << proxy
-      proxy.start
-      @proxies_condition.signal
-    end
-
     # stop
     def stop
       log "Stopping site #{@site_settings['site_id']}", level: :info
       super
     end
 
-    def wait_for_supervisor(ip, timeout)
+    def wait_for_supervisor(ip, timeout:)
       supervisor = find_supervisor ip
       return supervisor if supervisor
 
-      wait_for_condition(@proxy_condition, timeout: timeout) { find_supervisor ip }
+      wait_for_condition(@proxies_condition, timeout: timeout) { find_supervisor ip }
     rescue Async::TimeoutError
       raise RSMP::TimeoutError, "Supervisor '#{ip}' did not connect within #{timeout}s"
     end

data/lib/rsmp/node/supervisor/supervisor.rb

@@ -21,8 +21,18 @@ module RSMP
       @supervisor_settings['site_id']
     end
 
+    def client_role?
+      @supervisor_settings['connection_role'] == 'client'
+    end
+
+    def server_role?
+      !client_role?
+    end
+
     # listen for connections
     def run
+      return connect_to_sites if client_role?
+
       log "Starting supervisor on port #{@supervisor_settings['port']}",
           level: :info,
           timestamp: @clock.now
@@ -47,6 +57,38 @@ module RSMP
       distribute_error e, level: :internal
     end
 
+    def connect_to_sites
+      log 'Starting supervisor in client connection role',
+          level: :info,
+          timestamp: @clock.now
+      build_outbound_proxies
+      @ready_condition.signal
+      @proxies.each(&:start)
+      @proxies.each(&:wait)
+    end
+
+    def build_outbound_proxies
+      site_entries = (@supervisor_settings['sites'] || {}).except('default')
+      site_entries.each_pair do |site_id, site_settings|
+        endpoints = site_settings['supervisors'] || []
+        merged_settings = site_id_to_site_setting site_id
+        endpoints.each do |endpoint|
+          @proxies << SiteProxy.new({
+                                      supervisor: self,
+                                      task: @task,
+                                      settings: @supervisor_settings,
+                                      site_id: site_id,
+                                      site_settings: merged_settings,
+                                      ip: endpoint['ip'],
+                                      port: endpoint['port'],
+                                      logger: @logger,
+                                      archive: @archive,
+                                      collect: @collect
+                                    })
+        end
+      end
+    end
+
     # stop
     def stop
       log "Stopping supervisor #{@supervisor_settings['site_id']}", level: :info

data/lib/rsmp/options/schemas/site.json

@@ -5,6 +5,9 @@
   "properties": {
     "site_id": { "type": "string" },
     "type": { "type": "string" },
+    "connection_role": { "enum": ["client", "server"] },
+    "ip": { "type": "string" },
+    "port": { "type": ["integer", "string"] },
     "supervisors": {
       "type": "array",
       "items": { "$ref": "config_common.json#/$defs/endpoint" }

data/lib/rsmp/options/schemas/supervisor.json

@@ -4,6 +4,7 @@
   "properties": {
     "port": { "type": ["integer", "string"] },
     "ip": { "type": "string" },
+    "connection_role": { "enum": ["client", "server"] },
     "proxy_type": { "type": "string" },
     "ips": {
       "oneOf": [

data/lib/rsmp/options/site_options.rb

@@ -5,28 +5,15 @@ module RSMP
       def defaults
         {
           'site_id' => 'RN+SI0001',
-          'supervisors' => [
-            { 'ip' => '127.0.0.1', 'port' => 12_111 }
-          ],
-          'sxls' => {
-            'tlc' => RSMP::Schema.latest_version(:tlc)
-          },
-          'intervals' => {
-            'timer' => 0.1,
-            'watchdog' => 1,
-            'reconnect' => 0.1
-          },
-          'timeouts' => {
-            'watchdog' => 2,
-            'acknowledgement' => 2
-          },
+          'connection_role' => 'client',
+          'ip' => '0.0.0.0',
+          'supervisors' => default_supervisors,
+          'sxls' => default_sxls,
+          'intervals' => default_intervals,
+          'timeouts' => default_timeouts,
           'send_after_connect' => true,
           'message_buffer' => default_message_buffer,
-          'components' => {
-            'main' => {
-              'C1' => {}
-            }
-          }
+          'components' => default_components
         }
       end
 
@@ -43,10 +30,32 @@ module RSMP
         }
       end
 
+      def default_supervisors
+        [{ 'ip' => '127.0.0.1', 'port' => 12_111 }]
+      end
+
+      def default_sxls
+        { 'tlc' => RSMP::Schema.latest_version(:tlc) }
+      end
+
+      def default_intervals
+        { 'timer' => 0.1, 'watchdog' => 1, 'reconnect' => 0.1 }
+      end
+
+      def default_timeouts
+        { 'watchdog' => 2, 'acknowledgement' => 2 }
+      end
+
+      def default_components
+        { 'main' => { 'C1' => {} } }
+      end
+
       def apply_defaults(options)
         defaults = defaults()
         defaults['components']['main'] = options['components']['main'] if options.dig('components', 'main')
-        defaults.deep_merge(options)
+        data = defaults.deep_merge(options)
+        data['port'] ||= data.dig('supervisors', 0, 'port')
+        data
       end
     end
   end

data/lib/rsmp/options/supervisor_options.rb

@@ -5,6 +5,7 @@ module RSMP
       def defaults
         {
           'port' => 12_111,
+          'connection_role' => 'server',
           'ips' => 'all',
           'default' => {
             'sxls' => {

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

@@ -68,8 +68,10 @@ module RSMP
         def process_packet(json)
           attributes = Message.parse_attributes json
           message = Message.build attributes, json
-          message.validate(schemas) if should_validate_ingoing_message?(message)
+          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

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

@@ -12,21 +12,12 @@ module RSMP
         end
 
         def send_message(message, reason = nil, validate: true, force: false, buffer: true)
-          unless force || connected?
-            error = NotReady.new
-            raise error unless buffer
-
-            return buffer_message(message, error)
+          with_send_ready(message, force: force, buffer: buffer) do
+            write_message(message, validate: validate)
+            expect_acknowledgement message
+            distribute message
+            log_send message, reason
           end
-          raise IOError unless @protocol
-
-          message.direction = :out
-          message.generate_json
-          message.validate schemas unless validate == false
-          @protocol.write_lines message.json
-          expect_acknowledgement message
-          distribute message
-          log_send message, reason
         rescue NotReady, IOError => e
           raise e unless buffer
 
@@ -35,6 +26,25 @@ module RSMP
           handle_send_schema_error(message, e)
         end
 
+        def with_send_ready(message, force:, buffer:)
+          return yield if force || connected?
+
+          error = NotReady.new
+          raise error unless buffer
+
+          buffer_message(message, error)
+        end
+
+        def write_message(message, validate:)
+          raise IOError unless @protocol
+
+          message.direction = :out
+          message.encode_for(schemas) unless validate == false
+          message.generate_json
+          message.validate schemas unless validate == false
+          @protocol.write_lines message.json
+        end
+
         def buffer_message(message, error = nil)
           str = "Cannot send #{message.type} because the connection is closed."
           log str, message: message, level: :error
@@ -67,6 +77,8 @@ module RSMP
         end
 
         def apply_nts_message_attributes(message)
+          return if core_3_3?
+
           message.attributes['ntsOId'] = main && main.ntsoid ? main.ntsoid : ''
           message.attributes['xNId'] = main && main.xnid ? main.xnid : ''
         end

data/lib/rsmp/proxy/proxy.rb

@@ -234,6 +234,23 @@ module RSMP
       sxl_interface resolved.first
     end
 
+    def command_items(message)
+      key = message.is_a?(CommandResponse) ? 'rvs' : 'arg'
+      message.attributes[key] || []
+    end
+
+    def command_codes(message)
+      command_items(message).map { |item| item['cCI'] }.compact.uniq
+    end
+
+    def multiple_command_codes?(message)
+      command_codes(message).size > 1
+    end
+
+    def reject_multiple_command_codes(message)
+      dont_acknowledge message, 'Rejected', 'more than one command code in a single command message'
+    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']

data/lib/rsmp/proxy/site/connection.rb

@@ -0,0 +1,79 @@
+module RSMP
+  # Connection management for supervisor-side site proxies.
+  module SiteProxyConnection
+    # handle communication
+    # when we're created, the socket is already open
+    def run
+      if @protocol
+        run_accepted_connection
+      else
+        run_outbound_connection
+      end
+    end
+
+    def run_accepted_connection
+      self.state = :connected
+      start_reader
+      wait_for_reader # run until disconnected
+    rescue RSMP::ConnectionError => e
+      log e, level: :error
+    rescue StandardError => e
+      distribute_error e, level: :internal
+    ensure
+      close
+    end
+
+    def run_outbound_connection
+      loop do
+        setup_site_settings
+        connect
+        start_reader
+        wait_for_reader
+        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
+        break unless reconnect_delay?
+      ensure
+        close
+        stop_subtasks
+      end
+    end
+
+    def connect
+      log "Connecting to site #{@site_id} at #{@ip}:#{@port}", level: :info
+      self.state = :connecting
+      open_socket
+      self.state = :connected
+      @logger.unmute @ip, @port
+      log "Connected to site #{@site_id} at #{@ip}:#{@port}", level: :info
+    rescue SystemCallError => e
+      raise ConnectionError, "Could not connect to site #{@site_id} at #{@ip}:#{@port}: Errno #{e.errno} #{e}"
+    rescue StandardError => e
+      raise ConnectionError, "Error while connecting to site #{@site_id} at #{@ip}:#{@port}: #{e}"
+    end
+
+    def open_socket
+      endpoint = IO::Endpoint.tcp(@ip, @port)
+      timeout = @site_settings.dig('timeouts', 'connect') || 1.1
+      task.with_timeout(timeout) { @socket = endpoint.connect }
+      @stream = IO::Stream::Buffered.new(@socket)
+      @protocol = RSMP::Protocol.new(@stream)
+    end
+
+    def reconnect_delay?
+      return false if @site_settings['intervals']['reconnect'] == :no
+
+      interval = @site_settings['intervals']['reconnect'] || 0.1
+      log "Will try to reconnect again every #{interval} seconds...", level: :info
+      @logger.mute @ip, @port
+      @task.sleep interval
+      true
+    end
+  end
+end

data/lib/rsmp/proxy/site/modules/commands.rb

@@ -24,17 +24,40 @@ module RSMP
           validate_ready 'send command'
           component ||= main.c_id
           m_id = RSMP::Message.make_m_id
+          collector_list = command_collector_list(command_list)
           message = RSMP::CommandRequest.new({
                                                'cId' => component,
                                                'arg' => command_list,
                                                'mId' => m_id
                                              })
           apply_nts_message_attributes message
-          collector = CommandResponseCollector.new(self, command_list, timeout: within, initiator: message)
+          collector = CommandResponseCollector.new(self, collector_list, timeout: within, initiator: message)
           send_message_and_collect(message, collector, validate: validate)[:collector]
         end
 
+        def command_collector_list(command_list)
+          list = JSON.parse(JSON.generate(command_list))
+          resolved = RSMP::Schema.resolve_sxl({ 'type' => 'CommandRequest', 'arg' => list }, schemas: schemas)
+          return list unless resolved
+
+          type, version = resolved
+          list.each do |item|
+            next unless item.key?('v')
+
+            descriptor = RSMP::Schema.sxl_argument_descriptor(type, version, :commands, item['cCI'], item['n'])
+            next unless descriptor
+
+            encoded = RSMP::Message.encode_sxl_value(item['v'], descriptor)
+            item['v'] = RSMP::Message.decode_sxl_value(encoded, descriptor)
+          end
+          list
+        rescue RSMP::Schema::Error
+          list
+        end
+
         def process_command_response(message)
+          return reject_multiple_command_codes(message) if core_3_3? && multiple_command_codes?(message)
+
           log "Received #{message.type}", message: message, level: :log
           acknowledge message
         end

data/lib/rsmp/proxy/site/site_proxy.rb

@@ -6,6 +6,7 @@ module RSMP
     include Modules::AggregatedStatus
     include Modules::Alarms
     include Modules::Commands
+    include SiteProxyConnection
     include SiteSxlSelection
 
     attr_reader :supervisor, :site_id
@@ -16,27 +17,15 @@ module RSMP
       @supervisor = options[:supervisor]
       @settings = @supervisor.supervisor_settings.clone
       @site_id = options[:site_id]
+      @configured_site_settings = options[:site_settings]
       @status_subscriptions = {}
     end
 
-    # handle communication
-    # when we're created, the socket is already open
-    def run
-      self.state = :connected
-      start_reader
-      wait_for_reader # run until disconnected
-    rescue RSMP::ConnectionError => e
-      log e, level: :error
-    rescue StandardError => e
-      distribute_error e, level: :internal
-    ensure
-      close
-    end
-
     def revive(options)
       super
       @supervisor = options[:supervisor]
       @settings = @supervisor.supervisor_settings.clone
+      @configured_site_settings = options[:site_settings]
     end
 
     def node
@@ -170,6 +159,7 @@ module RSMP
       return extraneous_version message if @version_determined
 
       check_site_ids message
+      check_core_version message
       check_sxl_version message
       version_accepted message
     end
@@ -177,6 +167,7 @@ module RSMP
     def check_site_ids(message)
       # RSMP support multiple site ids. we don't support this yet. instead we use the first id only
       site_id = message.attribute('siteId').map { |item| item['sId'] }.first
+      @site_id ||= site_id
       @supervisor.check_site_id site_id
       site_ids_changed
     end
@@ -202,7 +193,7 @@ module RSMP
     end
 
     def setup_site_settings
-      @site_settings = find_site_settings @site_id
+      @site_settings = @configured_site_settings || find_site_settings(@site_id)
       if @site_settings
         @sxls = configured_sxls
         @accepted_sxls = @sxls.dup

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

@@ -20,11 +20,63 @@ module RSMP
           end
         end
 
+        def command_catalogue_item(command_code)
+          accepted_sxls.each do |sxl|
+            item = command_catalogue_match(sxl, command_code)
+            return item if item
+          end
+          nil
+        end
+
+        def command_catalogue_match(sxl, command_code)
+          version = RSMP::Schema.sanitize_version(sxl['version'].to_s)
+          catalogue = RSMP::Schema.sxl_catalogue(sxl['name'], version, :commands)
+          prefix = RSMP::Schema.sxl_prefix(sxl['name'], version, lenient: true)
+          lookup_catalogue_command(catalogue, command_code, prefix)
+        end
+
+        def lookup_catalogue_command(catalogue, command_code, prefix)
+          unprefixed = prefix && command_code.start_with?(prefix) ? command_code[prefix.length..] : command_code
+          catalogue[command_code] || catalogue[command_code.to_sym] ||
+            catalogue[unprefixed] || catalogue[unprefixed.to_sym]
+        end
+
+        def required_command_argument_names(command_code)
+          item = command_catalogue_item command_code
+          return [] unless item
+
+          RSMP::Schema.argument_names(item['required'])
+        end
+
+        def check_required_command_arguments(message)
+          return unless core_3_3?
+
+          command_codes(message).each do |command_code|
+            provided = message.attributes['arg'].select { |item| item['cCI'] == command_code }.map { |item| item['n'] }
+            missing = required_command_argument_names(command_code) - provided
+            next if missing.empty?
+
+            raise MissingAttribute, "Missing required command argument(s) #{missing.join(', ')} for #{command_code}"
+          end
+        end
+
+        def mark_command_unknown(rvs, command_code)
+          rvs.each do |item|
+            next unless item['cCI'] == command_code
+
+            item['age'] = 'unknown'
+            item['v'] = nil
+          end
+        end
+
         def execute_commands(message, component_id, rvs)
           component = @site.find_component component_id
           commands = simplify_command_requests message.attributes['arg']
           commands.each_pair do |command_code, arg|
             component.handle_command command_code, arg
+          rescue UnknownCommand => e
+            log e.to_s, message: message, level: :warning
+            mark_command_unknown rvs, command_code
           end
           log "Received #{message.type}", message: message, level: :log
         rescue UnknownComponent
@@ -34,6 +86,9 @@ module RSMP
         end
 
         def process_command_request(message)
+          return reject_multiple_command_codes(message) if core_3_3? && multiple_command_codes?(message)
+
+          check_required_command_arguments message
           component_id = message.attributes['cId']
           rvs = build_command_rvs(message.attributes['arg'])
           execute_commands(message, component_id, rvs)