rsmp 0.37.0 → 0.38.0

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

data/lib/rsmp/helpers/error.rb

@@ -0,0 +1,71 @@
+module RSMP
+  class Error < StandardError
+  end
+
+  class InvalidPacket < Error
+  end
+
+  class MalformedMessage < Error
+  end
+
+  class SchemaError < Error
+    attr_accessor :schemas
+  end
+
+  class InvalidMessage < Error
+  end
+
+  class UnknownMessage < Error
+  end
+
+  class MissingAcknowledgment < Error
+  end
+
+  class MissingWatchdog < Error
+  end
+
+  class MessageRejected < Error
+  end
+
+  class MissingAttribute < InvalidMessage
+  end
+
+  class FatalError < Error
+  end
+
+  class HandshakeError < FatalError
+  end
+
+  class NotReady < Error
+  end
+
+  class TimeoutError < Error
+  end
+
+  class DisconnectError < Error
+  end
+
+  class ConnectionError < Error
+  end
+
+  class UnknownComponent < Error
+  end
+
+  class UnknownCommand < Error
+  end
+
+  class UnknownStatus < Error
+  end
+
+  class ConfigurationError < Error
+  end
+
+  class RepeatedAlarmError < Error
+  end
+
+  class RepeatedStatusError < Error
+  end
+
+  class TimestampError < Error
+  end
+end

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

@@ -12,23 +12,20 @@
 
 module RSMP
   module Inspect
-
     def inspector *short_items
       instance_variables.map do |var_name|
         var = instance_variable_get(var_name)
         class_name = var.class.name
 
         short = short_items.include?(var_name) ||
-                   class_name.start_with?('Async') ||
-                   class_name.start_with?('RSMP')
+                class_name.start_with?('Async') ||
+                class_name.start_with?('RSMP')
 
         if short
-          if var.is_a? Array
-            "#{var_name}: #<#{class_name}:#{class_name.object_id}, #{var.size} items>"
-          elsif var.is_a? Hash
+          if var.is_a?(Array) || var.is_a?(Hash)
             "#{var_name}: #<#{class_name}:#{class_name.object_id}, #{var.size} items>"
           else
-            "#{var_name}: #{var.to_s}"
+            "#{var_name}: #{var}"
           end
         else
           "#{var_name}: #{var.inspect}"
@@ -39,8 +36,7 @@ module RSMP
     # override this if you want additional variable to be shown in the short format,
     # or ottherwise change the inspect format
     def inspect
-      "#<#{self.class.name}:#{self.object_id}, #{inspector}>"
+      "#<#{self.class.name}:#{object_id}, #{inspector}>"
     end
-
   end
-end
+end

data/lib/rsmp/log/archive.rb

@@ -0,0 +1,98 @@
+# Archive of log items, which can be messages or info items.
+# All items are timestamped, and stored chronologically.
+
+module RSMP
+  class Archive
+    include Inspect
+
+    attr_reader :items
+
+    @index = 0
+
+    class << self
+      attr_accessor :index
+    end
+
+    def initialize(max = 100)
+      @items = []
+      @max = max
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id}, #{inspector(:@items)}>"
+    end
+
+    def self.prepare_item(item)
+      raise ArgumentError unless item.is_a? Hash
+
+      cleaned = item.slice(:author, :level, :ip, :port, :site_id, :component, :text, :message, :exception)
+      cleaned[:timestamp] = Clock.now
+      if item[:message]
+        cleaned[:direction] = item[:message].direction
+        cleaned[:component] = item[:message].attributes['cId']
+      end
+
+      cleaned
+    end
+
+    def self.increase_index
+      self.index += 1
+    end
+
+    def self.current_index
+      index
+    end
+
+    def by_level(levels)
+      items.select { |item| levels.include? item[:level] }
+    end
+
+    def strings
+      items.map { |item| item[:str] }
+    end
+
+    def add(item)
+      item[:index] = RSMP::Archive.increase_index
+      @items << item
+      return unless @items.size > @max
+
+      @items.shift
+    end
+
+    private
+
+    def find(options, &)
+      # search backwards from newest to older, stopping once messages
+      # are older that options[:earliest]
+      out = []
+      @items.reverse_each do |item|
+        break if too_old?(item, options[:earliest])
+        next unless matches_filters?(item, options, &)
+
+        out.unshift item
+      end
+      out
+    end
+
+    def too_old?(item, earliest)
+      earliest && item[:timestamp] < earliest
+    end
+
+    def matches_filters?(item, options, &block)
+      return false if options[:level] && item[:level] != options[:level]
+      return false if options[:type] && !matches_type?(item, options[:type])
+      return false if options[:with_message] && !message?(item)
+      return false if block_given? && block.call != true
+
+      true
+    end
+
+    def matches_type?(item, type)
+      item[:message] && item[:message].type == type
+    end
+
+    def message?(item)
+      item[:direction] && item[:message]
+    end
+  end
+end

data/lib/rsmp/log/colorization.rb

@@ -0,0 +1,41 @@
+module RSMP
+  class Logger
+    # Handles colorization of log output
+    module Colorization
+      def default_colors
+        {
+          'info' => 'white',
+          'log' => 'light_blue',
+          'statistics' => 'light_black',
+          'warning' => 'light_yellow',
+          'error' => 'red',
+          'debug' => 'light_black',
+          'collect' => 'light_black'
+        }
+      end
+
+      def colorize_with_map(level, str, colors)
+        color = colors[level.to_s]
+        color ? str.colorize(color.to_sym) : str
+      end
+
+      def apply_hash_colors(level, str)
+        colors = default_colors
+        colors.merge! @settings['color'] if @settings['color'].is_a?(Hash)
+        colorize_with_map(level, str, colors)
+      end
+
+      def colorize(level, str)
+        return str if @settings['color'] == false || @settings['color'].nil?
+
+        if @settings['color'] == true || @settings['color'].is_a?(Hash)
+          apply_hash_colors(level, str)
+        elsif %i[nack warning error].include?(level)
+          str.colorize(@settings['color']).bold
+        else
+          str.colorize @settings['color']
+        end
+      end
+    end
+  end
+end