aspera-cli 4.11.0 → 4.12.0

data/lib/aspera/cli/plugins/config.rb

@@ -3,7 +3,7 @@
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/cli/extended_value'
 require 'aspera/cli/version'
-require 'aspera/cli/formater'
+require 'aspera/cli/formatter'
 require 'aspera/cli/info'
 require 'aspera/fasp/installation'
 require 'aspera/fasp/parameters'
@@ -129,7 +129,7 @@ module Aspera
           ExtendedValue.instance.set_handler(EXTV_PRESET, :reader, lambda{|v|preset_by_name(v)})
           ExtendedValue.instance.set_handler(EXTV_INCLUDE_PRESETS, :decoder, lambda{|v|expanded_with_preset_includes(v)})
           ExtendedValue.instance.set_handler(EXTV_VAULT, :decoder, lambda{|v|vault_value(v)})
-          # load defaults before it can be overriden
+          # load defaults before it can be overridden
           add_plugin_default_preset(CONF_GLOBAL_SYM)
           options.parse_options!
           options.set_obj_attr(:ascp_path, Fasp::Installation.instance, :ascp_path)
@@ -261,16 +261,16 @@ module Aspera
             Log.log.debug{"javascript=[\n#{connect_versions_javascript}\n]"}
             # get javascript object only
             found = connect_versions_javascript.match(/^.*? = (.*);/)
-            raise CliError, 'Problen when getting connect versions from internet' if found.nil?
-            alldata = JSON.parse(found[1])
-            @connect_versions = alldata['entries']
+            raise CliError, 'Problem when getting connect versions from internet' if found.nil?
+            all_data = JSON.parse(found[1])
+            @connect_versions = all_data['entries']
           end
           return @connect_versions
         end
 
         # loads default parameters of plugin if no -P parameter
         # and if there is a section defined for the plugin in the "default" section
-        # try to find: conffile[conffile["default"][plugin_str]]
+        # try to find: conf[conf["default"][plugin_str]]
         # @param plugin_name_sym : symbol for plugin name
         def add_plugin_default_preset(plugin_name_sym)
           default_config_name = get_plugin_default_config_name(plugin_name_sym)
@@ -297,7 +297,7 @@ module Aspera
             File.dirname(File.expand_path(__FILE__))
           end
 
-          # name of englobin module
+          # name of englobing module
           # @return "Aspera::Cli::Plugins"
           def module_full_name
             return Module.nesting[2].to_s
@@ -309,7 +309,7 @@ module Aspera
             File.expand_path(module_full_name.gsub('::', '/').gsub(%r{[^/]+}, '..'), gem_plugins_folder)
           end
 
-          # instanciate a plugin
+          # instantiate a plugin
           # plugins must be Capitalized
           def plugin_class(plugin_name_sym)
             # Module.nesting[2] is Aspera::Cli::Plugins
@@ -330,7 +330,7 @@ module Aspera
           end
           @config_presets[global_default_preset_name] ||= {}
           @config_presets[global_default_preset_name][key.to_s] = value
-          self.format.display_status("Updated: #{global_default_preset_name}: #{key} <- #{value}")
+          formatter.display_status("Updated: #{global_default_preset_name}: #{key} <- #{value}")
           save_presets_to_config_file
           return global_default_preset_name
         end
@@ -362,7 +362,7 @@ module Aspera
           end
         end
 
-        # @return the hash value with 'incps' keys expanced to include other presets
+        # @return the hash value with 'incps' keys expanded to include other presets
         # @param hash_val
         # @param include_path to avoid inclusion loop
         def expanded_with_preset_includes(hash_val, include_path=[])
@@ -582,7 +582,8 @@ module Aspera
                 Log.log.debug{"Cannot detect #{plugin_name_sym} : #{e.message}"}
               end
             end
-            return detection_info.merge(product: plugin_name_sym, url: current_url) unless detection_info.nil?
+            # if there is a redirect, then the detector can override the url.
+            return {product: plugin_name_sym, url: current_url}.merge(detection_info) unless detection_info.nil?
           end # loop
           raise "No known application found at #{url}"
         end
@@ -615,9 +616,9 @@ module Aspera
               folder_dest = transfer.destination_folder(Fasp::TransferSpec::DIRECTION_RECEIVE)
               # folder_dest=self.options.get_next_argument('destination folder')
               api_connect_cdn = Rest.new({base_url: CONNECT_WEB_URL})
-              fileurl = one_link['href']
-              filename = fileurl.gsub(%r{.*/}, '')
-              api_connect_cdn.call({operation: 'GET', subpath: fileurl, save_to_file: File.join(folder_dest, filename)})
+              file_url = one_link['href']
+              filename = file_url.gsub(%r{.*/}, '')
+              api_connect_cdn.call({operation: 'GET', subpath: file_url, save_to_file: File.join(folder_dest, filename)})
               return Main.result_status("Downloaded: #{filename}")
             when :open
               OpenApplication.instance.uri(one_link['href'])
@@ -634,7 +635,7 @@ module Aspera
           when :use
             ascp_path = options.get_next_argument('path to ascp')
             ascp_version = Fasp::Installation.instance.get_ascp_version(ascp_path)
-            self.format.display_status("ascp version: #{ascp_version}")
+            formatter.display_status("ascp version: #{ascp_version}")
             preset_name = set_global_default(:ascp_path, ascp_path)
             return Main.result_status("Saved to default global preset #{preset_name}")
           when :show # shows files used
@@ -692,7 +693,7 @@ module Aspera
             return {
               type:   :object_list,
               data:   Fasp::Parameters.man_table,
-              fields: %w[name type].concat(Fasp::Parameters::SUPPORTED_AGENTS_SHORT.map(&:to_s), %w[description])
+              fields: [%w[name type], Fasp::Parameters::SUPPORTED_AGENTS_SHORT.map(&:to_s), %w[description]].flatten.freeze
             }
           when :errors
             error_data = []
@@ -706,23 +707,23 @@ module Aspera
 
         # legacy actions available globally
         PRESET_GBL_ACTIONS = %i[list overview lookup secure].freeze
-        # require existing preset
-        PRESET_EXST_ACTIONS = %i[show delete get unset].freeze
+        # operations requiring that preset exists
+        PRESET_EXIST_ACTIONS = %i[show delete get unset].freeze
         # require id
-        PRESET_INSTANCE_ACTIONS = %i[initialize update ask set].concat(PRESET_EXST_ACTIONS).freeze
-        PRESET_ALL_ACTIONS = [].concat(PRESET_GBL_ACTIONS, PRESET_INSTANCE_ACTIONS).freeze
+        PRESET_INSTANCE_ACTIONS = %i[initialize update ask set].concat(PRESET_EXIST_ACTIONS).freeze
+        PRESET_ALL_ACTIONS = [PRESET_GBL_ACTIONS, PRESET_INSTANCE_ACTIONS].flatten.freeze
 
         def execute_preset(action: nil, name: nil)
           action = options.get_next_command(PRESET_ALL_ACTIONS) if action.nil?
           name = instance_identifier if name.nil? && PRESET_INSTANCE_ACTIONS.include?(action)
           # those operations require existing option
-          raise "no such preset: #{name}" if PRESET_EXST_ACTIONS.include?(action) && !@config_presets.key?(name)
+          raise "no such preset: #{name}" if PRESET_EXIST_ACTIONS.include?(action) && !@config_presets.key?(name)
           selected_preset = @config_presets[name]
           case action
           when :list
             return {type: :value_list, data: @config_presets.keys, name: 'name'}
           when :overview
-            return {type: :object_list, data: Formater.flatten_config_overview(@config_presets)}
+            return {type: :object_list, data: Formatter.flatten_config_overview(@config_presets)}
           when :show
             raise "no such config: #{name}" if selected_preset.nil?
             return {type: :single_object, data: selected_preset}
@@ -766,10 +767,10 @@ module Aspera
             return Main.result_status("Modified: #{@option_config_file}")
           when :update
             #  get unprocessed options
-            theopts = options.get_options_table
-            Log.log.debug{"opts=#{theopts}"}
+            unprocessed_options = options.get_options_table
+            Log.log.debug{"opts=#{unprocessed_options}"}
             @config_presets[name] ||= {}
-            @config_presets[name].merge!(theopts)
+            @config_presets[name].merge!(unprocessed_options)
             # fix bug in 4.4 (creating key "true" in "default" preset)
             @config_presets[CONF_PRESET_DEFAULT].delete(true) if @config_presets[CONF_PRESET_DEFAULT].is_a?(Hash)
             save_presets_to_config_file
@@ -777,9 +778,9 @@ module Aspera
           when :ask
             options.ask_missing_mandatory = :yes
             @config_presets[name] ||= {}
-            options.get_next_argument('option names', expected: :multiple).each do |optionname|
-              option_value = options.get_interactive(:option, optionname)
-              @config_presets[name][optionname] = option_value
+            options.get_next_argument('option names', expected: :multiple).each do |option_name|
+              option_value = options.get_interactive(:option, option_name)
+              @config_presets[name][option_name] = option_value
             end
             save_presets_to_config_file
             return Main.result_status("Updated: #{name}")
@@ -794,20 +795,20 @@ module Aspera
             identifier = options.get_next_argument('config name', mandatory: false)
             preset_names = identifier.nil? ? @config_presets.keys : [identifier]
             secret_keywords = %w[password secret].freeze
-            preset_names.each do |pset_name|
-              preset = @config_presets[pset_name]
+            preset_names.each do |preset_name|
+              preset = @config_presets[preset_name]
               next unless preset.is_a?(Hash)
               preset.each_key do |option_name|
                 secret_keywords.each do |keyword|
                   next unless option_name.end_with?(keyword)
-                  vault_label = pset_name
+                  vault_label = preset_name
                   incr = 0
                   until vault.get(label: vault_label, exception: false).nil?
-                    vault_label = "#{pset_name}#{incr}"
+                    vault_label = "#{preset_name}#{incr}"
                     incr += 1
                   end
                   to_set = {label: vault_label, password: preset[option_name]}
-                  puts "need to encode #{pset_name}.#{option_name} -> #{vault_label} -> #{to_set}"
+                  puts "need to encode #{preset_name}.#{option_name} -> #{vault_label} -> #{to_set}"
                   # to_copy=%i[]
                   vault.set(to_set)
                   preset[option_name] = "@vault:#{vault_label}.password"
@@ -925,20 +926,20 @@ module Aspera
               raise CliBadArgument, "Supports only: aoc. Detected: #{params[:application]}"
             end # product
             if params[:option_default]
-              self.format.display_status("Setting config preset as default for #{params[:plugin_name]}")
+              formatter.display_status("Setting config preset as default for #{params[:plugin_name]}")
               @config_presets[CONF_PRESET_DEFAULT][params[:plugin_name]] = params[:preset_name]
             else
               params[:test_args] = "-P#{params[:preset_name]} #{params[:test_args]}"
             end
-            self.format.display_status('Saving config file.')
+            formatter.display_status('Saving config file.')
             save_presets_to_config_file
             return Main.result_status("Done.\nYou can test with:\n#{@info[:name]} #{params[:test_args]}")
           when :export_to_cli # this method shall be deprecated in the future: it was used to export configuration to "aspera.exe" CLI
-            self.format.display_status('Exporting: Aspera on Cloud')
+            formatter.display_status('Exporting: Aspera on Cloud')
             require 'aspera/cli/plugins/aoc'
             # need url / username
             add_plugin_default_preset(AOC_COMMAND_V3.to_sym)
-            # instanciate AoC plugin
+            # instantiate AoC plugin
             self.class.plugin_class(AOC_COMMAND_CURRENT).new(@agents) # TODO: is this line needed ? get options ?
             url = options.get_option(:url, is_type: :mandatory)
             cli_conf_file = Fasp::Installation.instance.cli_conf_file
@@ -961,9 +962,9 @@ module Aspera
             entry = data['AoCAccounts'].find{|i|i['organization'].eql?(organization)}
             if entry.nil?
               data['AoCAccounts'].push(new_conf)
-              self.format.display_status("Creating new aoc entry: #{organization}")
+              formatter.display_status("Creating new aoc entry: #{organization}")
             else
-              self.format.display_status("Updating existing aoc entry: #{organization}")
+              formatter.display_status("Updating existing aoc entry: #{organization}")
               entry.merge!(new_conf)
             end
             File.write(cli_conf_file, JSON.pretty_generate(data))
@@ -1208,12 +1209,12 @@ module Aspera
         end
 
         def wizard_aoc(params)
-          self.format.display_status('Detected: Aspera on Cloud'.bold)
+          formatter.display_status('Detected: Aspera on Cloud'.bold)
           params[:plugin_name] = AOC_COMMAND_CURRENT
           organization = AoC.parse_url(params[:instance_url]).first
           # if not defined by user, generate name
           params[:preset_name] = [params[:application], organization].join('_') if params[:preset_name].nil?
-          self.format.display_status("Preparing preset: #{params[:preset_name]}")
+          formatter.display_status("Preparing preset: #{params[:preset_name]}")
           # init defaults if necessary
           @config_presets[CONF_PRESET_DEFAULT] ||= {}
           option_override = options.get_option(:override, is_type: :mandatory)
@@ -1227,7 +1228,7 @@ module Aspera
           private_key_path = options.get_option(:pkeypath)
           # give a chance to provide
           if private_key_path.nil?
-            self.format.display_status('Please provide path to your private RSA key, or empty to generate one:')
+            formatter.display_status('Please provide path to your private RSA key, or empty to generate one:')
             private_key_path = options.get_option(:pkeypath, is_type: :mandatory).to_s
           end
           # else generate path
@@ -1235,45 +1236,45 @@ module Aspera
             private_key_path = File.join(@main_folder, DEFAULT_PRIV_KEY_FILENAME)
           end
           if File.exist?(private_key_path)
-            self.format.display_status('Using existing key:')
+            formatter.display_status('Using existing key:')
           else
-            self.format.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
+            formatter.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
             generate_rsa_private_key(private_key_path, DEFAULT_PRIVKEY_LENGTH)
-            self.format.display_status('Created:')
+            formatter.display_status('Created:')
           end
-          self.format.display_status(private_key_path)
+          formatter.display_status(private_key_path)
           pub_key_pem = OpenSSL::PKey::RSA.new(File.read(private_key_path)).public_key.to_s
           # declare command line options for AoC
           require 'aspera/cli/plugins/aoc'
           # make username mandatory for jwt, this triggers interactive input
           options.get_option(:username, is_type: :mandatory)
-          # instanciate AoC plugin, so that command line options are known
+          # instantiate AoC plugin, so that command line options are known
           aoc_api = self.class.plugin_class(params[:plugin_name]).new(@agents.merge({skip_basic_auth_options: true, private_key_path: private_key_path})).aoc_api
           auto_set_pub_key = false
           auto_set_jwt = false
           use_browser_authentication = false
           if options.get_option(:use_generic_client)
-            self.format.display_status('Using global client_id.')
-            self.format.display_status('Please Login to your Aspera on Cloud instance.'.red)
-            self.format.display_status('Navigate to your "Account Settings"'.red)
-            self.format.display_status('Check or update the value of "Public Key" to be:'.red.blink)
-            self.format.display_status(pub_key_pem.to_s)
+            formatter.display_status('Using global client_id.')
+            formatter.display_status('Please Login to your Aspera on Cloud instance.'.red)
+            formatter.display_status('Navigate to your "Account Settings"'.red)
+            formatter.display_status('Check or update the value of "Public Key" to be:'.red.blink)
+            formatter.display_status(pub_key_pem.to_s)
             if !options.get_option(:test_mode)
-              self.format.display_status('Once updated or validated, press enter.')
+              formatter.display_status('Once updated or validated, press enter.')
               OpenApplication.instance.uri(params[:instance_url])
               $stdin.gets
             end
           else
-            self.format.display_status('Using organization specific client_id.')
+            formatter.display_status('Using organization specific client_id.')
             if options.get_option(:client_id).nil? || options.get_option(:client_secret, is_type: :optional).nil?
-              self.format.display_status('Please login to your Aspera on Cloud instance.'.red)
-              self.format.display_status('Go to: Apps->Admin->Organization->Integrations')
-              self.format.display_status('Create or check if there is an existing integration named:')
-              self.format.display_status("- name: #{@info[:name]}")
-              self.format.display_status("- redirect uri: #{DEFAULT_REDIRECT}")
-              self.format.display_status('- origin: localhost')
-              self.format.display_status('Once created or identified,')
-              self.format.display_status('Please enter:'.red)
+              formatter.display_status('Please login to your Aspera on Cloud instance.'.red)
+              formatter.display_status('Go to: Apps->Admin->Organization->Integrations')
+              formatter.display_status('Create or check if there is an existing integration named:')
+              formatter.display_status("- name: #{@info[:name]}")
+              formatter.display_status("- redirect uri: #{DEFAULT_REDIRECT}")
+              formatter.display_status('- origin: localhost')
+              formatter.display_status('Once created or identified,')
+              formatter.display_status('Please enter:'.red)
             end
             OpenApplication.instance.uri("#{params[:instance_url]}/#{AOC_PATH_API_CLIENTS}")
             options.get_option(:client_id, is_type: :mandatory)
@@ -1281,24 +1282,24 @@ module Aspera
             use_browser_authentication = true
           end
           if use_browser_authentication
-            self.format.display_status('We will use web authentication to bootstrap.')
+            formatter.display_status('We will use web authentication to bootstrap.')
             auto_set_pub_key = true
             auto_set_jwt = true
-            aoc_api.oauth.gparams[:crtype] = :web
-            aoc_api.oauth.gparams[:scope] = AoC::SCOPE_FILES_ADMIN
-            aoc_api.oauth.sparams[:redirect_uri] = DEFAULT_REDIRECT
+            aoc_api.oauth.generic_parameters[:grant_method] = :web
+            aoc_api.oauth.generic_parameters[:scope] = AoC::SCOPE_FILES_ADMIN
+            aoc_api.oauth.specific_parameters[:redirect_uri] = DEFAULT_REDIRECT
           end
           myself = aoc_api.read('self')[:data]
           if auto_set_pub_key
             raise CliError, 'Public key is already set in profile (use --override=yes)' unless myself['public_key'].empty? || option_override
-            self.format.display_status('Updating profile with new key')
+            formatter.display_status('Updating profile with new key')
             aoc_api.update("users/#{myself['id']}", {'public_key' => pub_key_pem})
           end
           if auto_set_jwt
-            self.format.display_status('Enabling JWT for client')
+            formatter.display_status('Enabling JWT for client')
             aoc_api.update("clients/#{options.get_option(:client_id)}", {'jwt_grant_enabled' => true, 'explicit_authorization_required' => false})
           end
-          self.format.display_status("Creating new config preset: #{params[:preset_name]}")
+          formatter.display_status("Creating new config preset: #{params[:preset_name]}")
           @config_presets[params[:preset_name]] = {
             :url.to_s         => options.get_option(:url),
             :username.to_s    => myself['email'],
@@ -1314,11 +1315,11 @@ module Aspera
         end
 
         def wizard_faspex5(params)
-          self.format.display_status('Detected: Faspex v5'.bold)
+          formatter.display_status('Detected: Faspex v5'.bold)
           # if not defined by user, generate unique name
           params[:preset_name] = [params[:application]].concat(URI.parse(params[:instance_url]).host.gsub(/[^a-z0-9.]/, '').split('.')).join('_') \
             if params[:preset_name].nil?
-          self.format.display_status("Preparing preset: #{params[:preset_name]}")
+          formatter.display_status("Preparing preset: #{params[:preset_name]}")
           # init defaults if necessary
           @config_presets[CONF_PRESET_DEFAULT] ||= {}
           option_override = options.get_option(:override, is_type: :mandatory)
@@ -1332,7 +1333,7 @@ module Aspera
           private_key_path = options.get_option(:pkeypath)
           # give a chance to provide
           if private_key_path.nil?
-            self.format.display_status('Please provide path to your private RSA key, or empty to generate one:')
+            formatter.display_status('Please provide path to your private RSA key, or empty to generate one:')
             private_key_path = options.get_option(:pkeypath, is_type: :mandatory).to_s
           end
           # else generate path
@@ -1340,25 +1341,25 @@ module Aspera
             private_key_path = File.join(@main_folder, DEFAULT_PRIV_KEY_FILENAME)
           end
           if File.exist?(private_key_path)
-            self.format.display_status('Using existing key:')
+            formatter.display_status('Using existing key:')
           else
-            self.format.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
+            formatter.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
             generate_rsa_private_key(private_key_path, DEFAULT_PRIVKEY_LENGTH)
-            self.format.display_status('Created:')
+            formatter.display_status('Created:')
           end
-          self.format.display_status(private_key_path)
+          formatter.display_status(private_key_path)
           pub_key_pem = OpenSSL::PKey::RSA.new(File.read(private_key_path)).public_key.to_s
           # declare command line options for AoC
           require 'aspera/cli/plugins/faspex5'
           self.class.plugin_class(params[:plugin_name]).new(@agents.merge({skip_basic_auth_options: true}))
-          self.format.display_status('Please login to Faspex 5.'.red)
+          formatter.display_status('Please login to Faspex 5.'.red)
           OpenApplication.instance.uri(params[:instance_url])
-          self.format.display_status('Navigate to: 𓃑  → Admin → Configurations → API clients')
-          self.format.display_status('Create a client with:')
-          self.format.display_status('- JWT enabled')
-          self.format.display_status('- The following public key:')
-          self.format.display_status(pub_key_pem.to_s)
-          self.format.display_status('Once created, copy the following parameters:')
+          formatter.display_status('Navigate to: 𓃑  → Admin → Configurations → API clients')
+          formatter.display_status('Create a client with:')
+          formatter.display_status('- JWT enabled')
+          formatter.display_status('- The following public key:')
+          formatter.display_status(pub_key_pem.to_s)
+          formatter.display_status('Once created, copy the following parameters:')
           @config_presets[params[:preset_name]] = {
             :url.to_s           => options.get_option(:url),
             :username.to_s      => options.get_option(:username),

data/lib/aspera/cli/plugins/cos.rb

@@ -14,7 +14,7 @@ module Aspera
           options.add_opt_simple(:bucket, 'Bucket name')
           options.add_opt_simple(:endpoint, 'Storage endpoint url')
           options.add_opt_simple(:apikey, 'Storage API key')
-          options.add_opt_simple(:crn, 'Ressource instance id')
+          options.add_opt_simple(:crn, 'Resource instance id')
           options.add_opt_simple(:service_credentials, 'IBM Cloud service credentials (Hash)')
           options.add_opt_simple(:region, 'Storage region')
           options.add_opt_simple(:identity, "Authentication url (#{CosNode::IBM_CLOUD_TOKEN_URL})")

data/lib/aspera/cli/plugins/faspex.rb

@@ -46,24 +46,24 @@ module Aspera
             if result[:http].body.start_with?('<?xml')
               res_s = XmlSimple.xml_in(result[:http].body, {'ForceArray' => false})
               version = res_s['XRD']['application']['version']
-              return {version: version}
+              return {version: version, url: result[:http].uri}
             end
             return nil
           end
 
           # extract elements from anonymous faspex link
-          def get_link_data(publink)
-            publink_uri = URI.parse(publink)
-            raise CliBadArgument, 'Public link does not match Faspex format' unless (m = publink_uri.path.match(%r{^(.*)/(external.*)$}))
+          def get_link_data(public_url)
+            public_uri = URI.parse(public_url)
+            raise CliBadArgument, 'Public link does not match Faspex format' unless (m = public_uri.path.match(%r{^(.*)/(external.*)$}))
             base = m[1]
             subpath = m[2]
-            port_add = publink_uri.port.eql?(publink_uri.default_port) ? '' : ":#{publink_uri.port}"
+            port_add = public_uri.port.eql?(public_uri.default_port) ? '' : ":#{public_uri.port}"
             result = {
-              base_url: "#{publink_uri.scheme}://#{publink_uri.host}#{port_add}#{base}",
+              base_url: "#{public_uri.scheme}://#{public_uri.host}#{port_add}#{base}",
               subpath:  subpath,
-              query:    URI.decode_www_form(publink_uri.query).each_with_object({}){|v, h|h[v.first] = v.last; }
+              query:    URI.decode_www_form(public_uri.query).each_with_object({}){|v, h|h[v.first] = v.last; }
             }
-            Log.dump('publink', result)
+            Log.dump('link data', result)
             return result
           end
 
@@ -125,12 +125,12 @@ module Aspera
             @api_v4 = Rest.new({
               base_url: faspex_api_base + '/api',
               auth:     {
-                type:     :oauth2,
-                base_url: faspex_api_base + '/auth/oauth2',
-                auth:     {type: :basic, username: options.get_option(:username, is_type: :mandatory), password: options.get_option(:password, is_type: :mandatory)},
-                crtype:   :generic,
-                generic:  {grant_type: 'password'},
-                scope:    'admin'
+                type:         :oauth2,
+                base_url:     faspex_api_base + '/auth/oauth2',
+                auth:         {type: :basic, username: options.get_option(:username, is_type: :mandatory), password: options.get_option(:password, is_type: :mandatory)},
+                grant_method: :generic,
+                generic:      {grant_type: 'password'},
+                scope:        'admin'
               }})
           end
           return @api_v4
@@ -205,7 +205,7 @@ module Aspera
         end
 
         # retrieve transfer spec from pub link for send package
-        def send_publink_to_ts(public_link_url, package_create_params)
+        def send_public_link_to_ts(public_link_url, package_create_params)
           delivery_info = package_create_params['delivery']
           # pub link user
           link_data = self.class.get_link_data(public_link_url)
@@ -215,28 +215,28 @@ module Aspera
           create_path = link_data[:subpath].split('/')[0..-2].join('/')
           package_create_params[:passcode] = link_data[:query]['passcode']
           delivery_info[:transfer_type] = 'connect'
-          delivery_info[:source_paths_list] = transfer.ts_source_paths.map{|i|i['source']}.join("\r\n")
+          delivery_info[:source_paths_list] = transfer.source_list.join("\r\n")
           api_public_link = Rest.new({base_url: link_data[:base_url]})
           # Hum, as this does not always work (only user, but not dropbox), we get the javascript and need hack
           # pkg_created=api_public_link.create(create_path,package_create_params)[:data]
           # so extract data from javascript
-          pkgdatares = api_public_link.call({
+          package_creation_data = api_public_link.call({
             operation:   'POST',
             subpath:     create_path,
             json_params: package_create_params,
             headers:     {'Accept' => 'text/javascript'}})[:http].body
           # get args of function call
-          pkgdatares.delete!("\n") # one line
-          pkgdatares.gsub!(/^[^"]+\("\{/, '{') # delete header
-          pkgdatares.gsub!(/"\);[^"]+$/, '"') # delete trailer
-          pkgdatares.gsub!(/\}", *"/, '},"') # between two args
-          pkgdatares.gsub!('\\"', '"') # remove protecting quote
+          package_creation_data.delete!("\n") # one line
+          package_creation_data.gsub!(/^[^"]+\("\{/, '{') # delete header
+          package_creation_data.gsub!(/"\);[^"]+$/, '"') # delete trailer
+          package_creation_data.gsub!(/\}", *"/, '},"') # between two args
+          package_creation_data.gsub!('\\"', '"') # remove protecting quote
           begin
-            pkgdatares = JSON.parse("[#{pkgdatares}]")
+            package_creation_data = JSON.parse("[#{package_creation_data}]")
           rescue JSON::ParserError # => e
             raise 'Unexpected response: missing metadata ?'
           end
-          return pkgdatares.first
+          return package_creation_data.first
         end
 
         ACTIONS = %i[health package source me dropbox v4 address_book login_methods].freeze
@@ -273,7 +273,7 @@ module Aspera
                 # authenticated user
                 delivery_info['sources'] ||= [{'paths' => []}]
                 first_source = delivery_info['sources'].first
-                first_source['paths'].push(*transfer.ts_source_paths.map{|i|i['source']})
+                first_source['paths'].push(*transfer.source_list)
                 source_name = options.get_option(:source_name)
                 if !source_name.nil?
                   source_list = api_v3.call({operation: 'GET', subpath: 'source_shares', headers: {'Accept' => 'application/json'}})[:data]['items']
@@ -294,8 +294,8 @@ module Aspera
                 transfer_spec = pkg_created['xfer_sessions'].first
                 # use source from cmd line, this one only contains destination (already in dest root)
                 transfer_spec.delete('paths')
-              else # publink
-                transfer_spec = send_publink_to_ts(public_link_url, package_create_params)
+              else # public link
+                transfer_spec = send_public_link_to_ts(public_link_url, package_create_params)
               end
               # Log.dump('transfer_spec',transfer_spec)
               return Main.result_transfer(transfer.start(transfer_spec))
@@ -319,15 +319,15 @@ module Aspera
                     ]))
                 end
                 # get command line parameters
-                delivid = instance_identifier
-                raise 'empty id' if delivid.empty?
+                delivery_id = instance_identifier
+                raise 'empty id' if delivery_id.empty?
                 recipient = options.get_option(:recipient)
-                if VAL_ALL.eql?(delivid)
+                if VAL_ALL.eql?(delivery_id)
                   pkg_id_uri = mailbox_filtered_entries.map{|i|{id: i[PACKAGE_MATCH_FIELD], uri: self.class.get_fasp_uri_from_entry(i, raise_no_link: false)}}
                 elsif !recipient.nil? && recipient.start_with?('*')
-                  found_package_link = mailbox_filtered_entries(stop_at_id: delivid).find{|p|p[PACKAGE_MATCH_FIELD].eql?(delivid)}['link'].first['href']
+                  found_package_link = mailbox_filtered_entries(stop_at_id: delivery_id).find{|p|p[PACKAGE_MATCH_FIELD].eql?(delivery_id)}['link'].first['href']
                   raise 'Not Found. Dropbox and Workgroup packages can use the link option with faspe:' if found_package_link.nil?
-                  pkg_id_uri = [{id: delivid, uri: found_package_link}]
+                  pkg_id_uri = [{id: delivery_id, uri: found_package_link}]
                 else
                   # TODO: delivery id is the right one if package was receive by workgroup
                   endpoint =
@@ -335,9 +335,9 @@ module Aspera
                     when :inbox, :archive then'received'
                     when :sent then 'sent'
                     end
-                  entry_xml = api_v3.call({operation: 'GET', subpath: "#{endpoint}/#{delivid}", headers: {'Accept' => 'application/xml'}})[:http].body
+                  entry_xml = api_v3.call({operation: 'GET', subpath: "#{endpoint}/#{delivery_id}", headers: {'Accept' => 'application/xml'}})[:http].body
                   package_entry = XmlSimple.xml_in(entry_xml, {'ForceArray' => true})
-                  pkg_id_uri = [{id: delivid, uri: self.class.get_fasp_uri_from_entry(package_entry)}]
+                  pkg_id_uri = [{id: delivery_id, uri: self.class.get_fasp_uri_from_entry(package_entry)}]
                 end
               when /^faspe:/
                 pkg_id_uri = [{id: 'package', uri: link_url}]
@@ -348,16 +348,16 @@ module Aspera
                 end
                 # NOTE: unauthenticated API (authorization is in url params)
                 api_public_link = Rest.new({base_url: link_data[:base_url]})
-                pkgdatares = api_public_link.call(
+                package_creation_data = api_public_link.call(
                   operation: 'GET',
                   subpath: link_data[:subpath],
                   url_params: {passcode: link_data[:query]['passcode']},
                   headers: {'Accept' => 'application/xml'})
-                if !pkgdatares[:http].body.start_with?('<?xml ')
+                if !package_creation_data[:http].body.start_with?('<?xml ')
                   OpenApplication.instance.uri(link_url)
                   raise CliError, 'Unexpected response: package not found ?'
                 end
-                package_entry = XmlSimple.xml_in(pkgdatares[:http].body, {'ForceArray' => false})
+                package_entry = XmlSimple.xml_in(package_creation_data[:http].body, {'ForceArray' => false})
                 Log.dump(:package_entry, package_entry)
                 transfer_uri = self.class.get_fasp_uri_from_entry(package_entry)
                 pkg_id_uri = [{id: package_entry['id'], uri: transfer_uri}]
@@ -480,7 +480,7 @@ module Aspera
               headers: {'Accept' => 'application/json'},
               url_params: {'format' => 'json', 'count' => 100_000}
             )[:data]
-            self.format.display_status("users: #{result['itemsPerPage']}/#{result['totalResults']}, start:#{result['startIndex']}")
+            formatter.display_status("users: #{result['itemsPerPage']}/#{result['totalResults']}, start:#{result['startIndex']}")
             users = result['entry']
             # add missing entries
             users.each do |u|