aspera-cli 4.9.0 → 4.11.0

data/lib/aspera/proxy_auto_config.rb

@@ -22,9 +22,9 @@ module Aspera
   class ProxyAutoConfig
     # template file is read once, it contains functions that can be used in a proxy autoconf script
     # it is similar to mozilla ascii_pac_utils.inc
-    PAC_FUNCTIONS_FILE = __FILE__.gsub(/\.rb$/,'.js').freeze
+    PAC_FUNCTIONS_FILE = __FILE__.gsub(/\.rb$/, '.js').freeze
     PAC_MAIN_FUNCTION = 'FindProxyForURL'
-    private_constant :PAC_FUNCTIONS_FILE,:PAC_MAIN_FUNCTION
+    private_constant :PAC_FUNCTIONS_FILE, :PAC_MAIN_FUNCTION
 
     private
 
@@ -52,13 +52,15 @@ END_OF_JAVASCRIPT
 
     public
 
+    attr_writer :proxy_user, :proxy_pass
+
     # @param proxy_auto_config the proxy auto config script to be evaluated
     def initialize(proxy_auto_config)
       # user provided javascript with FindProxyForURL function
       @proxy_auto_config = proxy_auto_config
       # avoid multiple execution, this does not support load balancing
       @cache = {}
-      @pac_functions = nil
+      @proxy_user = @proxy_pass = @pac_functions = nil
     end
 
     def register_uri_generic
@@ -72,8 +74,8 @@ END_OF_JAVASCRIPT
     def find_proxy_for_url(service_url)
       uri = URI.parse(service_url)
       simple_url = "#{uri.scheme}://#{uri.host}"
-      if !@cache.has_key?(simple_url)
-        Log.log.debug("PAC: starting javascript for #{service_url}")
+      if !@cache.key?(simple_url)
+        Log.log.debug{"PAC: starting javascript for #{service_url}"}
         # require at runtime, in case there is no js engine
         require 'execjs'
         # read template lib
@@ -82,7 +84,7 @@ END_OF_JAVASCRIPT
         js_to_execute = "#{pac_dns_functions(uri.host)}#{@pac_functions}#{@proxy_auto_config}"
         executable_js = ExecJS.compile(js_to_execute)
         @cache[simple_url] = executable_js.call(PAC_MAIN_FUNCTION, simple_url, uri.host)
-        Log.log.debug("PAC: result: #{@cache[simple_url]}")
+        Log.log.debug{"PAC: result: #{@cache[simple_url]}"}
       end
       return @cache[simple_url]
     end
@@ -95,34 +97,39 @@ END_OF_JAVASCRIPT
       # execute PAC script
       proxy_list_str = find_proxy_for_url(service_url)
       if !proxy_list_str.is_a?(String)
-        Log.log.warn("PAC: did not return a String, returned #{proxy_list_str.class}")
+        Log.log.warn{"PAC: did not return a String, returned #{proxy_list_str.class}"}
         return uri_list
       end
       proxy_list_str.strip!
-      proxy_list_str.gsub!(/\s+/,' ')
+      proxy_list_str.gsub!(/\s+/, ' ')
       proxy_list_str.split(';').each do |item|
         # strip and split by space
         parts = item.strip.split
         case parts.shift
         when 'DIRECT'
           raise 'DIRECT has no param' unless parts.empty?
+          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?
           begin
             # PAC proxy addresses are <host>:<port>
             if /:[0-9]+$/.match?(addr_port)
-              # we want to return URIs, so add dummy scheme
-              uri_list.push(URI.parse("proxy://#{addr_port}"))
+              uri = URI.parse("proxy://#{addr_port}")
+              # ruby v>2.6 allows
+              uri.user = @proxy_user
+              uri.password = @proxy_pass
+              uri_list.push(uri)
             else
-              Log.log.warn("PAC: PROXY must be <address>:<port>, ignoring #{addr_port}")
+              Log.log.warn{"PAC: PROXY must be <address>:<port>, ignoring #{addr_port}"}
             end
-          rescue StandardError
-            Log.log.warn("PAC: cannot parse #{addr_port}")
+          rescue StandardError => e
+            Log.log.warn{"PAC: cannot parse #{addr_port} #{e}"}
           end
-        else Log.log.warn("PAC: ignoring proxy type #{parts.first}: not supported")
+        else Log.log.warn{"PAC: ignoring proxy type #{parts.first}: not supported"}
         end
       end
+      Log.log.debug{"Proxies: #{uri_list}"}
       return uri_list
     end
   end

data/lib/aspera/rest.rb

@@ -13,18 +13,12 @@ require 'cgi'
 require 'ruby-progressbar'
 
 # add cancel method to http
-class Net::HTTP::Cancel < Net::HTTPRequest
+class Net::HTTP::Cancel < Net::HTTPRequest # rubocop:disable Style/ClassAndModuleChildren
   METHOD = 'CANCEL'
   REQUEST_HAS_BODY  = false
   RESPONSE_HAS_BODY = false
 end
 
-#class Net::HTTP::Delete < Net::HTTPRequest
-#  METHOD = 'DELETE'
-#  REQUEST_HAS_BODY  = false
-#  RESPONSE_HAS_BODY = false
-#end
-
 module Aspera
   # a simple class to make HTTP calls, equivalent to rest-client
   # rest call errors are raised as exception RestCallError
@@ -37,20 +31,25 @@ module Aspera
       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
+      session_cb:              nil,
+      proxy_user:              nil,
+      proxy_pass:              nil
     }
 
     class << self
       # define accessors
-      @@global.keys.each do |p|
+      @@global.each_key do |p|
         define_method(p){@@global[p]}
-        define_method("#{p}="){|val|Log.log.debug("#{p} => #{val}".red);@@global[p] = val}
+        define_method("#{p}=") do |val|
+          Log.log.debug{"#{p} => #{val}".red}
+          @@global[p] = val
+        end
       end
 
-      def basic_creds(user,pass); return "Basic #{Base64.strict_encode64("#{user}:#{pass}")}";end
+      def basic_creds(user, pass); return "Basic #{Base64.strict_encode64("#{user}:#{pass}")}"; end
 
       # build URI from URL and parameters and check it is http or https
-      def build_uri(url,params=nil)
+      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?
@@ -58,15 +57,15 @@ module Aspera
           if params.is_a?(Hash)
             orig = params
             params = []
-            orig.each do |k,v|
+            orig.each do |k, v|
               case v
               when Array
                 suffix = v.first.eql?('[]') ? v.shift : ''
                 v.each do |e|
-                  params.push([k + suffix,e])
+                  params.push([k + suffix, e])
                 end
               else
-                params.push([k,v])
+                params.push([k, v])
               end
             end
           end
@@ -75,6 +74,21 @@ module Aspera
         end
         return uri
       end
+
+      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)
+        # manually start session for keep alive (if supported by server, else, session is closed every time)
+        http_session.start
+        return http_session
+      end
     end
 
     private
@@ -82,15 +96,7 @@ module Aspera
     # create and start keep alive connection on demand
     def http_session
       if @http_session.nil?
-        uri = self.class.build_uri(@params[:base_url])
-        # this honors http_proxy env var
-        @http_session = Net::HTTP.new(uri.host, uri.port)
-        @http_session.use_ssl = uri.scheme.eql?('https')
-        @http_session.set_debug_output($stdout) if self.class.debug
-        # set http options in callback, such as timeout and cert. verification
-        self.class.session_cb&.call(@http_session)
-        # manually start session for keep alive (if supported by server, else, session is closed every time)
-        @http_session.start
+        @http_session = self.class.start_http_session(@params[:base_url])
       end
       return @http_session
     end
@@ -112,57 +118,56 @@ module Aspera
       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)
       @params = a_rest_params.clone
-      Log.dump('REST params',@params)
+      Log.dump('REST params', @params)
       # base url without trailing slashes (note: string may be frozen)
-      @params[:base_url] = @params[:base_url].gsub(/\/+$/,'')
+      @params[:base_url] = @params[:base_url].gsub(%r{/+$}, '')
       @http_session = nil
       # default is no auth
       @params[:auth] ||= {type: :none}
       @params[:not_auth_codes] ||= ['401']
       @oauth = nil
-      Log.dump('REST params(2)',@params)
+      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)
+      raise "ERROR: expecting boolean, have #{force_refresh}" unless [true, false].include?(force_refresh)
       return oauth.get_authorization(use_refresh_token: force_refresh)
     end
 
     def build_request(call_data)
       # TODO: shall we percent encode subpath (spaces) test with access key delete with space in id
       # URI.escape()
-      uri = self.class.build_uri("#{call_data[:base_url]}#{['','/'].include?(call_data[:subpath]) ? '' : '/'}#{call_data[:subpath]}",call_data[:url_params])
-      Log.log.debug("URI=#{uri}")
+      uri = self.class.build_uri("#{call_data[:base_url]}#{['', '/'].include?(call_data[:subpath]) ? '' : '/'}#{call_data[:subpath]}", call_data[:url_params])
+      Log.log.debug{"URI=#{uri}"}
       begin
         # instanciate request object based on string name
         req = Net::HTTP.const_get(call_data[:operation].capitalize).new(uri)
       rescue NameError
         raise "unsupported operation : #{call_data[:operation]}"
       end
-      if call_data.has_key?(:json_params) && !call_data[:json_params].nil?
+      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])
-        #Log.log.debug("body JSON data=#{JSON.pretty_generate(call_data[:json_params])}")
+        Log.dump('body JSON data', call_data[:json_params])
         req['Content-Type'] = 'application/json'
-        #call_data[:headers]['Accept']='application/json'
+        # call_data[:headers]['Accept']='application/json'
       end
-      if call_data.has_key?(:www_body_params)
+      if call_data.key?(:www_body_params)
         req.body = URI.encode_www_form(call_data[:www_body_params])
-        Log.log.debug("body www data=#{req.body.chomp}")
+        Log.log.debug{"body www data=#{req.body.chomp}"}
         req['Content-Type'] = 'application/x-www-form-urlencoded'
       end
-      if call_data.has_key?(:text_body_params)
+      if call_data.key?(:text_body_params)
         req.body = call_data[:text_body_params]
-        Log.log.debug("body data=#{req.body.chomp}")
+        Log.log.debug{"body data=#{req.body.chomp}"}
       end
       # set headers
-      if call_data.has_key?(:headers)
-        call_data[:headers].keys.each do |key|
+      if call_data.key?(:headers)
+        call_data[:headers].each_key do |key|
           req[key] = call_data[:headers][key]
         end
       end
       # :type = :basic
-      req.basic_auth(call_data[:auth][:username],call_data[:auth][:password]) if call_data[:auth][:type].eql?(:basic)
+      req.basic_auth(call_data[:auth][:username], call_data[:auth][:password]) if call_data[:auth][:type].eql?(:basic)
       return req
     end
 
@@ -190,7 +195,7 @@ module Aspera
     def call(call_data)
       raise "Hash call parameter is required (#{call_data.class})" unless call_data.is_a?(Hash)
       call_data[:subpath] = '' if call_data[:subpath].nil?
-      Log.log.debug("accessing #{call_data[:subpath]}".red.bold.bg_green)
+      Log.log.debug{"accessing #{call_data[:subpath]}".red.bold.bg_green}
       call_data[:headers] ||= {}
       call_data[:headers]['User-Agent'] ||= self.class.user_agent
       # defaults from @params are overriden by call data
@@ -202,7 +207,7 @@ module Aspera
         Log.log.debug('using Basic auth')
         # done in build_req
       when :oauth2
-        call_data[:headers]['Authorization'] = oauth_token unless call_data[:headers].has_key?('Authorization')
+        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|
@@ -211,7 +216,7 @@ module Aspera
       else raise "unsupported auth type: [#{call_data[:auth][:type]}]"
       end
       req = build_request(call_data)
-      Log.log.debug("call_data = #{call_data}")
+      Log.log.debug{"call_data = #{call_data}"}
       result = {http: nil}
       # start a block to be able to retry the actual HTTP request
       begin
@@ -233,11 +238,11 @@ module Aspera
             target_file = call_data[:save_to_file]
             # override user's path to path in header
             if !response['Content-Disposition'].nil? && (m = response['Content-Disposition'].match(/filename="([^"]+)"/))
-              target_file = File.join(File.dirname(target_file),m[1])
+              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}"
-            Log.log.debug("saving to: #{target_file}")
+            Log.log.debug{"saving to: #{target_file}"}
             File.open(target_file_tmp, 'wb') do |file|
               result[:http].read_body do |fragment|
                 file.write(fragment)
@@ -253,17 +258,17 @@ module Aspera
         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}")
+        Log.log.debug{"result: body=#{result[:http].body}"}
         result_mime = (result[:http]['Content-Type'] || 'text/plain').split(';').first
         result[:data] = case result_mime
-        when 'application/json','application/vnd.api+json'
+        when 'application/json', 'application/vnd.api+json'
           JSON.parse(result[:http].body) rescue nil
-        else #when 'text/plain'
+        else # when 'text/plain'
           result[:http].body
         end
-        Log.dump("result: parsed: #{result_mime}",result[:data])
-        Log.log.debug("result: code=#{result[:http].code}")
-        RestErrorAnalyzer.instance.raise_on_error(req,result)
+        Log.dump("result: parsed: #{result_mime}", result[:data])
+        Log.log.debug{"result: code=#{result[:http].code}"}
+        RestErrorAnalyzer.instance.raise_on_error(req, result)
       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)
@@ -276,16 +281,16 @@ module Aspera
             # regenerate a brand new token
             req['Authorization'] = oauth_token(use_cache: false)
           end
-          Log.log.debug("using new token=#{call_data[:headers]['Authorization']}")
+          Log.log.debug{"using new token=#{call_data[:headers]['Authorization']}"}
           retry unless (oauth_tries -= 1).zero?
         end # if oauth
         # moved ?
         if e.response.is_a?(Net::HTTPRedirection) && tries_remain_redirect.positive?
           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')
-          Log.log.info("URL is moved: #{new_url}")
+          new_url = e.response['location']
+          new_url = "#{current_uri.scheme}:#{new_url}" unless new_url.start_with?('http')
+          Log.log.info{"URL is moved: #{new_url}"}
           redir_uri = URI.parse(new_url)
           call_data[:base_url] = new_url
           call_data[:subpath] = ''
@@ -294,14 +299,14 @@ module Aspera
             retry
           else
             # change host
-            Log.log.info("Redirect changes host: #{current_uri.host} -> #{redir_uri.host}")
+            Log.log.info{"Redirect changes host: #{current_uri.host} -> #{redir_uri.host}"}
             return self.class.new(call_data).call(call_data)
           end
         end
         # raise exception if could not retry and not return error in result
         raise e unless call_data[:return_error]
       end # begin request
-      Log.log.debug("result=#{result}")
+      Log.log.debug{"result=#{result}"}
       return result
     end
 
@@ -310,24 +315,24 @@ module Aspera
     #
 
     # @param encoding : one of: :json_params, :url_params
-    def create(subpath,params,encoding=:json_params)
-      return call({operation: 'POST',subpath: subpath,headers: {'Accept' => 'application/json'},encoding => params})
+    def create(subpath, params, encoding=:json_params)
+      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, args=nil)
+      return call({operation: 'GET', subpath: subpath, headers: {'Accept' => 'application/json'}, url_params: args})
     end
 
-    def update(subpath,params)
-      return call({operation: 'PUT',subpath: subpath,headers: {'Accept' => 'application/json'},json_params: params})
+    def update(subpath, params)
+      return call({operation: 'PUT', subpath: subpath, headers: {'Accept' => 'application/json'}, json_params: params})
     end
 
     def delete(subpath)
-      return call({operation: 'DELETE',subpath: subpath,headers: {'Accept' => 'application/json'}})
+      return call({operation: 'DELETE', subpath: subpath, headers: {'Accept' => 'application/json'}})
     end
 
     def cancel(subpath)
-      return call({operation: 'CANCEL',subpath: subpath,headers: {'Accept' => 'application/json'}})
+      return call({operation: 'CANCEL', subpath: subpath, headers: {'Accept' => 'application/json'}})
     end
   end
-end #module Aspera
+end # module Aspera

data/lib/aspera/rest_call_error.rb

@@ -4,8 +4,9 @@ module Aspera
   # raised on error after REST call
   class RestCallError < StandardError
     attr_accessor :request, :response
+
     # @param http response
-    def initialize(req,resp,msg)
+    def initialize(req, resp, msg)
       @request = req
       @response = resp
       super(msg)

data/lib/aspera/rest_error_analyzer.rb

@@ -9,15 +9,16 @@ module Aspera
   class RestErrorAnalyzer
     include Singleton
     attr_accessor :log_file
+
     # the singleton object is registered with application specific handlers
     def initialize
       # list of handlers
       @error_handlers = []
       @log_file = nil
-      add_handler('Type Generic') do |type,call_context|
+      add_handler('Type Generic') do |type, call_context|
         if !call_context[:response].code.start_with?('2')
           # add generic information
-          RestErrorAnalyzer.add_error(call_context,type,"#{call_context[:request]['host']} #{call_context[:response].code} #{call_context[:response].message}")
+          RestErrorAnalyzer.add_error(call_context, type, "#{call_context[:request]['host']} #{call_context[:response].code} #{call_context[:response].message}")
         end
       end
     end
@@ -25,7 +26,7 @@ module Aspera
     # Use this method to analyze a EST result and raise an exception
     # Analyzes REST call response and raises a RestCallError exception
     # if HTTP result code is not 2XX
-    def raise_on_error(req,res)
+    def raise_on_error(req, res)
       call_context = {
         messages: [],
         request:  req,
@@ -36,14 +37,14 @@ module Aspera
       # analyze errors from provided handlers
       # note that there can be an error even if code is 2XX
       @error_handlers.each do |handler|
-        begin
-          #Log.log.debug("test exception: #{handler[:name]}")
-          handler[:block].call(handler[:name],call_context)
+        begin # rubocop:disable Style/RedundantBegin
+          # Log.log.debug{"test exception: #{handler[:name]}"}
+          handler[:block].call(handler[:name], call_context)
         rescue StandardError => e
-          Log.log.error("ERROR in handler:\n#{e.message}\n#{e.backtrace}")
+          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[:request], call_context[:response], call_context[:messages].join("\n")) unless call_context[:messages].empty?
     end
 
     # add a new error handler (done at application initialisation)
@@ -51,18 +52,18 @@ module Aspera
     # @param block : processing of response: takes two parameters: name, call_context
     # name is the one provided here
     # call_context is built in method raise_on_error
-    def add_handler(name,&block)
+    def add_handler(name, &block)
       @error_handlers.unshift({name: name, block: block})
     end
 
     # 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)
-      add_handler(name) do |type,call_context|
+    def add_simple_handler(name, *args)
+      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}")
+        # 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)
@@ -70,10 +71,10 @@ module Aspera
           # dig and find sub entry corresponding to path in deep hash
           error_struct = path.inject(call_context[:data]) { |subhash, key| subhash.respond_to?(:keys) ? subhash[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])
-            error_struct.each do |k,v|
+            RestErrorAnalyzer.add_error(call_context, type, error_struct[msg_key])
+            error_struct.each do |k, v|
               next if k.eql?(msg_key)
-              RestErrorAnalyzer.add_error(call_context,"#{type}(sub)","#{k}: #{v}") if [String,Integer].include?(v.class)
+              RestErrorAnalyzer.add_error(call_context, "#{type}(sub)", "#{k}: #{v}") if [String, Integer].include?(v.class)
             end
           end
         end
@@ -86,12 +87,12 @@ module Aspera
       # @param call_context a Hash containing the result call_context, provided to handler
       # @param type a string describing type of exception, for logging purpose
       # @param msg one error message  to add to list
-      def add_error(call_context,type,msg)
+      def add_error(call_context, type, msg)
         call_context[:messages].push(msg)
         logfile = instance.log_file
         # log error for further analysis (file must exist to activate)
         return if logfile.nil? || !File.exist?(logfile)
-        File.open(logfile,'a+') do |f|
+        File.open(logfile, 'a+') do |f|
           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

data/lib/aspera/rest_errors_aspera.rb

@@ -12,45 +12,45 @@ module Aspera
         Log.log.debug('registering Aspera REST error handlers')
         # Faspex 4: both user_message and internal_message, and code 200
         # example: missing meta data on package creation
-        RestErrorAnalyzer.instance.add_simple_handler('Type 1: error:user_message','error','user_message',true)
-        RestErrorAnalyzer.instance.add_simple_handler('Type 2: error:description','error','description')
-        RestErrorAnalyzer.instance.add_simple_handler('Type 3: error:internal_message','error','internal_message')
+        RestErrorAnalyzer.instance.add_simple_handler('Type 1: error:user_message', 'error', 'user_message', true)
+        RestErrorAnalyzer.instance.add_simple_handler('Type 2: error:description', 'error', 'description')
+        RestErrorAnalyzer.instance.add_simple_handler('Type 3: error:internal_message', 'error', 'internal_message')
         # AoC Automation
-        RestErrorAnalyzer.instance.add_simple_handler('AoC Automation','error')
-        RestErrorAnalyzer.instance.add_simple_handler('Type 5','error_description')
-        RestErrorAnalyzer.instance.add_simple_handler('Type 6','message')
-        RestErrorAnalyzer.instance.add_handler('Type 7: errors[]') do |name,call_context|
+        RestErrorAnalyzer.instance.add_simple_handler('AoC Automation', 'error')
+        RestErrorAnalyzer.instance.add_simple_handler('Type 5', 'error_description')
+        RestErrorAnalyzer.instance.add_simple_handler('Type 6', 'message')
+        RestErrorAnalyzer.instance.add_handler('Type 7: errors[]') do |name, call_context|
           if call_context[:data].is_a?(Hash) && call_context[:data]['errors'].is_a?(Hash)
-            call_context[:data]['errors'].each do |k,v|
-              RestErrorAnalyzer.add_error(call_context,name,"#{k}: #{v}")
+            call_context[:data]['errors'].each do |k, v|
+              RestErrorAnalyzer.add_error(call_context, name, "#{k}: #{v}")
             end
           end
         end
         # call to upload_setup and download_setup of node api
-        RestErrorAnalyzer.instance.add_handler('T8:node: *_setup') do |type,call_context|
+        RestErrorAnalyzer.instance.add_handler('T8:node: *_setup') do |type, call_context|
           if call_context[:data].is_a?(Hash)
             d_t_s = call_context[:data]['transfer_specs']
             if d_t_s.is_a?(Array)
               d_t_s.each do |res|
-                #r_err=res['transfer_spec']['error']
+                # r_err=res['transfer_spec']['error']
                 r_err = res['error']
                 if r_err.is_a?(Hash)
-                  RestErrorAnalyzer.add_error(call_context,type,"#{r_err['code']}: #{r_err['reason']}: #{r_err['user_message']}")
+                  RestErrorAnalyzer.add_error(call_context, type, "#{r_err['code']}: #{r_err['reason']}: #{r_err['user_message']}")
                 end
               end
             end
           end
         end
-        RestErrorAnalyzer.instance.add_simple_handler('T9:IBM cloud IAM','errorMessage')
-        RestErrorAnalyzer.instance.add_simple_handler('T10:faspex v4','user_message')
-        RestErrorAnalyzer.instance.add_handler('bss graphql') do |type,call_context|
+        RestErrorAnalyzer.instance.add_simple_handler('T9:IBM cloud IAM', 'errorMessage')
+        RestErrorAnalyzer.instance.add_simple_handler('T10:faspex v4', 'user_message')
+        RestErrorAnalyzer.instance.add_handler('bss graphql') do |type, call_context|
           if call_context[:data].is_a?(Hash)
             d_t_s = call_context[:data]['errors']
             if d_t_s.is_a?(Array)
               d_t_s.each do |res|
                 r_err = res['message']
                 if r_err.is_a?(String)
-                  RestErrorAnalyzer.add_error(call_context,type,r_err)
+                  RestErrorAnalyzer.add_error(call_context, type, r_err)
                 end
               end
             end

data/lib/aspera/secret_hider.rb

@@ -7,16 +7,17 @@ module Aspera
   class SecretHider
     # display string for hidden secrets
     HIDDEN_PASSWORD = '🔑'
+    # env vars for ascp with secrets
+    ASCP_ENV_SECRETS = %w[ASPERA_SCP_PASS ASPERA_SCP_KEY ASPERA_SCP_FILEPASS ASPERA_PROXY_PASS ASPERA_SCP_TOKEN].freeze
     # keys in hash that contain secrets
-    ASCP_SECRETS=%w[ASPERA_SCP_PASS ASPERA_SCP_KEY ASPERA_SCP_FILEPASS ASPERA_PROXY_PASS].freeze
-    KEY_SECRETS =%w[password secret private_key passphrase].freeze
-    ALL_SECRETS =[ASCP_SECRETS,KEY_SECRETS].flatten.freeze
+    KEY_SECRETS = %w[password secret private_key passphrase].freeze
+    ALL_SECRETS = [].concat(ASCP_ENV_SECRETS, KEY_SECRETS).freeze
     # regex that define namec captures :begin and :end
-    REGEX_LOG_REPLACES=[
+    REGEX_LOG_REPLACES = [
       # CLI manager get/set options
       /(?<begin>[sg]et (#{KEY_SECRETS.join('|')})=).*(?<end>)/,
       # env var ascp exec
-      /(?<begin> (#{ASCP_SECRETS.join('|')})=)[^ ]*(?<end> )/,
+      /(?<begin> (#{ASCP_ENV_SECRETS.join('|')})=)(\\.|[^ ])*(?<end> )/,
       # rendered JSON
       /(?<begin>["':][^"]*(#{ALL_SECRETS.join('|')})[^"]*["']?[=>: ]+")[^"]+(?<end>")/,
       # option "secret"
@@ -26,13 +27,14 @@ module Aspera
       # private key values
       /(?<begin>--+BEGIN .+ KEY--+)[[:ascii:]]+?(?<end>--+?END .+ KEY--+)/
     ].freeze
-    private_constant :HIDDEN_PASSWORD,:ASCP_SECRETS,:KEY_SECRETS,:ALL_SECRETS,:REGEX_LOG_REPLACES
+    private_constant :HIDDEN_PASSWORD, :ASCP_ENV_SECRETS, :KEY_SECRETS, :ALL_SECRETS, :REGEX_LOG_REPLACES
     @log_secrets = false
     class << self
       attr_accessor :log_secrets
+
       def log_formatter(original_formatter)
         original_formatter ||= Logger::Formatter.new
-        # note that @log_secrets may be set AFTER this init is done, so it's done at runtime
+        # NOTE: that @log_secrets may be set AFTER this init is done, so it's done at runtime
         return lambda do |severity, datetime, progname, msg|
           if msg.is_a?(String) && !@log_secrets
             REGEX_LOG_REPLACES.each do |regx|
@@ -43,25 +45,25 @@ module Aspera
         end
       end
 
-      def secret?(keyword,value)
-        keyword=keyword.to_s if keyword.is_a?(Symbol)
+      def secret?(keyword, value)
+        keyword = keyword.to_s if keyword.is_a?(Symbol)
         # only Strings can be secrets, not booleans, or hash, arrays
         keyword.is_a?(String) && ALL_SECRETS.any?{|kw|keyword.include?(kw)} && value.is_a?(String)
       end
 
-      def deep_remove_secret(obj,is_name_value: false)
+      def deep_remove_secret(obj, is_name_value: false)
         case obj
         when Array
           if is_name_value
             obj.each do |i|
-              i['value']=HIDDEN_PASSWORD if secret?(i['parameter'],i['value'])
+              i['value'] = HIDDEN_PASSWORD if secret?(i['parameter'], i['value'])
             end
           else
             obj.each{|i|deep_remove_secret(i)}
           end
         when Hash
-          obj.each do |k,v|
-            if secret?(k,v)
+          obj.each do |k, v|
+            if secret?(k, v)
               obj[k] = HIDDEN_PASSWORD
             elsif obj[k].is_a?(Hash)
               deep_remove_secret(obj[k])