rsmp 0.37.0 → 0.38.0

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

@@ -0,0 +1,195 @@
+# RSMP site
+# The site initializes the connection to the supervisor.
+# Connections to supervisors are handles via supervisor proxies.
+
+module RSMP
+  class Site < Node
+    include Components
+
+    attr_reader :core_version, :site_settings, :logger, :proxies
+
+    def initialize(options = {})
+      super
+      initialize_components
+      handle_site_settings options
+      @proxies = []
+      @sleep_condition = Async::Notification.new
+      @proxies_condition = Async::Notification.new
+      build_proxies
+    end
+
+    def sxl_version
+      @site_settings['sxl_version']
+    end
+
+    def site_id
+      @site_settings['site_id']
+    end
+
+    def default_site_settings
+      {
+        'site_id' => 'RN+SI0001',
+        'supervisors' => [
+          { 'ip' => '127.0.0.1', 'port' => 12_111 }
+        ],
+        'sxl' => 'tlc',
+        'sxl_version' => RSMP::Schema.latest_version(:tlc),
+        'intervals' => {
+          'timer' => 0.1,
+          'watchdog' => 1,
+          'reconnect' => 0.1
+        },
+        'timeouts' => {
+          'watchdog' => 2,
+          'acknowledgement' => 2
+        },
+        'send_after_connect' => true,
+        'components' => {
+          'main' => {
+            'C1' => {}
+          }
+        }
+      }
+    end
+
+    def handle_site_settings(options = {})
+      defaults = default_site_settings
+      defaults['components']['main'] = options[:site_settings]['components']['main'] if options.dig(
+        :site_settings, 'components', 'main'
+      )
+
+      @site_settings = defaults.deep_merge options[:site_settings]
+
+      check_sxl_version
+      check_core_versions
+      setup_components @site_settings['components']
+    end
+
+    def check_sxl_version
+      sxl = @site_settings['sxl']
+      version = @site_settings['sxl_version'].to_s
+      RSMP::Schema.find_schema! sxl, version, lenient: true
+    end
+
+    def check_core_versions
+      version = @site_settings['core_version']
+      return unless version
+
+      return if RSMP::Schema.core_versions.include? version
+
+      error_str = "Unknown core version: #{version}"
+      raise RSMP::ConfigurationError, error_str
+    end
+
+    def site_type_name
+      'site'
+    end
+
+    def log_site_starting
+      log "Starting #{site_type_name} #{@site_settings['site_id']}", level: :info, timestamp: @clock.now
+      sxl = "Using #{@site_settings['sxl']} sxl #{@site_settings['sxl_version']}"
+      version = @site_settings['core_version']
+      core = if version
+               "accepting only core version #{version}"
+             else
+               "accepting all core versions [#{RSMP::Schema.core_versions.join(', ')}]"
+             end
+      log "#{sxl}, #{core}", level: :info, timestamp: @clock.now
+    end
+
+    def run
+      log_site_starting
+      @proxies.each do |proxy|
+        proxy.start
+        proxy.wait
+      end
+    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
+                                        })
+      end
+    end
+
+    def aggregated_status_changed(component, options = {})
+      @proxies.each do |proxy|
+        proxy.send_aggregated_status component, options if proxy.ready?
+      end
+    end
+
+    def alarm_acknowledged(alarm_state)
+      send_alarm AlarmAcknowledged.new(alarm_state.to_hash)
+    end
+
+    def alarm_suspended_or_resumed(alarm_state)
+      send_alarm AlarmSuspended.new(alarm_state.to_hash)
+    end
+
+    def alarm_activated_or_deactivated(alarm_state)
+      send_alarm AlarmIssue.new(alarm_state.to_hash)
+    end
+
+    def send_alarm(alarm)
+      @proxies.each do |proxy|
+        proxy.send_message alarm if proxy.ready?
+      end
+    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)
+      supervisor = find_supervisor ip
+      return supervisor if supervisor
+
+      wait_for_condition(@proxy_condition, timeout: timeout) { find_supervisor ip }
+    rescue Async::TimeoutError
+      raise RSMP::TimeoutError, "Supervisor '#{ip}' did not connect within #{timeout}s"
+    end
+
+    def find_supervisor(ip)
+      @proxies.each do |supervisor|
+        return supervisor if ip == :any || supervisor.ip == ip
+      end
+      nil
+    end
+
+    def build_component(id:, type:, settings:)
+      settings ||= {}
+      if type == 'main'
+        Component.new id: id, node: self, grouped: true,
+                      ntsoid: settings['ntsOId'], xnid: settings['xNId']
+      else
+        Component.new id: id, node: self, grouped: false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module RSMP
+  class Supervisor < Node
+    module Modules
+      # Handles supervisor configuration and site settings
+      module Configuration
+        def handle_supervisor_settings(supervisor_settings)
+          defaults = {
+            'port' => 12_111,
+            'ips' => 'all',
+            'guest' => {
+              'sxl' => 'tlc',
+              'intervals' => {
+                'timer' => 1,
+                'watchdog' => 1
+              },
+              'timeouts' => {
+                'watchdog' => 2,
+                'acknowledgement' => 2
+              }
+            }
+          }
+
+          # merge options into defaults
+          @supervisor_settings = defaults.deep_merge(supervisor_settings)
+          @core_version = @supervisor_settings['guest']['core_version']
+          check_site_sxl_types
+        end
+
+        def check_site_sxl_types
+          sites = @supervisor_settings['sites'].clone || {}
+          sites['guest'] = @supervisor_settings['guest']
+          sites.each do |site_id, settings|
+            raise RSMP::ConfigurationError, "Configuration for site '#{site_id}' is empty" unless settings
+
+            sxl = settings['sxl']
+            raise RSMP::ConfigurationError, "Configuration error for site '#{site_id}': No SXL specified" unless sxl
+
+            RSMP::Schema.find_schemas! sxl if sxl
+          rescue RSMP::Schema::UnknownSchemaError => e
+            raise RSMP::ConfigurationError, "Configuration error for site '#{site_id}': #{e}"
+          end
+        end
+
+        def site_id_to_site_setting(site_id)
+          return {} unless @supervisor_settings['sites']
+
+          @supervisor_settings['sites'].each_pair do |id, settings|
+            return settings if id == 'guest' || id == site_id
+          end
+          raise HandshakeError, "site id #{site_id} unknown"
+        end
+
+        def ip_to_site_settings(ip)
+          @supervisor_settings['sites'][ip] || @supervisor_settings['sites']['guest']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+module RSMP
+  class Supervisor < Node
+    module Modules
+      # Handles incoming connections from sites
+      module Connection
+        def handle_connection(socket)
+          remote_port = socket.remote_address.ip_port
+          remote_hostname = socket.remote_address.ip_address
+          remote_ip = socket.remote_address.ip_address
+
+          info = { ip: remote_ip, port: remote_port, hostname: remote_hostname, now: Clock.now }
+          if accept? socket, info
+            accept_connection socket, info
+          else
+            reject_connection socket, info
+          end
+        rescue ConnectionError, HandshakeError => e
+          log "Rejected connection from #{remote_ip}:#{remote_port}, #{e}", level: :warning
+          distribute_error e
+        rescue StandardError => e
+          log "Connection: #{e}", exception: e, level: :error
+          distribute_error e, level: :internal
+        ensure
+          close socket, info
+        end
+
+        def accept?(_socket, _info)
+          true
+        end
+
+        def format_ip_and_port(info)
+          if @logger.settings['hide_ip_and_port']
+            '********'
+          else
+            "#{info[:ip]}:#{info[:port]}"
+          end
+        end
+
+        def authorize_ip(ip)
+          return if @supervisor_settings['ips'] == 'all'
+          return if @supervisor_settings['ips'].include? ip
+
+          raise ConnectionError, 'guest ip not allowed'
+        end
+
+        def check_max_sites
+          max = @supervisor_settings['max_sites']
+          return unless max
+          return unless @proxies.size >= max
+
+          raise ConnectionError, "maximum of #{max} sites already connected"
+        end
+
+        def peek_version_message(protocol)
+          json = protocol.peek_line
+          attributes = Message.parse_attributes json
+          Message.build attributes, json
+        end
+
+        def build_proxy_settings(socket, info)
+          stream = IO::Stream::Buffered.new(socket)
+          protocol = RSMP::Protocol.new stream
+
+          {
+            supervisor: self,
+            ip: info[:ip],
+            port: info[:port],
+            task: @task,
+            collect: @collect,
+            socket: socket,
+            stream: stream,
+            protocol: protocol,
+            info: info,
+            logger: @logger,
+            archive: @archive
+          }
+        end
+
+        def retrieve_site_id(protocol)
+          version_message = peek_version_message protocol
+          version_message.attribute('siteId').first['sId']
+        end
+
+        def setup_proxy(proxy, settings, id)
+          if proxy
+            raise ConnectionError, "Site #{id} alredy connected from port #{proxy.port}" if proxy.connected?
+
+            proxy.revive settings
+          else
+            check_max_sites
+            proxy = build_proxy settings.merge(site_id: id)
+            @proxies.push proxy
+          end
+          proxy
+        end
+
+        def validate_and_start_proxy(proxy, protocol)
+          proxy.setup_site_settings
+          proxy.check_core_version peek_version_message(protocol)
+          log "Validating using core version #{proxy.core_version}", level: :debug
+          proxy.start
+          proxy.wait
+        end
+
+        def accept_connection(socket, info)
+          log "Site connected from #{format_ip_and_port(info)}",
+              ip: info[:ip],
+              port: info[:port],
+              level: :info,
+              timestamp: Clock.now
+
+          authorize_ip info[:ip]
+
+          settings = build_proxy_settings(socket, info)
+          id = retrieve_site_id(settings[:protocol])
+          proxy = setup_proxy(find_site(id), settings, id)
+
+          validate_and_start_proxy(proxy, settings[:protocol])
+        ensure
+          site_ids_changed
+          stop if @supervisor_settings['one_shot']
+        end
+
+        def reject_connection(_socket, info)
+          log 'Site rejected', ip: info[:ip], level: :info
+        end
+
+        def close(socket, info)
+          if info
+            log "Connection to #{format_ip_and_port(info)} closed", ip: info[:ip], level: :info, timestamp: Clock.now
+          else
+            log 'Connection closed', level: :info, timestamp: Clock.now
+          end
+
+          socket.close
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module RSMP
+  class Supervisor < Node
+    module Modules
+      # Manages connected sites and site discovery
+      module Sites
+        def site_connected?(site_id)
+          !find_site(site_id).nil?
+        end
+
+        def find_site_from_ip_port(ip, port)
+          @proxies.each do |site|
+            return site if site.ip == ip && site.port == port
+          end
+          nil
+        end
+
+        def find_site(site_id)
+          @proxies.each do |site|
+            return site if site_id == :any || site.site_id == site_id
+          end
+          nil
+        end
+
+        def wait_for_site(site_id, timeout:)
+          site = find_site site_id
+          return site if site
+
+          wait_for_condition(@site_id_condition, timeout: timeout) do
+            find_site site_id
+          end
+        rescue Async::TimeoutError
+          str = if site_id == :any
+                  'No site connected'
+                else
+                  "Site '#{site_id}' did not connect"
+                end
+          raise RSMP::TimeoutError, "#{str} within #{timeout}s"
+        end
+
+        def wait_for_site_disconnect(site_id, timeout:)
+          wait_for_condition(@site_id_condition, timeout: timeout) { true unless find_site site_id }
+        rescue Async::TimeoutError
+          raise RSMP::TimeoutError, "Site '#{site_id}' did not disconnect within #{timeout}s"
+        end
+
+        def check_site_id(site_id)
+          # check_site_already_connected site_id
+          site_id_to_site_setting site_id
+        end
+
+        def check_site_already_connected(site_id)
+          site = find_site(site_id)
+          raise HandshakeError, "Site '#{site_id}' already connected" if !site.nil? && site != self
+        end
+
+        def site_ids_changed
+          @site_id_condition.signal
+        end
+
+        def aggregated_status_changed(site_proxy, component); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# RSMP supervisor (server)
+# The supervisor waits for sites to connect.
+# Connections to sites are handles via site proxies.
+
+module RSMP
+  class Supervisor < Node
+    include Modules::Configuration
+    include Modules::Connection
+    include Modules::Sites
+
+    attr_reader :core_version, :supervisor_settings, :proxies, :logger, :ready_condition
+
+    attr_accessor :site_id_condition
+
+    def initialize(options = {})
+      handle_supervisor_settings(options[:supervisor_settings] || {})
+      super
+      @proxies = []
+      @ready_condition = Async::Notification.new
+      @site_id_condition = Async::Notification.new
+    end
+
+    def site_id
+      @supervisor_settings['site_id']
+    end
+
+    # listen for connections
+    def run
+      log "Starting supervisor on port #{@supervisor_settings['port']}",
+          level: :info,
+          timestamp: @clock.now
+
+      @endpoint = IO::Endpoint.tcp('0.0.0.0', @supervisor_settings['port'])
+      @accept_task = Async::Task.current.async do |task|
+        task.annotate 'supervisor accept loop'
+        @endpoint.accept do |socket| # creates fibers
+          handle_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
+
+      @ready_condition.signal
+      @accept_task.wait
+    rescue StandardError => e
+      distribute_error e, level: :internal
+    end
+
+    # stop
+    def stop
+      log "Stopping supervisor #{@supervisor_settings['site_id']}", level: :info
+
+      @accept_task&.stop
+      @accept_task = nil
+
+      @endpoint = nil
+      super
+    end
+
+    def build_proxy(settings)
+      SiteProxy.new settings
+    end
+
+    def self.build_id_from_ip_port(ip, port)
+      Digest::MD5.hexdigest("#{ip}:#{port}")[0..8]
+    end
+  end
+end

data/lib/rsmp/{task.rb → node/task.rb}

@@ -13,7 +13,7 @@ module RSMP
     # run() will be called inside the task to perform actual long-running work
     def start
       return if @task
-      
+
       # Use current task context if available, otherwise create new reactor
       if Async::Task.current?
         Async::Task.current.async do |task|
@@ -37,12 +37,12 @@ module RSMP
 
     # initiate restart by raising a Restart exception
     def restart
-      raise Restart.new "restart initiated by #{self.class.name}:#{object_id}"
+      raise Restart, "restart initiated by #{self.class.name}:#{object_id}"
     end
 
     # get the status of our task, or nil of no task
     def task_status
-      @task.status if @task
+      @task&.status
     end
 
     # perform any long-running work
@@ -55,7 +55,7 @@ module RSMP
 
     # wait for our task to complete
     def wait
-      @task.wait if @task
+      @task&.wait
     end
 
     # stop our task
@@ -64,8 +64,7 @@ module RSMP
       stop_task if @task
     end
 
-    def stop_subtasks
-    end
+    def stop_subtasks; end
 
     # stop our task and any subtask
     def stop_task
@@ -75,22 +74,21 @@ module RSMP
 
     # wait for an async condition to signal, then yield to block
     # if block returns true we're done. otherwise, wait again
-    def wait_for_condition condition, timeout:, task:Async::Task.current, &block
-      unless task
-        raise RuntimeError.new("Can't wait without a task")
-      end
+    def wait_for_condition(condition, timeout:, task: Async::Task.current, &block)
+      raise "Can't wait without a task" unless task
+
       task.with_timeout(timeout) do
         while task.running?
           value = condition.wait
           return value unless block
+
           result = yield value
           return result if result
         end
-        raise RuntimeError.new("Can't wait for condition because task #{task.object_id} #{task.annotation} is not running")
+        raise "Can't wait for condition because task #{task.object_id} #{task.annotation} is not running"
       end
     rescue Async::TimeoutError
-      raise RSMP::TimeoutError.new
+      raise RSMP::TimeoutError
     end
-
   end
-end
+end