aspera-cli 4.10.0 → 4.11.0

data/lib/aspera/fasp/transfer_spec.rb

@@ -16,10 +16,43 @@ module Aspera
         'fasp_port'   => UDP_PORT
       }.freeze
       # define constants for enums of parameters: <paramater>_<enum>, e.g. CIPHER_AES_128
-      Aspera::Fasp::Parameters.description.each do |k,v|
+      Aspera::Fasp::Parameters.description.each do |k, v|
         next unless v[:enum].is_a?(Array)
         v[:enum].each do |enum|
-          TransferSpec.const_set("#{k.to_s.upcase}_#{enum.upcase.gsub(/[^A-Z0-9]/,'_')}", enum.freeze)
+          TransferSpec.const_set("#{k.to_s.upcase}_#{enum.upcase.gsub(/[^A-Z0-9]/, '_')}", enum.freeze)
+        end
+      end
+      class << self
+        def ascp_opts_to_ts(tspec, opts)
+          return if opts.nil?
+          raise 'ascp options must be an Array' unless opts.is_a?(Array)
+          raise 'transfer spec must be a Hash' unless tspec.is_a?(Hash)
+          raise 'ascp options must be an Array or Strings' if opts.any?{|o|!o.is_a?(String)}
+          tspec['EX_ascp_args'] ||= []
+          raise 'EX_ascp_args must be an Array' unless tspec['EX_ascp_args'].is_a?(Array)
+          # TODO: translate command line args into transfer spec
+          # non translatable args are left in special ts parameter
+          tspec['EX_ascp_args'] = tspec['EX_ascp_args'].concat(opts)
+          return tspec
+        end
+
+        def action_to_direction(tspec, command)
+          raise 'transfer spec must be a Hash' unless tspec.is_a?(Hash)
+          tspec['direction'] = case command.to_sym
+          when :upload then DIRECTION_SEND
+          when :download then DIRECTION_RECEIVE
+          else raise 'Error: upload or download only'
+          end
+          return tspec
+        end
+
+        def action(tspec)
+          raise 'transfer spec must be a Hash' unless tspec.is_a?(Hash)
+          return case tspec['direction']
+                 when DIRECTION_SEND then :upload
+                 when DIRECTION_RECEIVE then :download
+                 else raise 'Error: upload or download only'
+                 end
         end
       end
     end

data/lib/aspera/fasp/uri.rb

@@ -5,10 +5,10 @@ require 'aspera/command_line_builder'
 
 module Aspera
   module Fasp
-    # translates a "faspe:" URI (used in Faspex) into transfer spec hash
+    # translates a "faspe:" URI (used in Faspex 4) into transfer spec hash
     class Uri
       def initialize(fasplink)
-        @fasp_uri = URI.parse(fasplink.gsub(' ','%20'))
+        @fasp_uri = URI.parse(fasplink.gsub(' ', '%20'))
         # TODO: check scheme is faspe
       end
 
@@ -34,16 +34,16 @@ module Aspera
           when 'minrate' then result_ts['min_rate_kbps'] = value.to_i
           when 'port' then result_ts['fasp_port'] = value.to_i
           when 'bwcap' then result_ts['target_rate_cap_kbps'] = value.to_i
-          when 'enc' then result_ts['cipher'] = value.gsub(/^aes/,'aes-').gsub(/cfb$/,'-cfb').gsub(/gcm$/,'-gcm').gsub(/--/,'-')
+          when 'enc' then result_ts['cipher'] = value.gsub(/^aes/, 'aes-').gsub(/cfb$/, '-cfb').gsub(/gcm$/, '-gcm').gsub(/--/, '-')
           when 'tags64' then result_ts['tags'] = JSON.parse(Base64.strict_decode64(value))
           when 'createpath' then result_ts['create_dir'] = CommandLineBuilder.yes_to_true(value)
           when 'fallback' then result_ts['http_fallback'] = CommandLineBuilder.yes_to_true(value)
           when 'lockpolicy' then result_ts['lock_rate_policy'] = CommandLineBuilder.yes_to_true(value)
           when 'lockminrate' then result_ts['lock_min_rate'] = CommandLineBuilder.yes_to_true(value)
-          when 'auth' then Log.log.debug("ignoring auth #{name}=#{value}") # TODO: translate into transfer spec ? yes/no
-          when 'v' then Log.log.debug("ignoring v #{name}=#{value}") # TODO: translate into transfer spec ? 2
-          when 'protect' then Log.log.debug("ignoring protect #{name}=#{value}") # TODO: translate into transfer spec ?
-          else Log.log.warn("URI parameter ignored: #{name} = #{value}")
+          when 'auth' then Log.log.debug{"ignoring auth #{name}=#{value}"} # TODO: translate into transfer spec ? yes/no
+          when 'v' then Log.log.debug{"ignoring v #{name}=#{value}"} # TODO: translate into transfer spec ? 2
+          when 'protect' then Log.log.debug{"ignoring protect #{name}=#{value}"} # TODO: translate into transfer spec ?
+          else Log.log.warn{"URI parameter ignored: #{name} = #{value}"}
           end
         end
         return result_ts

data/lib/aspera/faspex_gw.rb

@@ -37,12 +37,13 @@ module Aspera
 
         faspex_pkg_parameters = JSON.parse(request.body)
         faspex_pkg_delivery = faspex_pkg_parameters['delivery']
-        Log.log.debug("faspex pkg create parameters=#{faspex_pkg_parameters}")
+        Log.log.debug{"faspex pkg create parameters=#{faspex_pkg_parameters}"}
 
         # get recipient ids
         files_pkg_recipients = []
         faspex_pkg_delivery['recipients'].each do |recipient_email|
-          user_lookup = @aoc_api_user.read('contacts',
+          user_lookup = @aoc_api_user.read(
+            'contacts',
             { 'current_workspace_id' => @aoc_workspace_id, 'q' => recipient_email })[:data]
           raise StandardError,
             "no such unique user: #{recipient_email} / #{user_lookup}" unless !user_lookup.nil? && user_lookup.length.eql?(1)
@@ -67,7 +68,8 @@ module Aspera
         node_info = @aoc_api_user.read("nodes/#{the_package['node_id']}")[:data]
 
         #  get transfer token (for node)
-        node_auth_bearer_token = @aoc_api_user.oauth_token(scope: AoC.node_scope(node_info['access_key'],
+        node_auth_bearer_token = @aoc_api_user.oauth_token(scope: AoC.node_scope(
+          node_info['access_key'],
           AoC::SCOPE_NODE_USER))
 
         # tell Files what to expect in package: 1 transfer (can also be done after transfer)
@@ -123,7 +125,7 @@ module Aspera
           'links'         => { 'status' => 'unused' },
           'xfer_sessions' => [faspex_transfer_spec]
         }
-        Log.log.info("faspex_package_create_result=#{faspex_package_create_result}")
+        Log.log.info{"faspex_package_create_result=#{faspex_package_create_result}"}
         response.status = 200
         response.content_type = 'application/json'
         response.body = JSON.generate(faspex_package_create_result)
@@ -160,7 +162,7 @@ module Aspera
         SSLEnable:   true,
         SSLCertName: [['CN', WEBrick::Utils.getservername]]
       }
-      Log.log.info("Server started on port #{webrick_options[:Port]}")
+      Log.log.info{"Server started on port #{webrick_options[:Port]}"}
       @server = WEBrick::HTTPServer.new(webrick_options)
       @server.mount('/aspera/faspex', FxGwServlet, a_aoc_api_user, a_workspace_id)
       @server.mount('/newuser', NewUserServlet)

data/lib/aspera/hash_ext.rb

@@ -2,11 +2,11 @@
 
 class ::Hash
   def deep_merge(second)
-    merge(second){|_key,v1,v2|Hash === v1 && Hash === v2 ? v1.deep_merge(v2) : v2}
+    merge(second){|_key, v1, v2|Hash === v1 && Hash === v2 ? v1.deep_merge(v2) : v2}
   end
 
   def deep_merge!(second)
-    merge!(second){|_key,v1,v2|Hash === v1 && Hash === v2 ? v1.deep_merge!(v2) : v2}
+    merge!(second){|_key, v1, v2|Hash === v1 && Hash === v2 ? v1.deep_merge!(v2) : v2}
   end
 end
 
@@ -14,7 +14,7 @@ end
 unless Hash.method_defined?(:transform_keys)
   class Hash
     def transform_keys
-      return each_with_object({}){|(k,v),memo|memo[yield(k)]=v} if block_given?
+      return each_with_object({}){|(k, v), memo|memo[yield(k)] = v} if block_given?
       raise 'missing block'
     end
   end

data/lib/aspera/id_generator.rb

@@ -7,7 +7,7 @@ module Aspera
     ID_SEPARATOR = '_'
     WINDOWS_PROTECTED_CHAR = %r{[/:"<>\\*?]}.freeze
     PROTECTED_CHAR_REPLACE = '_'
-    private_constant :ID_SEPARATOR,:PROTECTED_CHAR_REPLACE,:WINDOWS_PROTECTED_CHAR
+    private_constant :ID_SEPARATOR, :PROTECTED_CHAR_REPLACE, :WINDOWS_PROTECTED_CHAR
     class << self
       def from_list(object_id)
         if object_id.is_a?(Array)
@@ -16,10 +16,10 @@ module Aspera
           end.join(ID_SEPARATOR)
         end
         raise 'id must be a String' unless object_id.is_a?(String)
-        return object_id.
-            gsub(WINDOWS_PROTECTED_CHAR,PROTECTED_CHAR_REPLACE). # remove windows forbidden chars
-            gsub('.',PROTECTED_CHAR_REPLACE).  # keep dot for extension only (nicer)
-            downcase
+        return object_id
+            .gsub(WINDOWS_PROTECTED_CHAR, PROTECTED_CHAR_REPLACE) # remove windows forbidden chars
+            .gsub('.', PROTECTED_CHAR_REPLACE)  # keep dot for extension only (nicer)
+            .downcase
       end
     end
   end

data/lib/aspera/keychain/encrypted_hash.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/hash_ext'
+require 'aspera/environment'
 require 'symmetric_encryption/core'
 require 'yaml'
 
@@ -8,65 +9,59 @@ module Aspera
   module Keychain
     # Manage secrets in a simple Hash
     class EncryptedHash
-      CIPHER_NAME='aes-256-cbc'
-      ACCEPTED_KEYS = %i[label username password url description].freeze
-      def initialize(path,current_password)
-        @path=path
-        self.password=current_password
+      CIPHER_NAME = 'aes-256-cbc'
+      CONTENT_KEYS = %i[label username password url description].freeze
+      def initialize(path, current_password)
+        @path = path
+        self.password = current_password
         raise 'path to vault file shall be String' unless @path.is_a?(String)
-        @all_secrets=File.exist?(@path) ? YAML.load_stream(@cipher.decrypt(File.read(@path))).first : {}
+        @all_secrets = File.exist?(@path) ? YAML.load_stream(@cipher.decrypt(File.read(@path))).first : {}
       end
 
       def password=(new_password)
-        key_bytes=CIPHER_NAME.split('-')[1].to_i/8
-        # derive key from passphrase
-        key="#{new_password}#{"\x0"*key_bytes}"[0..(key_bytes-1)]
-        Log.log.debug("key=[#{key}],#{key.length}")
-        SymmetricEncryption.cipher=@cipher = SymmetricEncryption::Cipher.new(cipher_name: CIPHER_NAME,key: key,encoding: :none)
+        # number of bits in second position
+        key_bytes = CIPHER_NAME.split('-')[1].to_i / Environment::BITS_PER_BYTE
+        # derive key from passphrase, add trailing zeros
+        key = "#{new_password}#{"\x0" * key_bytes}"[0..(key_bytes - 1)]
+        Log.log.debug{"key=[#{key}],#{key.length}"}
+        SymmetricEncryption.cipher = @cipher = SymmetricEncryption::Cipher.new(cipher_name: CIPHER_NAME, key: key, encoding: :none)
       end
 
       def save
-        File.write(@path, @cipher.encrypt(YAML.dump(@all_secrets)),encoding: 'BINARY')
+        File.write(@path, @cipher.encrypt(YAML.dump(@all_secrets)), encoding: 'BINARY')
       end
 
       def set(options)
         raise 'options shall be Hash' unless options.is_a?(Hash)
-        unsupported = options.keys - ACCEPTED_KEYS
+        unsupported = options.keys - CONTENT_KEYS
+        options.each_value {|v| raise 'value must be String' unless v.is_a?(String)}
         raise "unsupported options: #{unsupported}" unless unsupported.empty?
         label = options.delete(:label)
-        raise "secret #{label} already exist, delete first" if @all_secrets.has_key?(label)
+        raise "secret #{label} already exist, delete first" if @all_secrets.key?(label)
         @all_secrets[label] = options.symbolize_keys
         save
       end
 
       def list
         result = []
-        @all_secrets.each do |label,values|
+        @all_secrets.each do |label, values|
           normal = values.symbolize_keys
           normal[:label] = label
-          ACCEPTED_KEYS.each{|k|normal[k] = '' unless normal.has_key?(k)}
+          CONTENT_KEYS.each{|k|normal[k] = '' unless normal.key?(k)}
           result.push(normal)
         end
         return result
       end
 
-      def delete(options)
-        raise 'options shall be Hash' unless options.is_a?(Hash)
-        unsupported = options.keys - %i[label]
-        raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        label=options[:label]
+      def delete(label:)
         @all_secrets.delete(label)
         save
       end
 
-      def get(options)
-        raise 'options shall be Hash' unless options.is_a?(Hash)
-        unsupported = options.keys - %i[label]
-        raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        label=options[:label]
+      def get(label:, exception: true)
+        raise "Label not found: #{label}" unless @all_secrets.key?(label) || !exception
         result = @all_secrets[label].clone
-        raise "no such entry #{label}" if result.nil?
-        result[:label]=label
+        result[:label] = label if result.is_a?(Hash)
         return result
       end
     end

data/lib/aspera/keychain/macos_security.rb

@@ -10,10 +10,10 @@ module Aspera
       # keychain based on macOS keychain, using `security` cmmand line
       class Keychain
         DOMAINS = %i[user system common dynamic].freeze
-        LIST_OPTIONS={
+        LIST_OPTIONS = {
           domain: :c
         }
-        ADD_PASS_OPTIONS={
+        ADD_PASS_OPTIONS = {
           account:  :a,
           creator:  :c,
           type:     :C,
@@ -32,7 +32,7 @@ module Aspera
           getpass:  :g
         }.freeze
         class << self
-          def execute(command,options=nil,supported=nil,lastopt=nil)
+          def execute(command, options=nil, supported=nil, lastopt=nil)
             url = options&.delete(:url)
             if !url.nil?
               uri = URI.parse(url)
@@ -40,20 +40,20 @@ module Aspera
               options[:protocol] = 'htps'
               raise 'host required in URL' if uri.host.nil?
               options[:server] = uri.host
-              options[:path] = uri.path unless ['','/'].include?(uri.path)
+              options[:path] = uri.path unless ['', '/'].include?(uri.path)
               options[:port] = uri.port unless uri.port.eql?(443) && !url.include?(':443/')
             end
-            cmd=['security',command]
-            options&.each do |k,v|
-              raise "unknown option: #{k}" unless supported.has_key?(k)
+            cmd = ['security', command]
+            options&.each do |k, v|
+              raise "unknown option: #{k}" unless supported.key?(k)
               next if v.nil?
               cmd.push("-#{supported[k]}")
               cmd.push(v.shellescape) unless v.empty?
             end
             cmd.push(lastopt) unless lastopt.nil?
-            Log.log.debug("executing>>#{cmd.join(' ')}")
-            result=%x(#{cmd.join(' ')} 2>&1)
-            Log.log.debug("result>>[#{result}]")
+            Log.log.debug{"executing>>#{cmd.join(' ')}"}
+            result = %x(#{cmd.join(' ')} 2>&1)
+            Log.log.debug{"result>>[#{result}]"}
             return result
           end
 
@@ -70,8 +70,8 @@ module Aspera
           end
 
           def list(options={})
-            raise ArgumentError,"Invalid domain #{options[:domain]}, expected one of: #{DOMAINS}" unless options[:domain].nil? || DOMAINS.include?(options[:domain])
-            keychains(execute('list-keychains',options,LIST_OPTIONS))
+            raise ArgumentError, "Invalid domain #{options[:domain]}, expected one of: #{DOMAINS}" unless options[:domain].nil? || DOMAINS.include?(options[:domain])
+            keychains(execute('list-keychains', options, LIST_OPTIONS))
           end
 
           def by_name(name)
@@ -88,15 +88,15 @@ module Aspera
           [string].pack('H*').force_encoding('UTF-8')
         end
 
-        def password(operation,passtype,options)
+        def password(operation, passtype, options)
           raise "wrong operation: #{operation}" unless %i[add find delete].include?(operation)
           raise "wrong passtype: #{passtype}" unless %i[generic internet].include?(passtype)
           raise 'options shall be Hash' unless options.is_a?(Hash)
-          missing=(operation.eql?(:add) ? %i[account service password] : %i[label])-options.keys
+          missing = (operation.eql?(:add) ? %i[account service password] : %i[label]) - options.keys
           raise "missing options: #{missing}" unless missing.empty?
-          options[:getpass]='' if operation.eql?(:find)
-          output=self.class.execute("#{operation}-#{passtype}-password",options,ADD_PASS_OPTIONS,@path)
-          raise output.gsub(/^.*: /,'') if output.start_with?('security: ')
+          options[:getpass] = '' if operation.eql?(:find)
+          output = self.class.execute("#{operation}-#{passtype}-password", options, ADD_PASS_OPTIONS, @path)
+          raise output.gsub(/^.*: /, '') if output.start_with?('security: ')
           return nil unless operation.eql?(:find)
           attributes = {}
           output.split("\n").each do |line|
@@ -121,7 +121,7 @@ module Aspera
     end
 
     class MacosSystem
-      def initialize(name=nil,password=nil)
+      def initialize(name=nil, _password=nil)
         @keychain = name.nil? ? MacosSecurity::Keychain.default_keychain : MacosSecurity::Keychain.by_name(name)
         raise "no such keychain #{name}" if @keychain.nil?
       end
@@ -130,7 +130,8 @@ module Aspera
         raise 'options shall be Hash' unless options.is_a?(Hash)
         unsupported = options.keys - %i[label username password url description]
         raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        @keychain.password(:add,:generic, service: options[:label],
+        @keychain.password(
+          :add, :generic, service: options[:label],
           account: options[:username] || 'none', password: options[:password], comment: options[:description])
       end
 
@@ -138,7 +139,7 @@ module Aspera
         raise 'options shall be Hash' unless options.is_a?(Hash)
         unsupported = options.keys - %i[label]
         raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        info = @keychain.password(:find,:generic,label: options[:label])
+        info = @keychain.password(:find, :generic, label: options[:label])
         raise 'not found' if info.nil?
         result = options.clone
         result[:secret] = info['password']

data/lib/aspera/log.rb

@@ -14,25 +14,25 @@ module Aspera
     # class methods
     class << self
       # levels are :debug,:info,:warn,:error,fatal,:unknown
-      def levels; Logger::Severity.constants.sort{|a,b|Logger::Severity.const_get(a) <=> Logger::Severity.const_get(b)}.map{|c|c.downcase.to_sym};end
+      def levels; Logger::Severity.constants.sort{|a, b|Logger::Severity.const_get(a) <=> Logger::Severity.const_get(b)}.map{|c|c.downcase.to_sym}; end
 
       # where logs are sent to
-      def logtypes; %i[stderr stdout syslog];end
+      def logtypes; %i[stderr stdout syslog]; end
 
       # get the logger object of singleton
-      def log; instance.logger;end
+      def log; instance.logger; end
 
       # dump object in debug mode
       # @param name string or symbol
       # @param format either pp or json format
-      def dump(name,object,format=:json)
+      def dump(name, object, format=:json)
         log.debug do
           result =
             case format
             when :json
-              JSON.pretty_generate(object) rescue PP.pp(object,+'')
+              JSON.pretty_generate(object) rescue PP.pp(object, +'')
             when :ruby
-              PP.pp(object,+'')
+              PP.pp(object, +'')
             else
               raise 'wrong parameter, expect pp or json'
             end
@@ -70,7 +70,7 @@ module Aspera
     # change underlying logger, but keep log level
     def logger_type=(new_logtype)
       current_severity_integer = @logger.level unless @logger.nil?
-      current_severity_integer = ENV['AS_LOG_LEVEL'] if current_severity_integer.nil? && ENV.has_key?('AS_LOG_LEVEL')
+      current_severity_integer = ENV['AS_LOG_LEVEL'] if current_severity_integer.nil? && ENV.key?('AS_LOG_LEVEL')
       current_severity_integer = Logger::Severity::WARN if current_severity_integer.nil?
       case new_logtype
       when :stderr

data/lib/aspera/nagios.rb

@@ -10,32 +10,32 @@ module Aspera
     # date offset levels
     DATE_WARN_OFFSET = 2
     DATE_CRIT_OFFSET = 5
-    private_constant :LEVELS,:ADD_PREFIX,:DATE_WARN_OFFSET,:DATE_CRIT_OFFSET
+    private_constant :LEVELS, :ADD_PREFIX, :DATE_WARN_OFFSET, :DATE_CRIT_OFFSET
 
     # add methods to add nagios error levels, each take component name and message
     LEVELS.each_index do |code|
       name = "#{ADD_PREFIX}#{LEVELS[code]}".to_sym
-      define_method(name){|comp,msg|@data.push({code: code,comp: comp,msg: msg})}
+      define_method(name){|comp, msg|@data.push({code: code, comp: comp, msg: msg})}
     end
 
     class << self
       # process results of a analysis and display status and exit with code
       def process(data)
         raise 'INTERNAL ERROR, result must be list and not empty' unless data.is_a?(Array) && !data.empty?
-        %w[status component message].each{|c|raise "INTERNAL ERROR, result must have #{c}" unless data.first.has_key?(c)}
+        %w[status component message].each{|c|raise "INTERNAL ERROR, result must have #{c}" unless data.first.key?(c)}
         res_errors = data.reject{|s|s['status'].eql?('ok')}
         # keep only errors in case of problem, other ok are assumed so
         data = res_errors unless res_errors.empty?
         # first is most critical
-        data.sort!{|a,b|LEVELS.index(a['status'].to_sym) <=> LEVELS.index(b['status'].to_sym)}
+        data.sort!{|a, b|LEVELS.index(a['status'].to_sym) <=> LEVELS.index(b['status'].to_sym)}
         # build message: if multiple components: concatenate
-        #message = data.map{|i|"#{i['component']}:#{i['message']}"}.join(', ').gsub("\n",' ')
-        message = data.
-          map{|i|i['component']}.
-          uniq.
-          map{|comp|comp + ':' + data.select{|d|d['component'].eql?(comp)}.map{|d|d['message']}.join(',')}.
-          join(', ').
-          tr("\n",' ')
+        # message = data.map{|i|"#{i['component']}:#{i['message']}"}.join(', ').gsub("\n",' ')
+        message = data
+          .map{|i|i['component']}
+          .uniq
+          .map{|comp|comp + ':' + data.select{|d|d['component'].eql?(comp)}.map{|d|d['message']}.join(',')}
+          .join(', ')
+          .tr("\n", ' ')
         status = data.first['status'].upcase
         # display status for nagios
         puts("#{status} - [#{message}]\n")
@@ -45,6 +45,7 @@ module Aspera
     end
 
     attr_reader :data
+
     def initialize
       @data = []
     end
@@ -55,26 +56,26 @@ module Aspera
       rtime = DateTime.strptime(remote_date)
       diff_time = (rtime - DateTime.now).abs
       diff_disp = diff_time.round(-2)
-      Log.log.debug("DATE: #{remote_date} #{rtime} diff=#{diff_disp}")
+      Log.log.debug{"DATE: #{remote_date} #{rtime} diff=#{diff_disp}"}
       msg = "offset #{diff_disp} sec"
       if diff_time >= DATE_CRIT_OFFSET
-        add_critical(component,msg)
+        add_critical(component, msg)
       elsif diff_time >= DATE_WARN_OFFSET
-        add_warning(component,msg)
+        add_warning(component, msg)
       else
-        add_ok(component,msg)
+        add_ok(component, msg)
       end
     end
 
     def check_product_version(component, _product, version)
-      add_ok(component,"version #{version}")
-      # TODO check on database if latest version
+      add_ok(component, "version #{version}")
+      # TODO: check on database if latest version
     end
 
     # translate for display
     def result
       raise 'missing result' if @data.empty?
-      {type: :object_list,data: @data.map{|i|{'status' => LEVELS[i[:code]].to_s,'component' => i[:comp],'message' => i[:msg]}}}
+      {type: :object_list, data: @data.map{|i|{'status' => LEVELS[i[:code]].to_s, 'component' => i[:comp], 'message' => i[:msg]}}}
     end
   end
 end