rsmp 0.37.0 → 0.38.0

data/lib/rsmp/{alarm_state.rb → component/alarm_state.rb}

@@ -1,5 +1,4 @@
 module RSMP
-
   # The state of an alarm on a component.
   # The alarm state is for a particular alarm code,
   # a component typically have an alarm state for each
@@ -8,10 +7,8 @@ module RSMP
   class AlarmState
     attr_reader :component_id, :code, :acknowledged, :suspended, :active, :timestamp, :category, :priority, :rvs
 
-    def self.create_from_message component, message
-      self.new(
-        component: component,
-        code: message.attribute("aCId"),
+    def self.create_from_message(component, message)
+      options = {
         timestamp: RSMP::Clock.parse(message.attribute('aTs')),
         acknowledged: message.attribute('ack') == 'Acknowledged',
         suspended: message.attribute('aS') == 'Suspended',
@@ -19,22 +16,21 @@ module RSMP
         category: message.attribute('cat'),
         priority: message.attribute('pri').to_i,
         rvs: message.attribute('rvs')
-      )
+      }
+      new(component: component, code: message.attribute('aCId'), **options)
     end
 
-    def initialize component:, code:, 
-        suspended: false, acknowledged: false, active: false, timestamp: nil,
-        category: 'D', priority: 2, rvs: []
+    def initialize(component:, code:, **options)
       @component = component
       @component_id = component.c_id
       @code = code
-      @suspended = !!suspended
-      @acknowledged = !!acknowledged 
-      @active = !!active
-      @timestamp =  timestamp
-      @category = category || 'D'
-      @priority = priority || 2
-      @rvs = rvs
+      @suspended = !!options[:suspended]
+      @acknowledged = !!options[:acknowledged]
+      @active = !!options[:active]
+      @timestamp = options[:timestamp]
+      @category = options[:category] || 'D'
+      @priority = options[:priority] || 2
+      @rvs = options[:rvs] || []
     end
 
     def to_hash
@@ -52,19 +48,22 @@ module RSMP
     end
 
     def acknowledge
-      change, @acknowledged = !@acknowledged, true
+      change = !@acknowledged
+      @acknowledged = true
       update_timestamp if change
       change
     end
 
     def suspend
-      change, @suspended = !@suspended, true
+      change = !@suspended
+      @suspended = true
       update_timestamp if change
       change
     end
 
     def resume
-      change, @suspended = @suspended, false
+      change = @suspended
+      @suspended = false
       update_timestamp if change
       change
     end
@@ -73,29 +72,33 @@ module RSMP
     # is when it's activated. See:
     # https://rsmp-nordic.org/rsmp_specifications/core/3.2.0/applicability/basic_structure.html#alarm-status
     def activate
-      change, @active, @acknowledged = !@active, true, false
+      change = !@active
+      @active = true
+      @acknowledged = false
       update_timestamp if change
       change
     end
 
     def deactivate
-      change, @active = @active, false
+      change = @active
+      @active = false
       update_timestamp if change
       change
     end
-    
+
     def update_timestamp
       @timestamp = @component.now
     end
 
-    def differ_from_message? message
-      return true if RSMP::Clock.to_s(@timestamp) != message.attribute('aTs')
-      return true if message.attribute('ack') && @acknowledged != (message.attribute('ack').downcase == 'acknowledged')
-      return true if message.attribute('sS') && @suspended != (message.attribute('sS').downcase == 'suspended')
-      return true if message.attribute('aS') && @active != (message.attribute('aS').downcase == 'active')
-      return true if message.attribute('cat') && @category != message.attribute('cat')
-      return true if message.attribute('pri') && @priority != message.attribute('pri').to_i
-      #return true @rvs = message.attribute('rvs')
+    def differ_from_message?(message)
+      return true if timestamp_differs?(message)
+      return true if acknowledgment_differs?(message)
+      return true if suspension_differs?(message)
+      return true if activity_differs?(message)
+      return true if category_differs?(message)
+      return true if priority_differs?(message)
+
+      # return true @rvs = message.attribute('rvs')
       false
     end
 
@@ -103,20 +106,20 @@ module RSMP
       @timestamp = nil
     end
 
-    def older_message? message
-      return false if @timestamp == nil
+    def older_message?(message)
+      return false if @timestamp.nil?
+
       RSMP::Clock.parse(message.attribute('aTs')) < @timestamp
     end
 
     # update from rsmp message
     # component id, alarm code and specialization are not updated
-    def update_from_message message
+    def update_from_message(message)
       unless differ_from_message? message
-        raise RepeatedAlarmError.new("no changes from previous alarm #{message.m_id_short}")
-      end
-      if older_message? message
-        raise TimestampError.new("timestamp is earlier than previous alarm #{message.m_id_short}")
+        raise RepeatedAlarmError,
+              "no changes from previous alarm #{message.m_id_short}"
       end
+      raise TimestampError, "timestamp is earlier than previous alarm #{message.m_id_short}" if older_message? message
     ensure
       @timestamp = RSMP::Clock.parse message.attribute('aTs')
       @acknowledged = message.attribute('ack') == 'True'
@@ -126,5 +129,41 @@ module RSMP
       @priority = message.attribute('pri').to_i
       @rvs = message.attribute('rvs')
     end
+
+    private
+
+    def timestamp_differs?(message)
+      RSMP::Clock.to_s(@timestamp) != message.attribute('aTs')
+    end
+
+    def acknowledgment_differs?(message)
+      return false unless message.attribute('ack')
+
+      @acknowledged != (message.attribute('ack').downcase == 'acknowledged')
+    end
+
+    def suspension_differs?(message)
+      return false unless message.attribute('sS')
+
+      @suspended != (message.attribute('sS').downcase == 'suspended')
+    end
+
+    def activity_differs?(message)
+      return false unless message.attribute('aS')
+
+      @active != (message.attribute('aS').downcase == 'active')
+    end
+
+    def category_differs?(message)
+      return false unless message.attribute('cat')
+
+      @category != message.attribute('cat')
+    end
+
+    def priority_differs?(message)
+      return false unless message.attribute('pri')
+
+      @priority != message.attribute('pri').to_i
+    end
   end
 end

data/lib/rsmp/{component.rb → component/component.rb}

@@ -1,19 +1,19 @@
 module RSMP
   # RSMP component
   class Component < ComponentBase
-    def initialize node:, id:, ntsOId: nil, xNId: nil, grouped: false
+    def initialize(node:, id:, ntsoid: nil, xnid: nil, grouped: false)
       super
     end
 
-    def handle_command command_code, arg
-      raise UnknownCommand.new "Command #{command_code} not implemented by #{self.class}"
+    def handle_command(command_code, _arg)
+      raise UnknownCommand, "Command #{command_code} not implemented by #{self.class}"
     end
 
-    def get_status status_code, status_name=nil, options={}
-      raise UnknownStatus.new "Status #{status_code}/#{status_name} not implemented by #{self.class}"
+    def get_status(status_code, status_name = nil, _options = {})
+      raise UnknownStatus, "Status #{status_code}/#{status_name} not implemented by #{self.class}"
     end
 
-    def acknowledge_alarm alarm_code
+    def acknowledge_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       if alarm.acknowledge
         log "Acknowledging alarm #{alarm_code}", level: :info
@@ -23,17 +23,17 @@ module RSMP
       end
     end
 
-    def suspend_alarm alarm_code
+    def suspend_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       if alarm.suspend
         log "Suspending alarm #{alarm_code}", level: :info
         @node.alarm_suspended_or_resumed alarm
       else
         log "Alarm #{alarm_code} already suspended", level: :info
-      end       
+      end
     end
 
-    def resume_alarm alarm_code
+    def resume_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       if alarm.resume
         log "Resuming alarm #{alarm_code}", level: :info
@@ -43,22 +43,22 @@ module RSMP
       end
     end
 
-    def activate_alarm alarm_code
+    def activate_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       return unless alarm.activate
+
       log "Activating alarm #{alarm_code}", level: :info
       @node.alarm_activated_or_deactivated alarm
     end
 
-    def deactivate_alarm alarm_code
+    def deactivate_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       return unless alarm.deactivate
+
       log "Deactivating alarm #{alarm_code}", level: :info
       @node.alarm_activated_or_deactivated alarm
     end
 
-    def status_updates_sent
-    end
-    
+    def status_updates_sent; end
   end
-end
+end

data/lib/rsmp/component/component_base.rb

@@ -0,0 +1,89 @@
+module RSMP
+  # RSMP component base class.
+
+  class ComponentBase
+    include Inspect
+
+    attr_reader :c_id, :ntsoid, :xnid, :node, :alarms, :statuses,
+                :aggregated_status, :aggregated_status_bools, :grouped
+
+    AGGREGATED_STATUS_KEYS = %i[local_control
+                                communication_distruption
+                                high_priority_alarm
+                                medium_priority_alarm
+                                low_priority_alarm
+                                normal
+                                rest
+                                not_connected].freeze
+
+    def initialize(node:, id:, ntsoid: nil, xnid: nil, grouped: false)
+      if grouped == false && (ntsoid || xnid)
+        raise RSMP::ConfigurationError,
+              'ntsoid and xnid are only allowed for grouped objects'
+      end
+
+      @c_id = id
+      @ntsoid = ntsoid
+      @xnid = xnid
+      @node = node
+      @grouped = grouped
+      clear_aggregated_status
+      @alarms = {}
+    end
+
+    def now
+      node.now
+    end
+
+    def clear_alarm_timestamps
+      @alarms.each_value(&:clear_timestamp)
+    end
+
+    def get_alarm_state(alarm_code)
+      @alarms[alarm_code] ||= RSMP::AlarmState.new component: self, code: alarm_code
+    end
+
+    def clear_aggregated_status
+      @aggregated_status = []
+      @aggregated_status_bools = Array.new(8, false)
+      @aggregated_status_bools[5] = true
+    end
+
+    def log(str, options)
+      default = { component: c_id }
+      @node.log str, default.merge(options)
+    end
+
+    def set_aggregated_status(status, options = {})
+      status = [status] if status.is_a? Symbol
+      raise InvalidArgument unless status.is_a? Array
+
+      input = status & AGGREGATED_STATUS_KEYS
+      return unless input != @aggregated_status
+
+      AGGREGATED_STATUS_KEYS.each_with_index do |key, index|
+        @aggregated_status_bools[index] = status.include?(key)
+      end
+      aggregated_status_changed options
+    end
+
+    def aggregated_status_bools=(status)
+      raise InvalidArgument unless status.is_a? Array
+      raise InvalidArgument unless status.size == 8
+
+      return unless status != @aggregated_status_bools
+
+      @aggregated_status = []
+      AGGREGATED_STATUS_KEYS.each_with_index do |key, index|
+        on = status[index] == true
+        @aggregated_status_bools[index] = on
+        @aggregated_status << key if on
+      end
+      aggregated_status_changed
+    end
+
+    def aggregated_status_changed(options = {})
+      @node.aggregated_status_changed self, options
+    end
+  end
+end

data/lib/rsmp/component/component_proxy.rb

@@ -0,0 +1,75 @@
+module RSMP
+  # A proxy to a remote RSMP component.
+  class ComponentProxy < ComponentBase
+    def initialize(node:, id:, ntsoid: nil, xnid: nil, grouped: false)
+      super
+      @alarms = {}
+      @statuses = {}
+      @allow_repeat_updates = {}
+    end
+
+    # allow the next status update to be a repeat value
+    def allow_repeat_updates(subscribe_list)
+      subscribe_list.each do |item|
+        sci = item['sCI']
+        n = item['n']
+        @allow_repeat_updates[sci] ||= Set.new # Set is like an array, but with no duplicates
+        @allow_repeat_updates[sci] << n
+      end
+    end
+
+    # Check that were not receiving repeated update values.
+    # The check is not performed for item with an update interval.
+    def check_repeat_values(message, subscription_list)
+      message.attribute('sS').each do |item|
+        check_status_item_for_repeats(item, subscription_list)
+      end
+    end
+
+    def check_status_item_for_repeats(item, subscription_list)
+      status_code = item['sCI']
+      status_name = item['n']
+      return if update_rate_set?(subscription_list, status_code, status_name)
+      return unless should_check_repeats?(subscription_list, status_code, status_name)
+
+      new_values = { 's' => item['s'], 'q' => item['q'] }
+      old_values = @statuses.dig(status_code, status_name)
+      raise RSMP::RepeatedStatusError, "no change for #{status_code} '#{status_name}'" if new_values == old_values
+    end
+
+    def update_rate_set?(subscription_list, status_code, status_name)
+      urt = subscription_list.dig(c_id, status_code, status_name, 'uRt')
+      urt.to_i.positive?
+    end
+
+    def should_check_repeats?(subscription_list, status_code, status_name)
+      soc = subscription_list.dig(c_id, status_code, status_name, 'sOc')
+      return false if soc == false
+      return false if @allow_repeat_updates[status_code]&.include?(status_name)
+
+      true
+    end
+
+    # Store the latest status update values
+    def store_status(message)
+      message.attribute('sS').each do |item|
+        sci = item['sCI']
+        n = item['n']
+        s = item['s']
+        q = item['q']
+        @statuses[sci] ||= {}
+        @statuses[sci][n] = { 's' => s, 'q' => q }
+
+        # once a value is received, don't allow the value to be a repeat
+        @allow_repeat_updates[sci]&.delete(n)
+      end
+    end
+
+    # handle incoming alarm
+    def handle_alarm(message)
+      code = message.attribute('aCId')
+      alarm = get_alarm_state code
+      alarm.update_from_message message
+    end
+  end
+end

data/lib/rsmp/component/components.rb

@@ -0,0 +1,63 @@
+# Things shared between sites and site proxies
+
+module RSMP
+  module Components
+    attr_reader :components, :main
+
+    def initialize_components
+      @components = {}
+      @main = nil
+    end
+
+    def aggregated_status_changed(component, options = {}); end
+
+    def setup_components(settings)
+      return unless settings
+
+      check_main_component settings
+      settings.each_pair do |type, components_by_type|
+        next unless components_by_type
+
+        components_by_type.each_pair do |id, component_settings|
+          component_settings ||= {}
+          @components[id] = build_component(id: id, type: type, settings: component_settings)
+          @main = @components[id] if type == 'main'
+        end
+      end
+    end
+
+    def check_main_component(settings)
+      raise ConfigurationError, 'main component must be defined' unless settings['main'] && settings['main'].size >= 1
+      return unless settings['main'].size > 1
+
+      raise ConfigurationError, "only one main component can be defined, found #{settings['main'].keys.join(', ')}"
+    end
+
+    def add_component(component)
+      @components[component.c_id] = component
+    end
+
+    def infer_component_type(component_id)
+      raise UnknownComponent, "Component #{component_id} mising and cannot infer type"
+    end
+
+    def find_component(component_id, build: true)
+      component = @components[component_id]
+      return component if component
+
+      return unless build
+
+      inferred_type = infer_component_type component_id
+      component = inferred_type.new node: self, id: component_id
+      @components[component_id] = component
+      class_name = component.class.name.split('::').last
+      class_name << ' component' unless %w[Component ComponentProxy].include?(class_name)
+      log "Added component #{component_id} with the inferred type #{class_name}", level: :debug
+      component
+    end
+
+    def clear_alarm_timestamps
+      @components.each_value(&:clear_alarm_timestamps)
+    end
+  end
+end