rsmp 0.37.0 → 0.38.0

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

@@ -0,0 +1,73 @@
+module RSMP
+  class SupervisorProxy < Proxy
+    module Modules
+      # Alarm handling
+      module Alarms
+        def send_alarm(_component, alarm, options = {})
+          send_and_optionally_collect alarm, options do |collect_options|
+            Collector.new self, collect_options.merge(task: @task, type: 'MessageAck')
+          end
+        end
+
+        def send_active_alarms
+          @site.components.each_pair do |_c_id, component|
+            component.alarms.each_pair do |_alarm_code, alarm_state|
+              if alarm_state.active
+                alarm = AlarmIssue.new(alarm_state.to_hash.merge('aSp' => 'Issue'))
+                send_message alarm
+              end
+            end
+          end
+        end
+
+        def process_alarm(message)
+          case message
+          when AlarmAcknowledge
+            handle_alarm_acknowledge message
+          when AlarmSuspend
+            handle_alarm_suspend message
+          when AlarmResume
+            handle_alarm_resume message
+          when AlarmRequest
+            handle_alarm_request message
+          else
+            dont_acknowledge message, 'Invalid alarm message type'
+          end
+        end
+
+        def handle_alarm_acknowledge(message)
+          component_id = message.attributes['cId']
+          component = @site.find_component component_id
+          alarm_code = message.attribute('aCId')
+          log "Received #{message.type} #{alarm_code} acknowledgement", message: message, level: :log
+          acknowledge message
+          component.acknowledge_alarm alarm_code
+        end
+
+        def handle_alarm_suspend(message)
+          component_id = message.attributes['cId']
+          component = @site.find_component component_id
+          alarm_code = message.attribute('aCId')
+          log "Received #{message.type} #{alarm_code} suspend", message: message, level: :log
+          acknowledge message
+          component.suspend_alarm alarm_code
+        end
+
+        def handle_alarm_resume(message)
+          component_id = message.attributes['cId']
+          component = @site.find_component component_id
+          alarm_code = message.attribute('aCId')
+          log "Received #{message.type} #{alarm_code} resume", message: message, level: :log
+          acknowledge message
+          component.resume_alarm alarm_code
+        end
+
+        def handle_alarm_request(message)
+          log "Received #{message.type}", message: message, level: :log
+          acknowledge message
+          send_active_alarms
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module RSMP
+  class SupervisorProxy < Proxy
+    module Modules
+      # Command request handling
+      module Commands
+        def simplify_command_requests(arg)
+          sorted = {}
+          arg.each do |item|
+            sorted[item['cCI']] ||= {}
+            sorted[item['cCI']][item['n']] = item['v']
+          end
+          sorted
+        end
+
+        def build_command_rvs(args)
+          args.map do |item|
+            item = item.dup.merge('age' => 'recent')
+            item.delete 'cO'
+            item
+          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
+          end
+          log "Received #{message.type}", message: message, level: :log
+        rescue UnknownComponent
+          log "Received #{message.type} with unknown component id '#{component_id}' and cannot infer type",
+              message: message, level: :warning
+          rvs.map { |item| item['age'] = 'undefined' }
+        end
+
+        def process_command_request(message)
+          component_id = message.attributes['cId']
+          rvs = build_command_rvs(message.attributes['arg'])
+          execute_commands(message, component_id, rvs)
+
+          response = CommandResponse.new({
+                                           'cId' => component_id,
+                                           'cTS' => clock.to_s,
+                                           'rvs' => rvs
+                                         })
+          apply_nts_message_attributes response
+          acknowledge message
+          send_message response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,204 @@
+module RSMP
+  class SupervisorProxy < Proxy
+    module Modules
+      # Status request and subscription handling
+      module Status
+        def rsmpify_value(value, quality)
+          if value.is_a?(Array) || value.is_a?(Set)
+            value
+          elsif %w[undefined unknown].include?(quality.to_s)
+            nil
+          else
+            value.to_s
+          end
+        end
+
+        def fetch_status_values(component, args)
+          args.map do |arg|
+            value, quality = component.get_status arg['sCI'], arg['n'], { sxl_version: sxl_version }
+            { 's' => rsmpify_value(value, quality), 'q' => quality.to_s }.merge arg
+          end
+        end
+
+        def build_undefined_statuses(args)
+          args.map { |arg| arg.dup.merge('q' => 'undefined', 's' => nil) }
+        end
+
+        def process_status_request(message, options = {})
+          component_id = message.attributes['cId']
+          args = message.attributes['sS']
+
+          begin
+            component = @site.find_component component_id
+            ss = fetch_status_values(component, args)
+            log "Received #{message.type}", message: message, level: :log
+          rescue UnknownComponent
+            log "Received #{message.type} with unknown component id '#{component_id}' and cannot infer type",
+                message: message, level: :warning
+            ss = build_undefined_statuses(args)
+          end
+
+          response = StatusResponse.new({
+                                          'cId' => component_id,
+                                          'sTs' => clock.to_s,
+                                          'sS' => ss,
+                                          'mId' => options[:m_id]
+                                        })
+
+          apply_nts_message_attributes response
+          acknowledge message
+          send_message response
+        end
+
+        def add_status_subscription(component_id, subs, update_list, arg, now)
+          sci = arg['sCI']
+          name = arg['n']
+          subcription = { interval: arg['uRt'].to_i, last_sent_at: now }
+          subs[sci] ||= {}
+          subs[sci][name] = subcription
+          update_list[component_id][sci] ||= []
+          update_list[component_id][sci] << name
+        end
+
+        def process_status_subcribe(message)
+          log "Received #{message.type}", message: message, level: :log
+
+          update_list = {}
+          component_id = message.attributes['cId']
+          @status_subscriptions[component_id] ||= {}
+          update_list[component_id] ||= {}
+          now = Time.now
+          subs = @status_subscriptions[component_id]
+
+          message.attributes['sS'].each do |arg|
+            add_status_subscription(component_id, subs, update_list, arg, now)
+          end
+          acknowledge message
+          send_status_updates update_list
+        end
+
+        def get_status_subscribe_interval(component_id, sci, name)
+          @status_subscriptions.dig component_id, sci, name
+        end
+
+        def remove_status_subscription(subs, arg)
+          sci = arg['sCI']
+          return unless subs[sci]
+
+          subs[sci].delete arg['n']
+          subs.delete(sci) if subs[sci].empty?
+        end
+
+        def process_status_unsubcribe(message)
+          log "Received #{message.type}", message: message, level: :log
+          component = message.attributes['cId']
+
+          subs = @status_subscriptions[component]
+          if subs
+            message.attributes['sS'].each { |arg| remove_status_subscription(subs, arg) }
+            @status_subscriptions.delete(component) if subs.empty?
+          end
+          acknowledge message
+        end
+
+        def fetch_last_sent_status(component, code, name)
+          @last_status_sent&.dig component, code, name
+        end
+
+        def store_last_sent_status(message)
+          component_id = message.attribute('cId')
+          @last_status_sent ||= {}
+          @last_status_sent[component_id] ||= {}
+          message.attribute('sS').each do |item|
+            sci = item['sCI']
+            n = item['n']
+            s = item['s']
+            @last_status_sent[component_id][sci] ||= {}
+            @last_status_sent[component_id][sci][n] = s
+          end
+        end
+
+        def check_on_change_update(subscription, component, code, name)
+          return [nil, false] unless subscription[:interval].zero?
+
+          current = nil
+          if component
+            current, quality = *(component.get_status code, name)
+            current = rsmpify_value(current, quality)
+          end
+          last_sent = fetch_last_sent_status component.c_id, code, name
+          [current, current != last_sent]
+        end
+
+        def interval_update_due?(subscription, now)
+          return true if subscription[:last_sent_at].nil?
+
+          (now - subscription[:last_sent_at]) >= subscription[:interval]
+        end
+
+        def check_status_subscription(subscription, component, code, name, now)
+          current, should_send = check_on_change_update(subscription, component, code, name)
+          should_send ||= interval_update_due?(subscription, now)
+          return [nil, false] unless should_send
+
+          subscription[:last_sent_at] = now
+          [current, true]
+        end
+
+        def status_update_timer(now)
+          update_list = {}
+
+          @status_subscriptions.each_pair do |component_id, by_code|
+            component = @site.find_component component_id
+            by_code.each_pair do |code, by_name|
+              by_name.each_pair do |name, subscription|
+                current, should_send = check_status_subscription(subscription, component, code, name, now)
+                next unless should_send
+
+                update_list[component_id] ||= {}
+                update_list[component_id][code] ||= {}
+                update_list[component_id][code][name] = current
+              end
+            end
+          end
+          send_status_updates update_list
+        end
+
+        def build_status_list(component, by_code)
+          ss = []
+          by_code.each_pair do |code, names|
+            names.map do |status_name, value|
+              if value
+                quality = 'recent'
+              else
+                value, quality = component.get_status code, status_name
+              end
+              ss << { 'sCI' => code,
+                      'n' => status_name,
+                      's' => rsmpify_value(value, quality),
+                      'q' => quality }
+            end
+          end
+          ss
+        end
+
+        def send_status_updates(update_list)
+          now = clock.to_s
+          update_list.each_pair do |component_id, by_code|
+            component = @site.find_component component_id
+            ss = build_status_list(component, by_code)
+            update = StatusUpdate.new({
+                                        'cId' => component_id,
+                                        'sTs' => now,
+                                        'sS' => ss
+                                      })
+            apply_nts_message_attributes update
+            send_message update
+            store_last_sent_status update
+            component.status_updates_sent
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/proxy/supervisor/supervisor_proxy.rb

@@ -0,0 +1,178 @@
+# Handles a site connection to a remote supervisor
+
+require 'digest'
+
+module RSMP
+  class SupervisorProxy < Proxy
+    include Modules::Status
+    include Modules::Commands
+    include Modules::Alarms
+    include Modules::AggregatedStatus
+
+    attr_reader :supervisor_id, :site
+
+    def initialize(options)
+      super(options.merge(node: options[:site]))
+      @site = options[:site]
+      @site_settings = @site.site_settings.clone
+      @ip = options[:ip]
+      @port = options[:port]
+      @status_subscriptions = {}
+      @sxl = @site_settings['sxl']
+      @synthetic_id = Supervisor.build_id_from_ip_port @ip, @port
+    end
+
+    # handle communication
+    # if disconnected, then try to reconnect
+    def run
+      loop do
+        connect
+        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
+        break unless reconnect_delay?
+      ensure
+        close
+        stop_subtasks
+      end
+    end
+
+    def start_handshake
+      send_version @site_settings['site_id'], core_versions
+    end
+
+    # connect to the supervisor and initiate handshake supervisor
+    def connect
+      log "Connecting to supervisor at #{@ip}:#{@port}", level: :info
+      self.state = :connecting
+      connect_tcp
+      @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}"
+    end
+
+    def stop_task
+      super
+      @last_status_sent = nil
+    end
+
+    def connect_tcp
+      @endpoint = IO::Endpoint.tcp(@ip, @port)
+
+      # this timeout is a workaround for connect hanging on windows if the other side is not present yet
+      timeout = @site_settings.dig('timeouts', 'connect') || 1.1
+      task.with_timeout timeout do
+        @socket = @endpoint.connect
+      end
+      delay = @site_settings.dig('intervals', 'after_connect')
+      task.sleep delay if delay
+
+      @stream = IO::Stream::Buffered.new(@socket)
+      @protocol = RSMP::Protocol.new(@stream) # rsmp messages are json terminated with a form-feed
+      self.state = :connected
+    rescue Errno::ECONNREFUSED => e # rescue to avoid log output
+      log 'Connection refused', level: :warning
+      raise e
+    end
+
+    def handshake_complete
+      sanitized_sxl_version = RSMP::Schema.sanitize_version(sxl_version)
+      log "Connection to supervisor established, using core #{@core_version}, #{sxl} #{sanitized_sxl_version}",
+          level: :info
+      self.state = :ready
+      start_watchdog
+      if @site_settings['send_after_connect']
+        send_all_aggregated_status
+        send_active_alarms
+      end
+      super
+    end
+
+    def process_message(message)
+      case message
+      when StatusResponse, StatusUpdate, AggregatedStatus, AlarmIssue
+        will_not_handle message
+      when AggregatedStatusRequest
+        process_aggregated_status_request message
+      when CommandRequest
+        process_command_request message
+      when CommandResponse
+        process_command_response message
+      when StatusRequest
+        process_status_request message
+      when StatusSubscribe
+        process_status_subcribe message
+      when StatusUnsubscribe
+        process_status_unsubcribe message
+      when Alarm, AlarmAcknowledged, AlarmSuspend, AlarmResume, AlarmRequest
+        process_alarm message
+      else
+        super
+      end
+    rescue UnknownComponent, UnknownCommand, UnknownStatus,
+           MessageRejected, MissingAttribute => e
+      dont_acknowledge message, '', e.to_s
+    end
+
+    def acknowledged_first_ingoing(message)
+      case message.type
+      when 'Watchdog'
+        handshake_complete
+      end
+    end
+
+    def reconnect_delay?
+      return false if @site_settings['intervals']['reconnect'] == :no
+
+      interval = @site_settings['intervals']['reconnect']
+      log "Will try to reconnect again every #{interval} seconds...", level: :info
+      @logger.mute @ip, @port
+      @task.sleep interval
+      true
+    end
+
+    def version_accepted(message)
+      log "Received Version message, using RSMP #{@core_version}", message: message, level: :log
+      start_timer
+      acknowledge message
+      @version_determined = true
+      send_watchdog
+    end
+
+    def timer(now)
+      super
+      status_update_timer now if ready?
+    end
+
+    def sxl_version
+      @site_settings['sxl_version'].to_s
+    end
+
+    def process_version(message)
+      return extraneous_version message if @version_determined
+
+      check_core_version message
+      check_sxl_version message
+      @site_id = Supervisor.build_id_from_ip_port @ip, @port
+      version_accepted message
+    end
+
+    def check_sxl_version(message); end
+
+    def main
+      @site.main
+    end
+  end
+end

data/lib/rsmp/tlc/detector_logic.rb

@@ -3,22 +3,22 @@ module RSMP
     class DetectorLogic < Component
       attr_reader :forced, :value
 
-      def initialize node:, id:
-        super node: node, id: id, grouped: false
+      def initialize(node:, id:)
+        super(node: node, id: id, grouped: false)
         @forced = 0
         @value = 0
       end
 
-      def get_status code, name=nil, options={}
+      def get_status(code, name = nil, _options = {})
         case code
         when 'S0201', 'S0202', 'S0203', 'S0204'
-          return send("handle_#{code.downcase}", code, name)
+          send("handle_#{code.downcase}", code, name)
         else
-          raise InvalidMessage.new "unknown status code #{code}"
+          raise InvalidMessage, "unknown status code #{code}"
         end
       end
 
-      def handle_s0201 status_code, status_name=nil, options={}
+      def handle_s0201(_status_code, status_name = nil, _options = {})
         case status_name
         when 'starttime'
           TrafficControllerSite.make_status @node.clock.to_s
@@ -27,7 +27,7 @@ module RSMP
         end
       end
 
-      def handle_s0202 status_code, status_name=nil, options={}
+      def handle_s0202(_status_code, status_name = nil, _options = {})
         case status_name
         when 'starttime'
           TrafficControllerSite.make_status @node.clock.to_s
@@ -36,7 +36,7 @@ module RSMP
         end
       end
 
-      def handle_s0203 status_code, status_name=nil, options={}
+      def handle_s0203(_status_code, status_name = nil, _options = {})
         case status_name
         when 'starttime'
           TrafficControllerSite.make_status @node.clock.to_s
@@ -45,57 +45,41 @@ module RSMP
         end
       end
 
-      def handle_s0204 status_code, status_name=nil, options={}
+      def handle_s0204(_status_code, status_name = nil, _options = {})
         case status_name
         when 'starttime'
           TrafficControllerSite.make_status @node.clock.to_s
-        when 'P'
-          TrafficControllerSite.make_status 0
-        when 'PS'
-          TrafficControllerSite.make_status 0
-        when 'L'
-          TrafficControllerSite.make_status 0
-        when 'LS'
-          TrafficControllerSite.make_status 0
-        when 'B'
-          TrafficControllerSite.make_status 0
-        when 'SP'
-          TrafficControllerSite.make_status 0
-        when 'MC'
-          TrafficControllerSite.make_status 0
-        when 'C'
-          TrafficControllerSite.make_status 0
-        when 'F'
+        when 'P', 'PS', 'L', 'LS', 'B', 'SP', 'MC', 'C', 'F'
           TrafficControllerSite.make_status 0
         end
       end
 
-      def handle_command command_code, arg, options={}
+      def handle_command(command_code, arg, _options = {})
         case command_code
         when 'M0008'
           handle_m0008 arg
         else
-          raise UnknownCommand.new "Unknown command #{command_code}"
+          raise UnknownCommand, "Unknown command #{command_code}"
         end
       end
 
-      def handle_m0008 arg, options={}
+      def handle_m0008(arg, _options = {})
         @node.verify_security_code 2, arg['securityCode']
-        status = arg['status']=='True'
-        mode = arg['mode']=='True'
+        status = arg['status'] == 'True'
+        mode = arg['mode'] == 'True'
         force_detector_logic status, mode
         arg
       end
 
-      def force_detector_logic forced, value
+      def force_detector_logic(forced, value)
         @forced = forced
         @value = value
         if @forced
           log "Forcing to #{value}", level: :info
         else
-          log "Releasing", level: :info
+          log 'Releasing', level: :info
         end
       end
     end
   end
-end
+end