aspera-cli 4.14.0 → 4.16.0

data/lib/aspera/preview/utils.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+# cspell:ignore ffprobe optipng unoconv
+require 'aspera/log'
+require 'aspera/assert'
 require 'English'
 require 'tmpdir'
 require 'fileutils'
-require 'aspera/log'
 require 'open3'
 
 module Aspera
@@ -11,18 +13,17 @@ module Aspera
     class Utils
       # from bash manual: meta-character need to be escaped
       BASH_SPECIAL_CHARACTERS = "|&;()<> \t#\n"
-      # shell exit code when command is not found
-      BASH_EXIT_NOT_FOUND = 127
       # external binaries used
       EXTERNAL_TOOLS = %i[ffmpeg ffprobe convert composite optipng unoconv].freeze
       TEMP_FORMAT = 'img%04d.jpg'
-      private_constant :BASH_SPECIAL_CHARACTERS, :BASH_EXIT_NOT_FOUND, :EXTERNAL_TOOLS, :TEMP_FORMAT
+      private_constant :BASH_SPECIAL_CHARACTERS, :EXTERNAL_TOOLS, :TEMP_FORMAT
 
       class << self
         # returns string with single quotes suitable for bash if there is any bash meta-character
         def shell_quote(argument)
           return argument unless argument.chars.any?{|c|BASH_SPECIAL_CHARACTERS.include?(c)}
-          return "'" + argument.gsub(/'/){|_s| "'\"'\"'"} + "'"
+          # surround with single quotes, and escape single quotes
+          return %Q{'#{argument.gsub("'"){|_s| %q{'"'"'}}}'}
         end
 
         # check that external tools can be executed
@@ -30,42 +31,35 @@ module Aspera
           tools_to_check = EXTERNAL_TOOLS.dup
           tools_to_check.delete(:unoconv) if skip_types.include?(:office)
           # Check for binaries
-          tools_to_check.each do |command_symb|
-            external_command(command_symb, ['-h'])
+          tools_to_check.each do |command_sym|
+            external_command(command_sym, ['-h'], check_code: false)
+          rescue Errno::ENOENT => e
+            raise "missing #{command_sym} binary: #{e}"
+          rescue
+            nil
           end
         end
 
         # execute external command
         # one could use "system", but we would need to redirect stdout/err
         # @return true if su
-        def external_command(command_symb, command_args)
-          raise "unexpected command #{command_symb}" unless EXTERNAL_TOOLS.include?(command_symb)
+        def external_command(command_sym, command_args, check_code: true)
+          assert_values(command_sym, EXTERNAL_TOOLS){'command'}
           # build command line, and quote special characters
-          command = command_args.clone.unshift(command_symb).map{|i| shell_quote(i.to_s)}.join(' ')
-          Log.log.debug{"cmd=#{command}".blue}
-          # capture3: only in ruby2+
-          if Open3.respond_to?(:capture3)
-            stdout, stderr, exit_status = Open3.capture3(command)
-          else
-            stderr = '<merged with stdout>'
-            stdout = %x(#{command} 2>&1)
-            exit_status = $CHILD_STATUS
-          end
-          if BASH_EXIT_NOT_FOUND.eql?(exit_status)
-            raise "Error: #{command_symb} is not in the PATH"
-          end
-          unless exit_status.success?
-            Log.log.error{"command line: #{command}"}
-            Log.log.error{"Error code: #{exit_status}"}
+          command_line = command_args.clone.unshift(command_sym).map{|i| shell_quote(i.to_s)}.join(' ')
+          Log.log.debug{"cmd=#{command_line}".blue}
+          stdout, stderr, status = Open3.capture3(command_line)
+          if check_code && !status.success?
+            Log.log.error{"status: #{status}"}
             Log.log.error{"stdout: #{stdout}"}
             Log.log.error{"stderr: #{stderr}"}
-            raise "#{command_symb} error #{exit_status}"
+            raise "#{command_sym} error #{status}"
           end
-          return {status: exit_status, stdout: stdout}
+          return {status: status, stdout: stdout}
         end
 
         def ffmpeg(a)
-          raise 'error: hash expected' unless a.is_a?(Hash)
+          assert_type(a, Hash)
           # input_file,input_args,output_file,output_args
           a[:gl_p] ||= [
             '-y', # overwrite output without asking
@@ -73,7 +67,7 @@ module Aspera
           ]
           a[:in_p] ||= []
           a[:out_p] ||= []
-          raise "wrong params (#{a.keys.sort})" unless %i[gl_p in_f in_p out_f out_p].eql?(a.keys.sort)
+          assert(%i[gl_p in_f in_p out_f out_p].eql?(a.keys.sort)){"wrong params (#{a.keys.sort})"}
           external_command(:ffmpeg, [a[:gl_p], a[:in_p], '-i', a[:in_f], a[:out_p], a[:out_f]].flatten)
         end
 

data/lib/aspera/proxy_auto_config.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'aspera/log'
+require 'aspera/assert'
 require 'uri'
 require 'resolv'
 
@@ -9,7 +11,7 @@ module URI
     alias_method :find_proxy_orig, :find_proxy
     class << self
       def register_proxy_finder
-        raise 'mandatory block missing' unless Kernel.block_given?
+        assert(block_given?)
         # overload the method in URI : call user's provided block and fallback to original method
         define_method(:find_proxy) {|env_vars=ENV| yield(to_s) || find_proxy_orig(env_vars)}
       end
@@ -107,11 +109,12 @@ END_OF_JAVASCRIPT
         parts = item.strip.split
         case parts.shift
         when 'DIRECT'
-          raise 'DIRECT has no param' unless parts.empty?
+          assert(parts.empty?){'DIRECT has no param'}
           Log.log.debug('ignoring proxy DIRECT')
         when 'PROXY'
           addr_port = parts.shift
-          raise 'PROXY shall have one param' unless addr_port.is_a?(String) && parts.empty?
+          assert_type(addr_port, String)
+          assert(parts.empty?){'PROXY shall have one param'}
           begin
             # PAC proxy addresses are <host>:<port>
             if /:[0-9]+$/.match?(addr_port)

data/lib/aspera/rest.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/log'
+require 'aspera/assert'
 require 'aspera/oauth'
 require 'aspera/rest_error_analyzer'
 require 'aspera/hash_ext'
@@ -10,7 +11,6 @@ require 'net/https'
 require 'json'
 require 'base64'
 require 'cgi'
-require 'ruby-progressbar'
 
 # add cancel method to http
 class Net::HTTP::Cancel < Net::HTTPRequest # rubocop:disable Style/ClassAndModuleChildren
@@ -26,34 +26,25 @@ module Aspera
   class Rest
     # global settings also valid for any subclass
     @@global = { # rubocop:disable Style/ClassVars
-      debug:                   false,
-      # true if https ignore certificate
-      user_agent:              'Ruby',
-      download_partial_suffix: '.http_partial',
-      # a lambda which takes the Net::HTTP as arg, use this to change parameters
-      session_cb:              nil,
-      proxy_user:              nil,
-      proxy_pass:              nil
+      user_agent:              'Ruby',          # goes to HTTP request header: 'User-Agent'
+      download_partial_suffix: '.http_partial', # suffix for partial download
+      session_cb:              nil,             # a lambda which takes the Net::HTTP as arg, use this to change parameters
+      progress_bar:            nil # progress bar object
     }
 
+    # flag for array parameters prefixed with []
     ARRAY_PARAMS = '[]'
 
     private_constant :ARRAY_PARAMS
 
-    # error message when entity not found
+    # error message when entity not found (TODO: use specific exception)
     ENTITY_NOT_FOUND = 'No such'
 
-    class << self
-      # define accessors
-      @@global.each_key do |p|
-        define_method(p){@@global[p]}
-        define_method("#{p}=") do |val|
-          Log.log.debug{"#{p} => #{val}".red}
-          @@global[p] = val
-        end
-      end
+    # Content-Type that are JSON
+    JSON_DECODE = ['application/json', 'application/vnd.api+json', 'application/x-javascript'].freeze
 
-      def basic_creds(user, pass); return "Basic #{Base64.strict_encode64("#{user}:#{pass}")}"; end
+    class << self
+      def basic_token(user, pass); return "Basic #{Base64.strict_encode64("#{user}:#{pass}")}"; end
 
       # used to build a parameter list prefixed with "[]"
       # @param values [Array] list of values
@@ -61,47 +52,92 @@ module Aspera
         return [ARRAY_PARAMS].concat(values)
       end
 
+      def array_params?(values)
+        return values.first.eql?(ARRAY_PARAMS)
+      end
+
       # build URI from URL and parameters and check it is http or https
       def build_uri(url, params=nil)
         uri = URI.parse(url)
-        raise "REST endpoint shall be http/s not #{uri.scheme}" unless %w[http https].include?(uri.scheme)
-        if !params.nil?
-          # support array url params, there is no standard. Either p[]=1&p[]=2, or p=1&p=2
-          if params.is_a?(Hash)
-            orig = params
-            params = []
-            orig.each do |k, v|
-              case v
-              when Array
-                suffix = v.first.eql?(ARRAY_PARAMS) ? v.shift : ''
-                v.each do |e|
-                  params.push([k.to_s + suffix, e])
-                end
-              else
-                params.push([k, v])
-              end
+        assert(%w[http https].include?(uri.scheme)){"REST endpoint shall be http/s not #{uri.scheme}"}
+        return uri if params.nil?
+        Log.log.debug{Log.dump('params', params)}
+        assert_type(params, Hash)
+        return uri if params.empty?
+        query = []
+        params.each do |k, v|
+          case v
+          when Array
+            # support array url params, there is no standard. Either p[]=1&p[]=2, or p=1&p=2
+            suffix = array_params?(v) ? v.shift : ''
+            v.each do |e|
+              query.push(["#{k}#{suffix}", e])
             end
+          else
+            query.push([k, v])
           end
-          # CGI.unescape to transform back %5D into []
-          uri.query = CGI.unescape(URI.encode_www_form(params))
         end
+        # [] is allowed in url parameters
+        uri.query = URI.encode_www_form(query).gsub('%5B%5D=', '[]=')
         return uri
       end
 
+      def decode_query(query)
+        URI.decode_www_form(query).each_with_object({}){|v, h|h[v.first] = v.last }
+      end
+
+      # start a HTTP/S session, also used for web sockets
+      # @param base_url [String] base url of HTTP/S session
+      # @return [Net::HTTP] a started HTTP session
       def start_http_session(base_url)
         uri = build_uri(base_url)
         # this honors http_proxy env var
         http_session = Net::HTTP.new(uri.host, uri.port)
-        http_session.proxy_user = proxy_user
-        http_session.proxy_pass = proxy_pass
         http_session.use_ssl = uri.scheme.eql?('https')
-        http_session.set_debug_output($stdout) if debug
         # set http options in callback, such as timeout and cert. verification
-        session_cb&.call(http_session)
+        @@global[:session_cb]&.call(http_session)
         # manually start session for keep alive (if supported by server, else, session is closed every time)
         http_session.start
         return http_session
       end
+
+      # get Net::HTTP underlying socket i/o
+      # little hack, handy because HTTP debug, proxy, etc... will be available
+      # used implement web sockets after `start_http_session`
+      def io_http_session(http_session)
+        assert_type(http_session, Net::HTTP)
+        # Net::BufferedIO in net/protocol.rb
+        result = http_session.instance_variable_get(:@socket)
+        assert(!result.nil?){"no socket for #{http_session}"}
+        return result
+      end
+
+      # @return [String] PEM certificates of remote server
+      def remote_certificates(url)
+        # initiate a session to retrieve remote certificate
+        http_session = Rest.start_http_session(url)
+        begin
+          # retrieve underlying openssl socket
+          return Rest.io_http_session(http_session).io.peer_cert_chain.reverse.map(&:to_pem).join("\n")
+        rescue
+          return http_session.peer_cert.to_pem
+        ensure
+          http_session.finish
+        end
+      end
+
+      # set global parameters
+      def set_parameters(**options)
+        options.each do |key, value|
+          assert(@@global.key?(key)){"unknown Rest option #{key}"}
+          @@global[key] = value
+        end
+      end
+
+      # @return [String] HTTP agent name
+      def user_agent
+        return @@global[:user_agent]
+      end
     end
 
     private
@@ -120,7 +156,7 @@ module Aspera
 
     def oauth
       if @oauth.nil?
-        raise 'ERROR: no OAuth defined' unless @params[:auth][:type].eql?(:oauth2)
+        assert(@params[:auth][:type].eql?(:oauth2)){'no OAuth defined'}
         @oauth = Oauth.new(@params[:auth])
       end
       return @oauth
@@ -128,10 +164,10 @@ module Aspera
 
     # @param a_rest_params [Hash] default call parameters (merged at call)
     def initialize(a_rest_params)
-      raise 'ERROR: expecting Hash' unless a_rest_params.is_a?(Hash)
-      raise 'ERROR: expecting base_url' unless a_rest_params[:base_url].is_a?(String)
+      assert_type(a_rest_params, Hash)
+      assert_type(a_rest_params[:base_url], String)
       @params = a_rest_params.clone
-      Log.dump('REST params', @params)
+      Log.log.debug{Log.dump('REST params', @params)}
       # base url without trailing slashes (note: string may be frozen)
       @params[:base_url] = @params[:base_url].gsub(%r{/+$}, '')
       @http_session = nil
@@ -139,11 +175,11 @@ module Aspera
       @params[:auth] ||= {type: :none}
       @params[:not_auth_codes] ||= ['401']
       @oauth = nil
-      Log.dump('REST params(2)', @params)
+      Log.log.debug{Log.dump('REST params(2)', @params)}
     end
 
     def oauth_token(force_refresh: false)
-      raise "ERROR: expecting boolean, have #{force_refresh}" unless [true, false].include?(force_refresh)
+      assert_values(force_refresh, [true, false])
       return oauth.get_authorization(use_refresh_token: force_refresh)
     end
 
@@ -159,8 +195,8 @@ module Aspera
         raise "unsupported operation : #{call_data[:operation]}"
       end
       if call_data.key?(:json_params) && !call_data[:json_params].nil?
-        req.body = JSON.generate(call_data[:json_params])
-        Log.dump('body JSON data', call_data[:json_params])
+        req.body = JSON.generate(call_data[:json_params]) # , ascii_only: true
+        Log.log.debug{Log.dump('body JSON data', call_data[:json_params])}
         req['Content-Type'] = 'application/json'
         # call_data[:headers]['Accept']='application/json'
       end
@@ -181,6 +217,7 @@ module Aspera
       end
       # :type = :basic
       req.basic_auth(call_data[:auth][:username], call_data[:auth][:password]) if call_data[:auth][:type].eql?(:basic)
+      Log.log.debug{Log.dump(:req_body, req.body)}
       return req
     end
 
@@ -203,14 +240,14 @@ module Aspera
     # :type (:none, :basic, :oauth2, :url)
     # :username   [:basic]
     # :password   [:basic]
-    # :url_creds  [:url] a hash
+    # :url_query  [:url] a hash
     # :*          [:oauth2] see Oauth class
     def call(call_data)
-      raise "Hash call parameter is required (#{call_data.class})" unless call_data.is_a?(Hash)
+      assert_type(call_data, Hash)
       call_data[:subpath] = '' if call_data[:subpath].nil?
       Log.log.debug{"accessing #{call_data[:subpath]}".red.bold.bg_green}
       call_data[:headers] ||= {}
-      call_data[:headers]['User-Agent'] ||= self.class.user_agent
+      call_data[:headers]['User-Agent'] ||= @@global[:user_agent]
       # defaults from @params are overridden by call data
       call_data = @params.deep_merge(call_data)
       case call_data[:auth][:type]
@@ -223,10 +260,10 @@ module Aspera
         call_data[:headers]['Authorization'] = oauth_token unless call_data[:headers].key?('Authorization')
       when :url
         call_data[:url_params] ||= {}
-        call_data[:auth][:url_creds].each do |key, value|
+        call_data[:auth][:url_query].each do |key, value|
           call_data[:url_params][key] = value
         end
-      else raise "unsupported auth type: [#{call_data[:auth][:type]}]"
+      else error_unexpected_value(call_data[:auth][:type])
       end
       req = build_request(call_data)
       Log.log.debug{"call_data = #{call_data}"}
@@ -238,16 +275,18 @@ module Aspera
         # initialize with number of initial retries allowed, nil gives zero
         tries_remain_redirect = call_data[:redirect_max].to_i if tries_remain_redirect.nil?
         Log.log.debug("send request (retries=#{tries_remain_redirect})")
+        result_mime = nil
+        file_saved = false
         # make http request (pipelined)
         http_session.request(req) do |response|
           result[:http] = response
-          if !call_data[:save_to_file].nil? && result[:http].code.to_s.start_with?('2')
+          result_mime = (result[:http]['Content-Type'] || 'text/plain').split(';').first.downcase
+          # JSON data needs to be parsed, in case it contains an error code
+          if !call_data[:save_to_file].nil? &&
+              result[:http].code.to_s.start_with?('2') &&
+              !result[:http]['Content-Length'].nil? &&
+              !JSON_DECODE.include?(result_mime)
             total_size = result[:http]['Content-Length'].to_i
-            progress = ProgressBar.create(
-              format:     '%a %B %p%% %r KB/sec %e',
-              rate_scale: lambda{|rate|rate / 1024},
-              title:      'progress',
-              total:      total_size)
             Log.log.debug('before write file')
             target_file = call_data[:save_to_file]
             # override user's path to path in header
@@ -255,34 +294,37 @@ module Aspera
               target_file = File.join(File.dirname(target_file), m[1])
             end
             # download with temp filename
-            target_file_tmp = "#{target_file}#{self.class.download_partial_suffix}"
+            target_file_tmp = "#{target_file}#{@@global[:download_partial_suffix]}"
             Log.log.debug{"saving to: #{target_file}"}
+            written_size = 0
+            @@global[:progress_bar]&.event(session_id: 1, type: :session_start)
+            @@global[:progress_bar]&.event(session_id: 1, type: :session_size, info: total_size)
             File.open(target_file_tmp, 'wb') do |file|
               result[:http].read_body do |fragment|
                 file.write(fragment)
-                new_process = progress.progress + fragment.length
-                new_process = total_size if new_process > total_size
-                progress.progress = new_process
+                written_size += fragment.length
+                @@global[:progress_bar]&.event(session_id: 1, type: :transfer, info: written_size)
               end
             end
+            @@global[:progress_bar]&.event(session_id: 1, type: :end)
             # rename at the end
             File.rename(target_file_tmp, target_file)
-            progress = nil
+            file_saved = true
           end # save_to_file
         end
-        # sometimes there is a UTF8 char (e.g. (c) )
-        result[:http].body.force_encoding('UTF-8') if result[:http].body.is_a?(String)
-        Log.log.debug{"result: body=#{result[:http].body}"}
-        result_mime = (result[:http]['Content-Type'] || 'text/plain').split(';').first
+        # sometimes there is a UTF8 char (e.g. (c) ), TODO : related to mime type encoding ?
+        # result[:http].body.force_encoding('UTF-8') if result[:http].body.is_a?(String)
+        # Log.log.debug{"result: body=#{result[:http].body}"}
         result[:data] = case result_mime
-        when 'application/json', 'application/vnd.api+json'
-          JSON.parse(result[:http].body) rescue nil
+        when *JSON_DECODE
+          JSON.parse(result[:http].body) rescue result[:http].body
         else # when 'text/plain'
           result[:http].body
         end
-        Log.dump("result: parsed: #{result_mime}", result[:data])
+        Log.log.debug{Log.dump("result: parsed: #{result_mime}", result[:data])}
         Log.log.debug{"result: code=#{result[:http].code}"}
         RestErrorAnalyzer.instance.raise_on_error(req, result)
+        File.write(call_data[:save_to_file], result[:http].body) unless file_saved || call_data[:save_to_file].nil?
       rescue RestCallError => e
         # not authorized: oauth token expired
         if call_data[:not_auth_codes].include?(result[:http].code.to_s) && call_data[:auth][:type].eql?(:oauth2)
@@ -303,7 +345,12 @@ module Aspera
           tries_remain_redirect -= 1
           current_uri = URI.parse(call_data[:base_url])
           new_url = e.response['location']
-          new_url = "#{current_uri.scheme}:#{new_url}" unless new_url.start_with?('http')
+          # special case: relative redirect
+          if URI.parse(new_url).host.nil?
+            # we don't manage relative redirects with non-absolute path
+            assert(new_url.start_with?('/')){"redirect location is relative: #{new_url}, but does not start with /."}
+            new_url = current_uri.scheme + '://' + current_uri.host + new_url
+          end
           Log.log.info{"URL is moved: #{new_url}"}
           redirection_uri = URI.parse(new_url)
           call_data[:base_url] = new_url
@@ -333,16 +380,16 @@ module Aspera
       return call({operation: 'POST', subpath: subpath, headers: {'Accept' => 'application/json'}, encoding => params})
     end
 
-    def read(subpath, args=nil)
-      return call({operation: 'GET', subpath: subpath, headers: {'Accept' => 'application/json'}, url_params: args})
+    def read(subpath, options=nil)
+      return call({operation: 'GET', subpath: subpath, headers: {'Accept' => 'application/json'}, url_params: options})
     end
 
     def update(subpath, params)
       return call({operation: 'PUT', subpath: subpath, headers: {'Accept' => 'application/json'}, json_params: params})
     end
 
-    def delete(subpath, args=nil)
-      return call({operation: 'DELETE', subpath: subpath, headers: {'Accept' => 'application/json'}, url_params: args})
+    def delete(subpath, params=nil)
+      return call({operation: 'DELETE', subpath: subpath, headers: {'Accept' => 'application/json'}, url_params: params})
     end
 
     def cancel(subpath)
@@ -355,11 +402,11 @@ module Aspera
     # @param options additional search options
     def lookup_by_name(subpath, search_name, options={})
       # returns entities whose name contains value (case insensitive)
-      matching_items = read(subpath, options.merge({'q' => CGI.escape(search_name)}))[:data]
+      matching_items = read(subpath, options.merge({'q' => search_name}))[:data]
       # API style: {totalcount:, ...} cspell: disable-line
       # TODO: not generic enough ? move somewhere ? inheritance ?
       matching_items = matching_items[subpath] if matching_items.is_a?(Hash)
-      raise "Internal error: expecting array, have #{matching_items.class}" unless matching_items.is_a?(Array)
+      assert_type(matching_items, Array)
       case matching_items.length
       when 1 then return matching_items.first
       when 0 then raise %Q{#{ENTITY_NOT_FOUND} #{subpath}: "#{search_name}"}

data/lib/aspera/rest_call_error.rb

@@ -8,7 +8,7 @@ module Aspera
     # @param req HTTP Request object
     # @param resp HTTP Response object
     # @param msg Error message
-    def initialize(req, resp, msg)
+    def initialize(msg, req=nil, resp=nil)
       @request = req
       @response = resp
       super(msg)

data/lib/aspera/rest_error_analyzer.rb

@@ -27,6 +27,7 @@ module Aspera
     # Analyzes REST call response and raises a RestCallError exception
     # if HTTP result code is not 2XX
     def raise_on_error(req, res)
+      Log.log.debug{"raise_on_error #{req.method} #{req.path} #{res[:http].code}"}
       call_context = {
         messages: [],
         request:  req,
@@ -44,7 +45,7 @@ module Aspera
           Log.log.error{"ERROR in handler:\n#{e.message}\n#{e.backtrace}"}
         end
       end
-      raise RestCallError.new(call_context[:request], call_context[:response], call_context[:messages].join("\n")) unless call_context[:messages].empty?
+      raise RestCallError.new(call_context[:messages].join("\n"), call_context[:request], call_context[:response]) unless call_context[:messages].empty?
     end
 
     # add a new error handler (done at application initialization)
@@ -59,21 +60,21 @@ module Aspera
     # add a simple error handler
     # check that key exists and is string under specified path (hash)
     # adds other keys as secondary information
-    def add_simple_handler(name, *args)
+    # @param name [String] name of error handler (for logs)
+    # @param always [boolean] if true, always add error message, even if response code is 2XX
+    # @param path [Array] path to error message in response
+    def add_simple_handler(name:, always: false, path:)
+      path.freeze
       add_handler(name) do |type, call_context|
-        # need to clone because we modify and same array is used subsequently
-        path = args.clone
-        # Log.log.debug{"path=#{path}"}
-        # if last in path is boolean it tells if the error is only with http error code or always
-        always = [true, false].include?(path.last) ? path.pop : false
         if call_context[:data].is_a?(Hash) && (!call_context[:response].code.start_with?('2') || always)
-          msg_key = path.pop
-          # dig and find sub entry corresponding to path in deep hash
-          error_struct = path.inject(call_context[:data]) { |sub_hash, key| sub_hash.respond_to?(:keys) ? sub_hash[key] : nil }
-          if error_struct.is_a?(Hash) && error_struct[msg_key].is_a?(String)
-            RestErrorAnalyzer.add_error(call_context, type, error_struct[msg_key])
+          # Log.log.debug{"simple_handler: #{type} #{path} #{path.last}"}
+          # dig and find hash containing error message
+          error_struct = path.length.eql?(1) ? call_context[:data] : call_context[:data].dig(*path[0..-2])
+          # Log.log.debug{"found: #{error_struct.class} #{error_struct}"}
+          if error_struct.is_a?(Hash) && error_struct[path.last].is_a?(String)
+            RestErrorAnalyzer.add_error(call_context, type, error_struct[path.last])
             error_struct.each do |k, v|
-              next if k.eql?(msg_key)
+              next if k.eql?(path.last)
               RestErrorAnalyzer.add_error(call_context, "#{type}(sub)", "#{k}: #{v}") if [String, Integer].include?(v.class)
             end
           end
@@ -89,11 +90,12 @@ module Aspera
       # @param msg one error message  to add to list
       def add_error(call_context, type, msg)
         call_context[:messages].push(msg)
+        Log.log.trace1{"Found error: #{type}: #{msg}"}
         log_file = instance.log_file
         # log error for further analysis (file must exist to activate)
         return if log_file.nil? || !File.exist?(log_file)
         File.open(log_file, 'a+') do |f|
-          f.write("\n=#{type}=====\n#{call_context[:request].method} #{call_context[:request].path}\n#{call_context[:response].code}\n"\
+          f.write("\n=#{type}=====\n#{call_context[:request].method} #{call_context[:request].path}\n#{call_context[:response].code}\n" \
             "#{JSON.generate(call_context[:data])}\n#{call_context[:messages].join("\n")}")
         end
       end