aspera-cli 4.11.0 → 4.12.0

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

@@ -28,14 +28,14 @@ module Aspera
         TMP_DIR_PREFIX = 'prev_tmp'
         DEFAULT_PREVIEWS_FOLDER = 'previews'
         AK_MARKER_FILE = '.aspera_access_key'
-        LOCAL_STORAGE_PCVL = 'file:///'
+        PVCL_LOCAL_STORAGE = 'file:///'
         LOG_LIMITER_SEC = 30.0
         private_constant :PREV_GEN_TAG,
           :PREVIEW_FOLDER_SUFFIX,
           :PREVIEW_BASENAME,
           :TMP_DIR_PREFIX,
           :DEFAULT_PREVIEWS_FOLDER,
-          :LOCAL_STORAGE_PCVL,
+          :PVCL_LOCAL_STORAGE,
           :AK_MARKER_FILE,
           :LOG_LIMITER_SEC
 
@@ -69,7 +69,7 @@ module Aspera
           options.add_opt_simple(:skip_folders, 'list of folder to skip')
           options.add_opt_simple(:case, 'basename of output for for test')
           options.add_opt_simple(:scan_path, 'subpath in folder id to start scan in (default=/)')
-          options.add_opt_simple(:scan_id, 'forder id in storage to start scan in, default is access key main folder id')
+          options.add_opt_simple(:scan_id, 'folder id in storage to start scan in, default is access key main folder id')
           options.add_opt_boolean(:mimemagic, 'use Mime type detection of gem mimemagic')
           options.add_opt_list(:overwrite, %i[always never mtime], 'when to overwrite result file')
           options.add_opt_list(:file_access, %i[local remote], 'how to read and write files in repository')
@@ -222,7 +222,7 @@ module Aspera
             # TODO: configurable ? useful ?
             @default_transfer_spec['remote_host'] = @transfer_server_address
           end
-          tspec = @default_transfer_spec.merge({
+          t_spec = @default_transfer_spec.merge({
             'direction' => direction,
             'paths'     => [{'source' => source_filename}],
             'tags'      => {
@@ -233,9 +233,9 @@ module Aspera
                   'file_id'    => folder_id }}}
           })
           # force destination
-          # tspec['destination_root']=destination
+          # t_spec['destination_root']=destination
           transfer.option_transfer_spec_deep_merge({'destination_root' => destination})
-          Main.result_transfer(transfer.start(tspec))
+          Main.result_transfer(transfer.start(t_spec))
         end
 
         def get_infos_local(gen_infos, entry)
@@ -437,7 +437,7 @@ module Aspera
               raise 'only local storage allowed in this mode' unless @access_key_self['storage']['type'].eql?('local')
               @local_storage_root = @access_key_self['storage']['path']
               # TODO: option to override @local_storage_root='xxx'
-              @local_storage_root = @local_storage_root[LOCAL_STORAGE_PCVL.length..-1] if @local_storage_root.start_with?(LOCAL_STORAGE_PCVL)
+              @local_storage_root = @local_storage_root[PVCL_LOCAL_STORAGE.length..-1] if @local_storage_root.start_with?(PVCL_LOCAL_STORAGE)
               # TODO: windows could have "C:" ?
               raise "not local storage: #{@local_storage_root}" unless @local_storage_root.start_with?('/')
               raise CliError, "Local storage root folder #{@local_storage_root} does not exist." unless File.directory?(@local_storage_root)
@@ -456,6 +456,8 @@ module Aspera
             end
           end
           Aspera::Preview::FileTypes.instance.use_mimemagic = options.get_option(:mimemagic, is_type: :mandatory)
+          # check tools that are anyway required for all cases
+          Aspera::Preview::Utils.check_tools(@skip_types)
           case command
           when :scan
             scan_path = options.get_option(:scan_path)
@@ -490,8 +492,7 @@ module Aspera
             send("process_#{command}", iteration_persistency)
             return Main.result_status("#{command} finished")
           when :check
-            Aspera::Preview::Utils.check_tools(@skip_types)
-            return Main.result_status('tools validated')
+            return Main.result_status('Tools validated')
           when :test
             format = options.get_next_argument('format', expected: Aspera::Preview::Generator::PREVIEW_FORMATS)
             source = options.get_next_argument('source file')

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

@@ -129,7 +129,7 @@ module Aspera
         # actions without ascmd
         BASE_ACTIONS = %i[health].concat(TRANSFER_COMMANDS).freeze
         # all actions
-        ACTIONS = [].concat(BASE_ACTIONS, Aspera::AsCmd::OPERATIONS, ASCMD_ALIASES.keys).freeze
+        ACTIONS = [BASE_ACTIONS, Aspera::AsCmd::OPERATIONS, ASCMD_ALIASES.keys].flatten.freeze
 
         def execute_action
           server_transfer_spec = options_to_base_transfer_spec

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

@@ -5,6 +5,7 @@ require 'aspera/cli/plugins/node'
 module Aspera
   module Cli
     module Plugins
+      # Plugin for Aspera Shares v1
       class Shares < Aspera::Cli::BasicAuthPlugin
         class << self
           def detect(base_url)
@@ -23,9 +24,12 @@ module Aspera
           end
         end
 
-        #        def initialize(env)
-        #          super(env)
-        #        end
+        def initialize(env)
+          super(env)
+          options.add_opt_list(:type, %i[any local ldap saml], 'Type of user/group for operations')
+          options.set_option(:type, :any)
+          options.parse_options!
+        end
 
         SAML_IMPORT_MANDATORY = %w[id name_id].freeze
         SAML_IMPORT_ALLOWED = %w[email given_name surname].concat(SAML_IMPORT_MANDATORY).freeze
@@ -52,58 +56,78 @@ module Aspera
             return nagios.result
           when :repository
             api_shares_node = basic_auth_api('node_api')
-            command = options.get_next_command(Node::COMMANDS_SHARES)
-            case command
-            when *Node::COMMANDS_SHARES then Node.new(@agents.merge(skip_basic_auth_options: true, node_api: api_shares_node)).execute_action(command)
-            else raise "INTERNAL ERROR, unknown command: [#{command}]"
-            end
+            repo_command = options.get_next_command(Node::COMMANDS_SHARES)
+            return Node.new(@agents.merge(skip_basic_auth_options: true, node_api: api_shares_node)).execute_action(repo_command)
           when :admin
             api_shares_admin = basic_auth_api('api/v1')
-            command = options.get_next_command(%i[user share])
-            case command
-            when :user
-              command = options.get_next_command(%i[list app_authorizations share_permissions saml_import ldap_import])
-              user_id = instance_identifier if %i[app_authorizations share_permissions].include?(command)
-              case command
-              when :list
-                return {type: :object_list, data: api_shares_admin.read('data/users')[:data], fields: %w[id username email directory_user urn]}
+            admin_command = options.get_next_command(%i[user group share node])
+            case admin_command
+            when :node
+              return entity_action(api_shares_admin, 'data/nodes')
+            when :user, :group
+              entity_type = admin_command
+              entities_location = options.get_option(:type, is_type: :mandatory)
+              entities_path = "data/#{entities_location}_#{entity_type}s"
+              entity_action = nil
+              case entities_location
+              when :any
+                entities_path = "data/#{entity_type}s"
+                entity_action = %i[list show delete share_permissions app_authorizations].freeze
+              when :local
+                entity_action = %i[list show create modify delete].freeze
+              when :ldap
+                entity_action = %i[add].freeze
+              when :saml
+                entity_action = %i[import].freeze
+              end
+              entity_command = options.get_next_command(entity_action)
+              entity_path = "#{entities_path}/#{instance_identifier}" if %i[app_authorizations share_permissions].include?(entity_command)
+              case entity_command
+              when :list, :show, :create, :delete, :modify
+                display_fields = entity_type.eql?(:user) ? %w[id username first_name last_name email] : nil
+                display_fields.push(:directory_user) if entity_type.eql?(:user) && entities_location.eql?(:any)
+                return entity_command(entity_command, api_shares_admin, entities_path, display_fields: display_fields)
               when :app_authorizations
-                return {type: :single_object, data: api_shares_admin.read("data/users/#{user_id}/app_authorizations")[:data]}
+                case options.get_next_command(%i[modify show])
+                when :show
+                  return {type: :single_object, data: api_shares_admin.read("#{entity_path}/app_authorizations")[:data]}
+                when :modify
+                  parameters = options.get_option(:value, is_type: :mandatory)
+                  return {type: :single_object, data: api_shares_admin.update("#{entity_path}/app_authorizations", parameters)[:data]}
+                end
               when :share_permissions
-                # share_name = options.get_next_argument('share name')
-                # all_shares = api_shares_admin.read('data/shares')[:data]
-                # share_id = all_shares.find{|s| s['name'].eql?(share_name)}['id']
-                return {type: :object_list, data: api_shares_admin.read("data/users/#{user_id}/share_permissions")[:data]}
-              when :saml_import
+                case options.get_next_command(%i[list show])
+                when :list
+                  return {type: :object_list, data: api_shares_admin.read("#{entity_path}/share_permissions")[:data]}
+                when :show
+                  return {type: :single_object, data: api_shares_admin.read("#{entity_path}/share_permissions/#{instance_identifier}")[:data]}
+                end
+              when :import
                 parameters = options.get_option(:value, is_type: :mandatory)
-                return do_bulk_operation(parameters, 'created') do |user_params|
-                  user_params = user_params.transform_keys{|k|k.gsub(/\s+/, '_').downcase}
-                  raise 'expecting Hash' unless user_params.is_a?(Hash)
-                  SAML_IMPORT_MANDATORY.each{|p|raise "missing mandatory field: #{p}" if user_params[p].nil?}
-                  user_params.each_key do |p|
+                return do_bulk_operation(parameters, 'created') do |entity_parameters|
+                  entity_parameters = entity_parameters.transform_keys{|k|k.gsub(/\s+/, '_').downcase}
+                  raise 'expecting Hash' unless entity_parameters.is_a?(Hash)
+                  SAML_IMPORT_MANDATORY.each{|p|raise "missing mandatory field: #{p}" if entity_parameters[p].nil?}
+                  entity_parameters.each_key do |p|
                     raise "unsupported field: #{p}, use: #{SAML_IMPORT_ALLOWED.join(',')}" unless SAML_IMPORT_ALLOWED.include?(p)
                   end
-                  api_shares_admin.create('data/saml_users/import', user_params)[:data]
+                  api_shares_admin.create("#{entities_path}/import", entity_parameters)[:data]
                 end
-              when :ldap_import
+              when :add
                 parameters = options.get_option(:value)
-                return do_bulk_operation(parameters, 'created') do |user_name|
-                  raise "expecting string (user name), have #{user_name.class}" unless user_name.is_a?(String)
-                  api_shares_admin.create('data/ldap_users', {'user'=>user_name})[:data]
+                return do_bulk_operation(parameters, 'created') do |entity_name|
+                  raise "expecting string (name), have #{entity_name.class}" unless entity_name.is_a?(String)
+                  api_shares_admin.create(entities_path, {entity_type=>entity_name})[:data]
                 end
               end
             when :share
-              command = options.get_next_command(%i[list user_permissions])
-              share_id = instance_identifier if %i[user_permissions].include?(command)
-              all_shares = api_shares_admin.read('data/shares')[:data]
-              case command
-              when :list
-                return {type: :object_list, data: all_shares, fields: %w[id name status status_message]}
-              when :user_permissions
-                # share_name = options.get_next_argument('share name')
-                # share_id = all_shares.find{|s| s['name'].eql?(share_name)}['id']
-                # raise "NOT IMPLEMENTED: #{share_name} #{share_id}"
-                return {type: :object_list, data: api_shares_admin.read("data/shares/#{share_id}/user_permissions")[:data]}
+              share_command = options.get_next_command(%i[user_permissions group_permissions].concat(Plugin::ALL_OPS))
+              case share_command
+              when *Plugin::ALL_OPS
+                return entity_command(share_command, api_shares_admin, 'data/shares')
+                # return {type: :object_list, data: all_shares, fields: %w[id name status status_message]}
+              when :user_permissions, :group_permissions
+                return entity_action(api_shares_admin, "data/shares/#{instance_identifier}/#{share_command}")
               end
             end
           end

data/lib/aspera/cli/transfer_agent.rb

@@ -25,7 +25,7 @@ module Aspera
 
         <%=ts.to_yaml%>
       END_OF_TEMPLATE
-      # % (formating bug in eclipse)
+      # % (formatting bug in eclipse)
       private_constant :FILE_LIST_FROM_ARGS,
         :FILE_LIST_FROM_TRANSFER_SPEC,
         :FILE_LIST_OPTIONS,
@@ -42,8 +42,6 @@ module Aspera
         end
       end
 
-      attr_accessor :token_regenerator
-
       # @param env external objects: option manager, config file manager
       def initialize(opt_mgr, config)
         @opt_mgr = opt_mgr
@@ -55,13 +53,10 @@ module Aspera
         @progress_listener = Listener::ProgressMulti.new
         # source/destination pair, like "paths" of transfer spec
         @transfer_paths = nil
-        # only used with agent "direct" allows to regenerate the token if it is expired
-        @token_regenerator = nil
         @opt_mgr.set_obj_attr(:ts, self, :option_transfer_spec)
         @opt_mgr.add_opt_simple(:ts, "Override transfer spec values (Hash, e.g. use @json: prefix), current=#{@opt_mgr.get_option(:ts)}")
-        @opt_mgr.add_opt_simple(:to_folder, 'Destination folder for transfered files')
-        @opt_mgr.add_opt_simple(:sources, "How list of transfered files is provided (#{FILE_LIST_OPTIONS.join(',')})")
-        @opt_mgr.add_opt_simple(:ascp_opts, 'Options for ascp in its native format')
+        @opt_mgr.add_opt_simple(:to_folder, 'Destination folder for transferred files')
+        @opt_mgr.add_opt_simple(:sources, "How list of transferred files is provided (#{FILE_LIST_OPTIONS.join(',')})")
         @opt_mgr.add_opt_list(:src_type, %i[list pair], 'Type of file list')
         @opt_mgr.add_opt_list(:transfer, TRANSFER_AGENTS, 'Type of transfer agent')
         @opt_mgr.add_opt_simple(:transfer_info, 'Parameters for transfer agent')
@@ -70,7 +65,6 @@ module Aspera
         @opt_mgr.set_option(:src_type, :list)
         @opt_mgr.set_option(:progress, :native) # use native ascp progress bar as it is more reliable
         @opt_mgr.parse_options!
-        Fasp::TransferSpec.ascp_opts_to_ts(@transfer_spec_cmdline, @opt_mgr.get_option(:ascp_opts))
       end
 
       def option_transfer_spec; @transfer_spec_cmdline; end
@@ -135,9 +129,15 @@ module Aspera
         return dest_folder
       end
 
-      # This is how the list of files to be transfered is specified
+      def source_list
+        return ts_source_paths.map do |i|
+          i['source']
+        end
+      end
+
+      # This is how the list of files to be transferred is specified
       # get paths suitable for transfer spec from command line
-      # @return {source: (mandatory), destination: (optional)}
+      # @return [Hash] {source: (mandatory), destination: (optional)}
       # computation is done only once, cache is kept in @transfer_paths
       def ts_source_paths
         # return cache if set
@@ -157,7 +157,7 @@ module Aspera
           Log.log.debug('assume list provided in transfer spec')
           special_case_direct_with_list =
             @opt_mgr.get_option(:transfer, is_type: :mandatory).eql?(:direct) &&
-            Fasp::Parameters.ts_has_ascp_file_list(@transfer_spec_cmdline)
+            Fasp::Parameters.ts_has_ascp_file_list(@transfer_spec_cmdline, @opt_mgr.get_option(:transfer_info))
           raise CliBadArgument, 'transfer spec on command line must have sources' if @transfer_paths.nil? && !special_case_direct_with_list
           # here we assume check of sources is made in transfer agent
           return @transfer_paths
@@ -185,8 +185,9 @@ module Aspera
       end
 
       # start a transfer and wait for completion, plugins shall use this method
-      # @param transfer_spec
-      def start(transfer_spec)
+      # @param transfer_spec [Hash]
+      # @param rest_token [Rest] if oauth token regeneration supported
+      def start(transfer_spec, rest_token: nil)
         # check parameters
         raise 'transfer_spec must be hash' unless transfer_spec.is_a?(Hash)
         # process :src option
@@ -216,8 +217,7 @@ module Aspera
         # create transfer agent
         set_agent_by_options
         Log.log.debug{"transfer agent is a #{@agent.class}"}
-        @agent.token_regenerator = @token_regenerator if @agent.respond_to?(:token_regenerator=)
-        @agent.start_transfer(transfer_spec)
+        @agent.start_transfer(transfer_spec, token_regenerator: rest_token)
         # list of : :success or error message
         result = @agent.wait_for_transfers_completion
         @progress_listener.reset

data/lib/aspera/cli/version.rb

@@ -2,6 +2,7 @@
 
 module Aspera
   module Cli
-    VERSION = '4.11.0'
+    # for beta add extension : .beta1
+    VERSION = '4.12.0'
   end
 end

data/lib/aspera/command_line_builder.rb

@@ -6,8 +6,14 @@ module Aspera
   # process_param is called repeatedly with all known parameters
   # add_env_args is called to get resulting param list and env var (also checks that all params were used)
   class CommandLineBuilder
-    # parameter with onne of those tags is an ascp command line option with --
-    CLTYPE_OPTIONS = %i[opt_without_arg opt_with_arg].freeze
+    # parameter with one of those tags is a command line option with --
+    CLI_OPTION_TYPE_SWITCH = %i[opt_without_arg opt_with_arg].freeze
+    CLI_OPTION_TYPES = %i[special ignore envvar].concat(CLI_OPTION_TYPE_SWITCH).freeze
+    OPTIONS_KEYS = %i[desc accepted_types default enum agents required cli ts].freeze
+    CLI_KEYS = %i[type switch convert variable].freeze
+
+    private_constant :CLI_OPTION_TYPE_SWITCH, :OPTIONS_KEYS, :CLI_KEYS
+
     class << self
       # transform yes/no to true/false
       def yes_to_true(value)
@@ -19,36 +25,33 @@ module Aspera
       end
 
       # Called by provider of definition before constructor of this class so that params_definition has all mandatory fields
-      def normalize_description(d)
-        d.each do |param_name, options|
-          raise "Expecting Hash, but have #{options.class} in #{param_name}" unless options.is_a?(Hash)
-          # options[:accepted_types]=:bool if options[:cltype].eql?(:envvar) and !options.has_key?(:accepted_types)
-          # by default : not mandatory
+      def normalize_description(full_description)
+        full_description.each do |name, options|
+          raise "Expecting Hash, but have #{options.class} in #{name}" unless options.is_a?(Hash)
+          unsupported_keys = options.keys - OPTIONS_KEYS
+          raise "Unsupported definition keys: #{unsupported_keys}" unless unsupported_keys.empty?
+          raise "Missing key: cli for #{name}" unless options.key?(:cli)
+          raise 'Key: cli must be Hash' unless options[:cli].is_a?(Hash)
+          raise 'Missing key: cli.type' unless options[:cli].key?(:type)
+          raise "Unsupported processing type for #{name}: #{options[:cli][:type]}" unless CLI_OPTION_TYPES.include?(options[:cli][:type])
+          # by default : optional
           options[:mandatory] ||= false
           options[:desc] ||= ''
+          cli = options[:cli]
+          unsupported_cli_keys = cli.keys - CLI_KEYS
+          raise "Unsupported cli keys: #{unsupported_cli_keys}" unless unsupported_cli_keys.empty?
           # by default : string, unless it's without arg
-          if !options.key?(:accepted_types)
-            options[:accepted_types] = options[:cltype].eql?(:opt_without_arg) ? :bool : :string
-          end
+          options[:accepted_types] ||= options[:cli][:type].eql?(:opt_without_arg) ? :bool : :string
           # single type is placed in array
           options[:accepted_types] = [options[:accepted_types]] unless options[:accepted_types].is_a?(Array)
           # add default switch name if not present
-          if !options.key?(:clswitch) && options.key?(:cltype) && CLTYPE_OPTIONS.include?(options[:cltype])
-            options[:clswitch] = '--' + param_name.to_s.tr('_', '-')
+          if !cli.key?(:switch) && cli.key?(:type) && CLI_OPTION_TYPE_SWITCH.include?(cli[:type])
+            cli[:switch] = '--' + name.to_s.tr('_', '-')
           end
         end
       end
-  end
-
-    private
-
-    # clvarname : command line variable name
-    def env_name(_param_name, options)
-      return options[:clvarname]
     end
 
-    public
-
     attr_reader :params_definition
 
     # @param param_hash
@@ -60,22 +63,19 @@ module Aspera
       @used_param_names = []
     end
 
-    def warn_unrecognized_params
-      # warn about non translated arguments
-      @param_hash.each_pair{|key, val|Log.log.warn{"unrecognized parameter: #{key} = \"#{val}\""} if !@used_param_names.include?(key)}
-    end
-
     # adds keys :env :args with resulting values after processing
     # warns if some parameters were not used
     def add_env_args(env, args)
       Log.log.debug{"ENV=#{@result_env}, ARGS=#{@result_args}"}
-      warn_unrecognized_params
+      # warn about non translated arguments
+      @param_hash.each_pair{|key, val|Log.log.warn{"unrecognized parameter: #{key} = \"#{val}\""} if !@used_param_names.include?(key)}
+      # set result
       env.merge!(@result_env)
       args.push(*@result_args)
       return nil
     end
 
-    # add options directly to ascp command line
+    # add options directly to command line
     def add_command_line_options(options)
       return if options.nil?
       options.each{|o|@result_args.push(o.to_s)}
@@ -87,88 +87,92 @@ module Aspera
       end
     end
 
+    def read_param(name)
+      return process_param(name, read: true)
+    end
+
+    private
+
     # Process a parameter from transfer specification and generate command line param or env var
-    # @param param_name : key in transfer spec
-    # @param action : type of processing: ignore getvalue envvar opt_without_arg opt_with_arg defer
-    # @param options : options for type
-    def process_param(param_name, action=nil)
-      options = @params_definition[param_name]
+    # @param name [String] of parameter
+    # @param read [TrueClass,FalseClass] read and return value of parameter instead of normal processing (for special)
+    def process_param(name, read: false)
+      options = @params_definition[name]
       # should not happen
       if options.nil?
-        Log.log.warn{"Unknown parameter #{param_name}"}
+        Log.log.warn{"Unknown parameter #{name}"}
         return
       end
-      action = options[:cltype] if action.nil?
+      processing_type = read ? :get_value : options[:cli][:type]
       # check mandatory parameter (nil is valid value)
-      raise Fasp::Error, "Missing mandatory parameter: #{param_name}" if options[:mandatory] && !@param_hash.key?(param_name)
-      parameter_value = @param_hash[param_name]
-
+      raise Fasp::Error, "Missing mandatory parameter: #{name}" if options[:mandatory] && !@param_hash.key?(name)
+      parameter_value = @param_hash[name]
+      # no default setting
       # parameter_value=options[:default] if parameter_value.nil? and options.has_key?(:default)
-
       # Check parameter type
-      expected_classes = options[:accepted_types].map do |s|
-        case s
+      expected_classes = options[:accepted_types].map do |type_symbol|
+        case type_symbol
         when :string then String
         when :array then Array
         when :hash then Hash
         when :int then Integer
         when :bool then [TrueClass, FalseClass]
-        else raise "INTERNAL: unexpected value: #{s}"
+        else raise "INTERNAL: unexpected value: #{type_symbol}"
         end
       end.flatten
-      raise Fasp::Error, "#{param_name} is : #{parameter_value.class} (#{parameter_value}), shall be #{options[:accepted_types]}, " \
+      # check that value is of expected type
+      raise Fasp::Error, "#{name} is : #{parameter_value.class} (#{parameter_value}), shall be #{options[:accepted_types]}, " \
         unless parameter_value.nil? || expected_classes.include?(parameter_value.class)
-      @used_param_names.push(param_name) unless action.eql?(:defer)
+      # special processing will be requested with type get_value
+      @used_param_names.push(name) unless processing_type.eql?(:special)
 
       # process only non-nil values
       return nil if parameter_value.nil?
 
       # check that value is of an accepted type (string, int bool)
-      raise "Value #{parameter_value} is not allowed for #{param_name}" if options.key?(:enum) && !options[:enum].include?(parameter_value)
+      raise "Enum value #{parameter_value} is not allowed for #{name}" if options.key?(:enum) && !options[:enum].include?(parameter_value)
 
       # convert some values if value on command line needs processing from value in structure
-      case options[:clconvert]
+      case options[:cli][:convert]
       when Hash
         # translate using conversion table
-        new_value = options[:clconvert][parameter_value]
-        raise "unsupported value: #{parameter_value}, expect: #{options[:clconvert].keys.join(', ')}" if new_value.nil?
+        new_value = options[:cli][:convert][parameter_value]
+        raise "unsupported value: #{parameter_value}, expect: #{options[:cli][:convert].keys.join(', ')}" if new_value.nil?
         parameter_value = new_value
       when String
-        # :clconvert has name of class and encoding method
-        convclass, convmethod = options[:clconvert].split('.')
-        newvalue = Kernel.const_get(convclass).send(convmethod, parameter_value)
-        raise Fasp::Error, "unsupported #{param_name}: #{parameter_value}" if newvalue.nil?
-        parameter_value = newvalue
+        # :convert has name of class and encoding method
+        conversion_class, conversion_method = options[:cli][:convert].split('.')
+        converted_value = Kernel.const_get(conversion_class).send(conversion_method, parameter_value)
+        raise Fasp::Error, "unsupported #{name}: #{parameter_value}" if converted_value.nil?
+        parameter_value = converted_value
       when NilClass
-      else raise "not expected type for clconvert #{options[:clconvert].class} for #{param_name}"
+      else raise "not expected type for convert #{options[:cli][:convert].class} for #{name}"
       end
 
-      case action
-      when :ignore, :defer # ignore this parameter or process later
-        return
-      when :get_value # just get value
+      case processing_type
+      when :get_value # just get value (deferred)
         return parameter_value
+      when :ignore, :special # ignore this parameter or process later
+        return
       when :envvar # set in env var
-        # define ascp parameter in env var from transfer spec
-        @result_env[env_name(param_name, options)] = parameter_value
+        raise 'error' unless options[:cli].key?(:variable)
+        @result_env[options[:cli][:variable]] = parameter_value
       when :opt_without_arg # if present and true : just add option without value
         add_param = false
         case parameter_value
         when false then nil # nothing to put on command line, no creation by default
         when true then add_param = true
-        else raise Fasp::Error, "unsupported #{param_name}: #{parameter_value}"
+        else raise Fasp::Error, "unsupported #{name}: #{parameter_value}"
         end
         add_param = !add_param if options[:add_on_false]
-        add_command_line_options([options[:clswitch]]) if add_param
+        add_command_line_options([options[:cli][:switch]]) if add_param
       when :opt_with_arg # transform into command line option with value
         # parameter_value=parameter_value.to_s if parameter_value.is_a?(Integer)
         parameter_value = [parameter_value] unless parameter_value.is_a?(Array)
         # if transfer_spec value is an array, applies option many times
-        parameter_value.each{|v|add_command_line_options([options[:clswitch], v])}
-      when NilClass
-        Log.log.debug{"Ignoring parameter: #{param_name}"}
+        parameter_value.each{|v|add_command_line_options([options[:cli][:switch], v])}
       else
-        raise "ERROR: unknown action: #{action}/#{action.class}"
+        raise "ERROR: unknown option processing type: #{processing_type}/#{processing_type.class}"
       end
     end
   end

data/lib/aspera/cos_node.rb

@@ -37,10 +37,10 @@ module Aspera
         not_auth_codes: %w[401 403], # error codes when not authorized
         headers:        {'ibm-service-instance-id' => instance_id},
         auth:           {
-          type:     :oauth2,
-          base_url: @auth_url,
-          crtype:   :generic,
-          generic:  {
+          type:         :oauth2,
+          base_url:     @auth_url,
+          grant_method: :generic,
+          generic:      {
             grant_type:    'urn:ibm:params:oauth:grant-type:apikey',
             response_type: 'cloud_iam',
             apikey:        @api_key
@@ -74,11 +74,11 @@ module Aspera
     def generate_token
       # OAuth API to get delegated token
       delegated_oauth = Oauth.new({
-        type:        :oauth2,
-        base_url:    @auth_url,
-        token_field: TOKEN_FIELD,
-        crtype:      :generic,
-        generic:     {
+        type:         :oauth2,
+        base_url:     @auth_url,
+        token_field:  TOKEN_FIELD,
+        grant_method: :generic,
+        generic:      {
           grant_type:          'urn:ibm:params:oauth:grant-type:apikey',
           response_type:       'delegated_refresh_token',
           apikey:              @api_key,

data/lib/aspera/fasp/agent_base.rb

@@ -6,6 +6,7 @@ module Aspera
     # sub classes shall implement start_transfer and shutdown
     class AgentBase
       # fields description for JSON generation
+      # spellchecker: disable
       INTEGER_FIELDS = %w[Bytescont FaspFileArgIndex StartByte Rate MinRate Port Priority RateCap MinRateCap TCPPort CreatePolicy TimePolicy
                           DatagramSize XoptFlags VLinkVersion PeerVLinkVersion DSPipelineDepth PeerDSPipelineDepth ReadBlockSize WriteBlockSize
                           ClusterNumNodes ClusterNodeId Size Written Loss FileBytes PreTransferBytes TransferBytes PMTU Elapsedusec ArgScansAttempted
@@ -14,6 +15,7 @@ module Aspera
                           MoveRange Keepalive TestLogin UseProxy Precalc RTTAutocorrect].freeze
       EXPECTED_METHODS = %i[text struct enhanced].freeze
       private_constant :INTEGER_FIELDS, :BOOLEAN_FIELDS, :EXPECTED_METHODS
+      # spellchecker: enable
 
       class << self
         # This checks the validity of the value returned by wait_for_transfers_completion
@@ -84,7 +86,7 @@ module Aspera
       end
 
       # the following methods must be implemented by subclass:
-      # start_transfer(transfer_spec) : start and wait for completion
+      # start_transfer(transfer_spec, token_regenerator: nil) : start transfer
       # wait_for_transfers_completion : wait for termination of all transfers, @return list of : :success or error message
       # optional: shutdown
     end