rsmp 0.35.2 → 0.38.0

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

data/lib/rsmp/convert/export/json_schema.rb

@@ -8,179 +8,187 @@ module RSMP
   module Convert
     module Export
       module JSONSchema
-
-        @@json_options = {
+        JSON_OPTIONS = {
           array_nl: "\n",
           object_nl: "\n",
           indent: '  ',
           space_before: ' ',
           space: ' '
-        }
+        }.freeze
 
-        def self.output_json item
-          JSON.generate(item,@@json_options)
+        def self.output_json(item)
+          JSON.generate(item, JSON_OPTIONS)
         end
 
-        def self.build_value item
+        def self.build_value(item)
           out = {}
-
-          if item['description']
-            out["description"] = item['description']
-          end
+          out['description'] = item['description'] if item['description']
 
           if item['list']
-            case item['type']
-            when "boolean"
-              out["$ref"] = "../../../core/3.1.1/definitions.json#/boolean_list"
-            when "integer", "ordinal", "unit", "scale", "long"
-              out["$ref"] = "../../../core/3.1.1/definitions.json#/integer_list"
-            else
-              raise "Error: List of #{item['type']} is not supported: #{item.inspect}"
-            end
+            build_list_value(out, item)
+          else
+            build_single_value(out, item)
+          end
 
-            if item["values"]
-              value_list = item["values"].keys.join('|')
-              out['pattern'] = /(?-mix:^(#{value_list})(?:,(#{value_list}))*$)/
-            end
+          out
+        end
 
-            if item["pattern"]
-              puts "Warning: Pattern not support for lists: #{item.inspect}"
-            end
+        def self.build_list_value(out, item)
+          case item['type']
+          when 'boolean'
+            out['$ref'] = '../../../core/3.1.1/definitions.json#/boolean_list'
+          when 'integer', 'ordinal', 'unit', 'scale', 'long'
+            out['$ref'] = '../../../core/3.1.1/definitions.json#/integer_list'
           else
-            case item['type']
-            when "string", "base64"
-              out["type"] = "string"
-            when "boolean"
-              out["$ref"] = "../../../core/3.1.1/definitions.json#/boolean"
-            when "timestamp"
-              out["$ref"] = "../../../core/3.1.1/definitions.json#/timestamp"
-            when "integer", "ordinal", "unit", "scale", "long"
-              out["$ref"] = "../../../core/3.1.1/definitions.json#/integer"
-            else
-              out["type"] = "string"
-            end
-
-            if item["values"]
-              out["enum"] = item["values"].keys.sort
-            end
+            raise "Error: List of #{item['type']} is not supported: #{item.inspect}"
+          end
 
-            if item["pattern"]
-              out["pattern"] = item["pattern"]
-            end
+          if item['values']
+            value_list = item['values'].keys.join('|')
+            out['pattern'] = /(?-mix:^(#{value_list})(?:,(#{value_list}))*$)/
           end
 
+          puts "Warning: Pattern not support for lists: #{item.inspect}" if item['pattern']
+        end
+
+        def self.build_single_value(out, item)
+          case item['type']
+          when 'boolean'
+            out['$ref'] = '../../../core/3.1.1/definitions.json#/boolean'
+          when 'timestamp'
+            out['$ref'] = '../../../core/3.1.1/definitions.json#/timestamp'
+          when 'integer', 'ordinal', 'unit', 'scale', 'long'
+            out['$ref'] = '../../../core/3.1.1/definitions.json#/integer'
+          else # includes 'string', 'base64' and any other types
+            out['type'] = 'string'
+          end
 
-          out
+          out['enum'] = item['values'].keys.sort if item['values']
+          out['pattern'] = item['pattern'] if item['pattern']
         end
 
-        def self.build_item item, property_key: 'v'
-          json = { "allOf" => [ { "description" => item['description'] } ] }
+        def self.build_item(item, property_key: 'v')
+          json = { 'allOf' => [{ 'description' => item['description'] }] }
           if item['arguments']
-            json["allOf"].first["properties"] = { "n" => { "enum" => item['arguments'].keys.sort } }
-            item['arguments'].each_pair do |key,argument|
-              json["allOf"] << {
-                "if" => { "required" => ["n"], "properties" => { "n" => { "const" => key }}},
-                "then" => { "properties" => { property_key => build_value(argument) } }
+            json['allOf'].first['properties'] = { 'n' => { 'enum' => item['arguments'].keys.sort } }
+            item['arguments'].each_pair do |key, argument|
+              json['allOf'] << {
+                'if' => { 'required' => ['n'], 'properties' => { 'n' => { 'const' => key } } },
+                'then' => { 'properties' => { property_key => build_value(argument) } }
               }
             end
           end
           json
         end
 
-        def self.output_alarms out, items
+        def self.output_alarms(out, items)
           list = items.keys.sort.map do |key|
             {
-              "if" => { "required" => ["aCId"], "properties" => { "aCId" => { "const" => key }}},
-              "then" => { "$ref" => "#{key}.json" }
+              'if' => { 'required' => ['aCId'], 'properties' => { 'aCId' => { 'const' => key } } },
+              'then' => { '$ref' => "#{key}.json" }
             }
           end
           json = {
-            "properties" => {
-              "aCId" => { "enum" => items.keys.sort },
-              "rvs" => { "items" => { "allOf" => list } }
+            'properties' => {
+              'aCId' => { 'enum' => items.keys.sort },
+              'rvs' => { 'items' => { 'allOf' => list } }
             }
           }
           out['alarms/alarms.json'] = output_json json
-          items.each_pair { |key,item| output_alarm out, key, item }
+          items.each_pair { |key, item| output_alarm out, key, item }
         end
 
-        def self.output_alarm out, key, item
+        def self.output_alarm(out, key, item)
           json = build_item item
           out["alarms/#{key}.json"] = output_json json
         end
 
-        def self.output_statuses out, items
-          list = [ { "properties" => { "sCI" => { "enum"=> items.keys.sort }}} ]
+        def self.output_statuses(out, items)
+          list = [{ 'properties' => { 'sCI' => { 'enum' => items.keys.sort } } }]
           items.keys.sort.each do |key|
             list << {
-              "if"=> { "required" => ["sCI"], "properties" => { "sCI"=> { "const"=> key }}},
-              "then" => { "$ref" => "#{key}.json" }
+              'if' => { 'required' => ['sCI'], 'properties' => { 'sCI' => { 'const' => key } } },
+              'then' => { '$ref' => "#{key}.json" }
             }
           end
-          json = { "properties" => { "sS" => { "items" => { "allOf" => list }}}}
+          json = { 'properties' => { 'sS' => { 'items' => { 'allOf' => list } } } }
           out['statuses/statuses.json'] = output_json json
-          items.each_pair { |key,item| output_status out, key, item }
+          items.each_pair { |key, item| output_status out, key, item }
         end
 
-        def self.output_status out, key, item
-          json = build_item item, property_key:'s'
+        def self.output_status(out, key, item)
+          json = build_item item, property_key: 's'
           out["statuses/#{key}.json"] = output_json json
         end
 
-        def self.output_commands out, items
-          list = [ { "properties" => { "cCI" => { "enum"=> items.keys.sort }}} ]
+        def self.output_commands(out, items)
+          list = [{ 'properties' => { 'cCI' => { 'enum' => items.keys.sort } } }]
           items.keys.sort.each do |key|
             list << {
-              "if" => { "required" => ["cCI"], "properties" => { "cCI"=> { "const"=> key }}},
-              "then" => { "$ref" => "#{key}.json" }
+              'if' => { 'required' => ['cCI'], 'properties' => { 'cCI' => { 'const' => key } } },
+              'then' => { '$ref' => "#{key}.json" }
             }
           end
-          json = { "items" => { "allOf" => list }}
+          json = { 'items' => { 'allOf' => list } }
           out['commands/commands.json'] = output_json json
 
-          json = { "properties" => { "arg" => { "$ref" => "commands.json" }}}
+          json = { 'properties' => { 'arg' => { '$ref' => 'commands.json' } } }
           out['commands/command_requests.json'] = output_json json
 
-          json = { "properties" => { "rvs" => { "$ref" => "commands.json" }}}
+          json = { 'properties' => { 'rvs' => { '$ref' => 'commands.json' } } }
           out['commands/command_responses.json'] = output_json json
 
-          items.each_pair { |key,item| output_command out, key, item }
+          items.each_pair { |key, item| output_command out, key, item }
         end
 
-        def self.output_command out, key, item
+        def self.output_command(out, key, item)
           json = build_item item
-          json["allOf"].first["properties"]['cO'] = { "const" => item['command'] }
+          json['allOf'].first['properties']['cO'] = { 'const' => item['command'] }
           out["commands/#{key}.json"] = output_json json
         end
 
-        def self.output_root out, meta
-          json = {
-            "name"=> meta['name'],
-            "description"=> meta['description'],
-            "version"=> meta['version'],
-            "allOf" => [
-              {
-                "if" => { "required" => ["type"], "properties" => { "type" => { "const" => "CommandRequest" }}},
-                "then" => { "$ref" => "commands/command_requests.json" }
-              },
-              {
-                "if" => { "required" => ["type"], "properties" => { "type" => { "const" => "CommandResponse" }}},
-                "then" => { "$ref" => "commands/command_responses.json" }
-              },
-              {
-                "if" => { "required" => ["type"], "properties" => { "type" => { "enum" => ["StatusRequest","StatusResponse","StatusSubscribe","StatusUnsubscribe","StatusUpdate"] }}},
-                "then" => { "$ref" => "statuses/statuses.json" }
-              },
-              {
-                "if" => { "required" => ["type"], "properties" => { "type" => { "const" => "Alarm" }}},
-                "then" => { "$ref" => "alarms/alarms.json" }
-              }
-            ]
+        def self.build_root_schema(meta)
+          {
+            'name' => meta['name'],
+            'description' => meta['description'],
+            'version' => meta['version'],
+            'allOf' => build_root_refs
           }
-          out["sxl.json"] = output_json json
         end
 
-        def self.generate sxl
+        def self.build_root_refs
+          [
+            {
+              'if' => { 'required' => ['type'], 'properties' => { 'type' => { 'const' => 'CommandRequest' } } },
+              'then' => { '$ref' => 'commands/command_requests.json' }
+            },
+            {
+              'if' => { 'required' => ['type'], 'properties' => { 'type' => { 'const' => 'CommandResponse' } } },
+              'then' => { '$ref' => 'commands/command_responses.json' }
+            },
+            {
+              'if' => { 'required' => ['type'],
+                        'properties' => {
+                          'type' => {
+                            'enum' => %w[StatusRequest StatusResponse StatusSubscribe
+                                         StatusUnsubscribe StatusUpdate]
+                          }
+                        } },
+              'then' => { '$ref' => 'statuses/statuses.json' }
+            },
+            {
+              'if' => { 'required' => ['type'], 'properties' => { 'type' => { 'const' => 'Alarm' } } },
+              'then' => { '$ref' => 'alarms/alarms.json' }
+            }
+          ]
+        end
+
+        def self.output_root(out, meta)
+          json = build_root_schema(meta)
+          out['sxl.json'] = output_json json
+        end
+
+        def self.generate(sxl)
           out = {}
           output_root out, sxl[:meta]
           output_alarms out, sxl[:alarms]
@@ -189,18 +197,16 @@ module RSMP
           out
         end
 
-        def self.write sxl, folder
+        def self.write(sxl, folder)
           out = generate sxl
-          out.each_pair do |relative_path,str|
+          out.each_pair do |relative_path, str|
             path = File.join(folder, relative_path)
-            FileUtils.mkdir_p File.dirname(path)      # create folders if needed
-            file = File.open(path, 'w+')      # w+ means truncate or create new file
+            FileUtils.mkdir_p File.dirname(path) # create folders if needed
+            file = File.open(path, 'w+') # w+ means truncate or create new file
             file.puts str
           end
         end
-
       end
-
     end
   end
-end
+end

data/lib/rsmp/convert/import/yaml.rb

@@ -8,34 +8,37 @@ module RSMP
   module Convert
     module Import
       module YAML
-
-        def self.read path
+        def self.read(path)
           convert ::YAML.load_file(path)
         end
 
-        def self.parse str
+        def self.parse(str)
           convert ::YAML.load(str)
         end
 
-        def self.convert yaml
-          sxl = {
-            meta: {},
-            alarms: {},
-            statuses: {},
-            commands: {}
-          }
-
+        def self.convert(yaml)
+          sxl = build_empty_sxl
           sxl[:meta] = yaml['meta']
+          merge_objects(sxl, yaml['objects'])
+          sxl
+        end
+
+        def self.build_empty_sxl
+          { meta: {}, alarms: {}, statuses: {}, commands: {} }
+        end
 
-          yaml['objects'].each_pair do |type,object|
-            object["alarms"].each { |id,item| sxl[:alarms][id] = item } if object["alarms"]
-            object["statuses"].each { |id,item| sxl[:statuses][id] = item } if object["statuses"]
-            object["commands"].each { |id,item| sxl[:commands][id] = item } if object["commands"]
+        def self.merge_objects(sxl, objects)
+          objects.each_pair do |_type, object|
+            merge_object_items(sxl, object)
           end
-          sxl
         end
-      end
 
+        def self.merge_object_items(sxl, object)
+          object['alarms']&.each { |id, item| sxl[:alarms][id] = item }
+          object['statuses']&.each { |id, item| sxl[:statuses][id] = item }
+          object['commands']&.each { |id, item| sxl[:commands][id] = item }
+        end
+      end
     end
   end
-end
+end

data/lib/rsmp/{rsmp.rb → helpers/clock.rb}

@@ -6,7 +6,6 @@
 require 'time'
 
 module RSMP
-
   class Clock
     attr_reader :adjustment
 
@@ -14,7 +13,7 @@ module RSMP
       @adjustment = 0
     end
 
-    def set target
+    def set(target)
       @adjustment = target - Time.now
     end
 
@@ -34,12 +33,12 @@ module RSMP
       Time.now.utc
     end
 
-    def self.to_s time=nil
-      (time || now).strftime("%FT%T.%3NZ")
+    def self.to_s(time = nil)
+      (time || now).strftime('%FT%T.%3NZ')
     end
 
-    def self.parse str
+    def self.parse(str)
       Time.parse(str)
     end
   end
-end
+end

data/lib/rsmp/{deep_merge.rb → helpers/deep_merge.rb}

@@ -1,7 +1,8 @@
 class Hash
   def deep_merge(other_hash)
     return self unless other_hash
-    self.merge(other_hash) do |key, old, fresh|
+
+    merge(other_hash) do |_key, old, fresh|
       if old.is_a?(Hash) && fresh.is_a?(Hash)
         old.deep_merge(fresh)
       else