rsmp 0.37.0 → 0.38.0

data/lib/rsmp/proxy/proxy.rb

@@ -0,0 +1,199 @@
+# A connection to a remote site or supervisor.
+# Uses the Task module to handle asyncronous work, but adds
+# the concept of a connection that can be connected or disconnected.
+
+require 'rubygems'
+
+module RSMP
+  class Proxy
+    WRAPPING_DELIMITER = "\f".freeze
+
+    include Logging
+    include Distributor
+    include Inspect
+    include Task
+    include Modules::State
+    include Modules::Watchdogs
+    include Modules::Acknowledgements
+    include Modules::Send
+    include Modules::Receive
+    include Modules::Versions
+    include Modules::Tasks
+
+    attr_reader :state, :archive, :connection_info, :sxl, :collector, :ip, :port, :node, :core_version
+
+    def initialize(options)
+      @node = options[:node]
+      initialize_logging options
+      initialize_distributor
+      initialize_task
+      setup options
+      clear
+      @state = :disconnected
+      @state_condition = Async::Notification.new
+    end
+
+    def now
+      node.now
+    end
+
+    # Connection lifecycle methods
+
+    def disconnect; end
+
+    # wait for the reader task to complete,
+    # which is not expected to happen before the connection is closed
+    def wait_for_reader
+      @reader&.wait
+    end
+
+    # close connection, but keep our main task running so we can reconnect
+    def close
+      log 'Closing connection', level: :warning
+      close_stream
+      close_socket
+      stop_reader
+      self.state = :disconnected
+      distribute_error DisconnectError.new('Connection was closed')
+
+      # stop timer
+      # as we're running inside the timer, code after stop_timer() will not be called,
+      # unless it's in the ensure block
+      stop_timer
+    end
+
+    def stop_subtasks
+      stop_timer
+      stop_reader
+      clear
+      super
+    end
+
+    def stop_timer
+      @timer&.stop
+    ensure
+      @timer = nil
+    end
+
+    def stop_reader
+      @reader&.stop
+    ensure
+      @reader = nil
+    end
+
+    def close_stream
+      @stream&.close
+    ensure
+      @stream = nil
+    end
+
+    def close_socket
+      @socket&.close
+    ensure
+      @socket = nil
+    end
+
+    def stop_task
+      close
+      super
+    end
+
+    # State management methods
+
+    def ready?
+      @state == :ready
+    end
+
+    def connected?
+      @state == :connected || @state == :ready
+    end
+
+    def disconnected?
+      @state == :disconnected
+    end
+
+    # change our state
+    def state=(state)
+      return if state == @state
+
+      @state = state
+      state_changed
+    end
+
+    # the state changed
+    # override to to things like notifications
+    def state_changed
+      @state_condition.signal @state
+    end
+
+    def clear
+      @awaiting_acknowledgement = {}
+      @latest_watchdog_received = nil
+      @watchdog_started = false
+      @version_determined = false
+      @ingoing_acknowledged = {}
+      @outgoing_acknowledged = {}
+      @latest_watchdog_send_at = nil
+
+      @acknowledgements = {}
+      @acknowledgement_condition = Async::Notification.new
+    end
+
+    # revive after a reconnect
+    def revive(options)
+      setup options
+    end
+
+    def setup(options)
+      @settings = options[:settings]
+      @socket = options[:socket]
+      @stream = options[:stream]
+      @protocol = options[:protocol]
+      @ip = options[:ip]
+      @port = options[:port]
+      @connection_info = options[:info]
+      @sxl = nil
+      @site_settings = nil # can't pick until we know the site id
+      return unless options[:collect]
+
+      @collector = RSMP::Collector.new self, options[:collect]
+      @collector.start
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id}, #{inspector(
+        :@acknowledgements, :@settings, :@site_settings
+      )}>"
+    end
+
+    def clock
+      @node.clock
+    end
+
+    def receive_error(error, options = {})
+      @node.receive_error error, options
+    end
+
+    def log(str, options = {})
+      super(str, options.merge(ip: @ip, port: @port, site_id: @site_id))
+    end
+
+    def schemas
+      schemas = { core: RSMP::Schema.latest_core_version } # use latest core
+      schemas[:core] = core_version if core_version
+      schemas[sxl] = RSMP::Schema.sanitize_version(sxl_version.to_s) if sxl && sxl_version
+      schemas
+    end
+
+    def author
+      @node.site_id
+    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']
+    def self.version_meets_requirement?(version, requirement)
+      Modules::Versions.version_meets_requirement?(version, requirement)
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module RSMP
+  class SiteProxy < Proxy
+    module Modules
+      # Handles aggregated status requests and responses
+      module AggregatedStatus
+        def request_aggregated_status(component, options = {})
+          validate_ready 'request aggregated status'
+          m_id = options[:m_id] || RSMP::Message.make_m_id
+          message = RSMP::AggregatedStatusRequest.new({
+                                                        'cId' => component,
+                                                        'mId' => m_id
+                                                      })
+          apply_nts_message_attributes message
+          send_and_optionally_collect message, options do |collect_options|
+            AggregatedStatusCollector.new(
+              self,
+              collect_options.merge(task: @task, m_id: m_id, num: 1)
+            )
+          end
+        end
+
+        def validate_aggregated_status(message, status_elements)
+          return if status_elements.is_a?(Array) && status_elements.size == 8
+
+          dont_acknowledge message, 'Received', reaons
+          raise InvalidMessage
+        end
+
+        def process_aggregated_status(message)
+          status_elements = message.attribute('se')
+          validate_aggregated_status(message, status_elements)
+          c_id = message.attributes['cId']
+          component = find_component c_id
+          unless component
+            reason = "component #{c_id} not found"
+            dont_acknowledge message, "Ignoring #{message.type}:", reason
+            return
+          end
+
+          component.aggregated_status_bools = status_elements
+          log "Received #{message.type} status for component #{c_id} [#{component.aggregated_status.join(', ')}]",
+              message: message
+          acknowledge message
+        end
+
+        def aggregated_status_changed(component, _options = {})
+          @supervisor.aggregated_status_changed self, component
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module RSMP
+  class SiteProxy < Proxy
+    module Modules
+      # Handles alarm messages
+      module Alarms
+        def process_alarm(message)
+          component = find_component message.attribute('cId')
+          status = %w[ack aS sS].map { |key| message.attribute(key) }.join(',')
+          component.handle_alarm message
+          alarm_code = message.attribute('aCId')
+          asp = message.attribute('aSp')
+          log "Received #{message.type}, #{alarm_code} #{asp} [#{status}]", message: message, level: :log
+          acknowledge message
+        end
+
+        def send_alarm_acknowledgement(component, alarm_code, options = {})
+          message = RSMP::AlarmAcknowledged.new({
+                                                  'cId' => component,
+                                                  'aCId' => alarm_code
+                                                })
+          send_message message, validate: options[:validate]
+          message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module RSMP
+  class SiteProxy < Proxy
+    module Modules
+      # Handles command requests and responses
+      module Commands
+        def send_command(component, command_list, options = {})
+          validate_ready 'send command'
+          m_id = options[:m_id] || RSMP::Message.make_m_id
+          message = RSMP::CommandRequest.new({
+                                               'cId' => component,
+                                               'arg' => command_list,
+                                               'mId' => m_id
+                                             })
+          apply_nts_message_attributes message
+          send_and_optionally_collect message, options do |collect_options|
+            CommandResponseCollector.new(
+              self,
+              command_list,
+              collect_options.merge(task: @task, m_id: m_id)
+            )
+          end
+        end
+
+        def process_command_response(message)
+          log "Received #{message.type}", message: message, level: :log
+          acknowledge message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+module RSMP
+  class SiteProxy < Proxy
+    module Modules
+      # Handles status requests, responses, subscriptions and updates
+      module Status
+        def request_status(component, status_list, options = {})
+          validate_ready 'request status'
+          m_id = options[:m_id] || RSMP::Message.make_m_id
+
+          # additional items can be used when verifying the response,
+          # but must be removed from the request
+          request_list = status_list.map { |item| item.slice('sCI', 'n') }
+
+          message = RSMP::StatusRequest.new({
+                                              'cId' => component,
+                                              'sS' => request_list,
+                                              'mId' => m_id
+                                            })
+          apply_nts_message_attributes message
+          send_and_optionally_collect message, options do |collect_options|
+            StatusCollector.new(
+              self,
+              status_list,
+              collect_options.merge(task: @task, m_id: m_id)
+            )
+          end
+        end
+
+        def process_status_response(message)
+          component = find_component message.attribute('cId')
+          component.store_status message
+          log "Received #{message.type}", message: message, level: :log
+          acknowledge message
+        end
+
+        def ensure_subscription_path(component_id, code, name)
+          @status_subscriptions[component_id] ||= {}
+          @status_subscriptions[component_id][code] ||= {}
+          @status_subscriptions[component_id][code][name] ||= {}
+        end
+
+        def update_subscription(component_id, subscribe_list)
+          subscribe_list.each do |item|
+            code = item['sCI']
+            name = item['n']
+            sub = ensure_subscription_path(component_id, code, name)
+            sub['uRt'] = item['uRt']
+            sub['sOc'] = item['sOc']
+          end
+        end
+
+        def subscribe_to_status(component_id, status_list, options = {})
+          validate_ready 'subscribe to status'
+          m_id = options[:m_id] || RSMP::Message.make_m_id
+          subscribe_list = status_list.map { |item| item.slice('sCI', 'n', 'uRt', 'sOc') }
+
+          update_subscription(component_id, subscribe_list)
+          find_component component_id
+
+          message = RSMP::StatusSubscribe.new({
+                                                'cId' => component_id,
+                                                'sS' => subscribe_list,
+                                                'mId' => m_id
+                                              })
+          apply_nts_message_attributes message
+
+          send_and_optionally_collect message, options do |collect_options|
+            StatusCollector.new(
+              self,
+              status_list,
+              collect_options.merge(task: @task, m_id: m_id)
+            )
+          end
+        end
+
+        def remove_subscription_item(component_id, code, name)
+          return unless @status_subscriptions.dig(component_id, code, name)
+
+          @status_subscriptions[component_id][code].delete name
+          @status_subscriptions[component_id].delete(code) if @status_subscriptions[component_id][code].empty?
+          @status_subscriptions.delete(component_id) if @status_subscriptions[component_id].empty?
+        end
+
+        def unsubscribe_to_status(component_id, status_list, options = {})
+          validate_ready 'unsubscribe to status'
+
+          status_list.each do |item|
+            remove_subscription_item(component_id, item['sCI'], item['n'])
+          end
+
+          message = RSMP::StatusUnsubscribe.new({
+                                                  'cId' => component_id,
+                                                  'sS' => status_list
+                                                })
+          apply_nts_message_attributes message
+          send_message message, validate: options[:validate]
+          message
+        end
+
+        def process_status_update(message)
+          component = find_component message.attribute('cId')
+          component.check_repeat_values message, @status_subscriptions
+          component.store_status message
+          log "Received #{message.type}", message: message, level: :log
+          acknowledge message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,205 @@
+# Handles a supervisor connection to a remote client
+
+module RSMP
+  class SiteProxy < Proxy
+    include Components
+    include Modules::Status
+    include Modules::AggregatedStatus
+    include Modules::Alarms
+    include Modules::Commands
+
+    attr_reader :supervisor, :site_id
+
+    def initialize(options)
+      super(options.merge(node: options[:supervisor]))
+      initialize_components
+      @supervisor = options[:supervisor]
+      @settings = @supervisor.supervisor_settings.clone
+      @site_id = options[:site_id]
+      @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
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id}, #{inspector(
+        :@acknowledgements, :@settings, :@site_settings, :@components
+      )}>"
+    end
+
+    def node
+      supervisor
+    end
+
+    def handshake_complete
+      super
+      sanitized_sxl_version = RSMP::Schema.sanitize_version(@site_sxl_version)
+      log "Connection to site #{@site_id} established, using core #{@core_version}, #{@sxl} #{sanitized_sxl_version}",
+          level: :info
+      start_watchdog
+    end
+
+    def process_message(message)
+      return super if handled_by_parent?(message)
+
+      case message
+      when StatusUnsubscribe, AggregatedStatusRequest
+        will_not_handle message
+      when AggregatedStatus
+        process_aggregated_status message
+      when AlarmIssue, AlarmSuspended, AlarmResumed, AlarmAcknowledged
+        process_alarm message
+      when CommandResponse
+        process_command_response message
+      when StatusResponse
+        process_status_response message
+      when StatusUpdate
+        process_status_update message
+      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)
+      message.is_a?(CommandRequest) || message.is_a?(StatusRequest) || message.is_a?(StatusSubscribe)
+    end
+
+    def version_accepted(message)
+      log "Received Version message for site #{@site_id}", message: message, level: :log
+      start_timer
+      acknowledge message
+      send_version @site_id, core_versions
+      @version_determined = true
+    end
+
+    def acknowledged_first_ingoing(message)
+      case message.type
+      when 'Watchdog'
+        send_watchdog
+      end
+    end
+
+    def acknowledged_first_outgoing(message)
+      case message.type
+      when 'Watchdog'
+        handshake_complete
+      end
+    end
+
+    def validate_ready(action)
+      raise NotReady, "Can't #{action} because connection is not ready. (Currently #{@state})" unless ready?
+    end
+
+    def version_acknowledged; end
+
+    def site_ids_changed
+      @supervisor.site_ids_changed
+    end
+
+    def watchdog_interval=(interval)
+      @settings['intervals']['watchdog'] = interval
+    end
+
+    def check_sxl_version(message)
+      # check that we have a schema for specified sxl type and version
+      # note that the type comes from the site config, while the version
+      # comes from the Version message send by the site
+      type = @site_settings['sxl']
+      version = message.attribute 'SXL'
+      RSMP::Schema.find_schema! type, version, lenient: true
+
+      # store sxl version requested by site
+      # TODO should check agaist site settings
+      @site_sxl_version = message.attribute 'SXL'
+    rescue RSMP::Schema::UnknownSchemaError => e
+      dont_acknowledge message, "Rejected #{message.type} message,", e.to_s
+    end
+
+    def sxl_version
+      # a supervisor does not maintain it's own sxl version
+      # instead we use what the site requests
+      @site_sxl_version
+    end
+
+    def process_version(message)
+      return extraneous_version message if @version_determined
+
+      check_site_ids message
+      check_sxl_version message
+      version_accepted message
+    end
+
+    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
+      @supervisor.check_site_id site_id
+      site_ids_changed
+    end
+
+    def find_site_settings(_site_id)
+      if @settings['sites'] && @settings['sites'][@site_id]
+        log "Using site settings for site id #{@site_id}", level: :debug
+        return @settings['sites'][@site_id]
+      end
+
+      @settings['guest']
+      if @settings['guest']
+        log 'Using site settings for guest', level: :debug
+        return @settings['guest']
+      end
+
+      nil
+    end
+
+    def setup_site_settings
+      @site_settings = find_site_settings @site_id
+      if @site_settings
+        @sxl = @site_settings['sxl']
+        setup_components @site_settings['components']
+      else
+        dont_acknowledge message, 'Rejected', "No config found for site #{@site_id}"
+      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'
+        ComponentProxy.new id: id, node: self, grouped: true,
+                           ntsoid: settings['ntsOId'], xnid: settings['xNId']
+      else
+        ComponentProxy.new id: id, node: self, grouped: false
+      end
+    end
+
+    def infer_component_type(_component_id)
+      ComponentProxy
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module RSMP
+  class SupervisorProxy < Proxy
+    module Modules
+      # Handles aggregated status messages
+      module AggregatedStatus
+        def send_all_aggregated_status
+          @site.components.each_pair do |_c_id, component|
+            send_aggregated_status component if component.grouped
+          end
+        end
+
+        # Send aggregated status for a component
+        def send_aggregated_status(component, options = {})
+          m_id = options[:m_id] || RSMP::Message.make_m_id
+
+          se = if Proxy.version_meets_requirement?(core_version, '<=3.1.2')
+                 component.aggregated_status_bools.map { |bool| bool ? 'true' : 'false' }
+               else
+                 component.aggregated_status_bools
+               end
+
+          message = RSMP::AggregatedStatus.new({
+                                                 'aSTS' => clock.to_s,
+                                                 'cId' => component.c_id,
+                                                 'fP' => nil,
+                                                 'fS' => nil,
+                                                 'se' => se,
+                                                 'mId' => m_id
+                                               })
+
+          apply_nts_message_attributes message
+          send_and_optionally_collect message, options do |collect_options|
+            Collector.new self, collect_options.merge(task: @task, type: 'MessageAck')
+          end
+        end
+
+        def process_aggregated_status_request(message)
+          log "Received #{message.type}", message: message, level: :log
+          component_id = message.attributes['cId']
+          component = @site.find_component component_id
+          acknowledge message
+          send_aggregated_status component
+        end
+      end
+    end
+  end
+end