aspera-cli 4.10.0 → 4.12.0

data/lib/aspera/cli/transfer_agent.rb

@@ -15,7 +15,7 @@ module Aspera
       FILE_LIST_FROM_ARGS = '@args'
       # special value for --sources : read file list from transfer spec (--ts)
       FILE_LIST_FROM_TRANSFER_SPEC = '@ts'
-      FILE_LIST_OPTIONS=[FILE_LIST_FROM_ARGS,FILE_LIST_FROM_TRANSFER_SPEC,'Array'].freeze
+      FILE_LIST_OPTIONS = [FILE_LIST_FROM_ARGS, FILE_LIST_FROM_TRANSFER_SPEC, 'Array'].freeze
       DEFAULT_TRANSFER_NOTIF_TMPL = <<~END_OF_TEMPLATE
         From: <%=from_name%> <<%=from_email%>>
         To: <<%=to%>>
@@ -25,8 +25,10 @@ module Aspera
 
         <%=ts.to_yaml%>
       END_OF_TEMPLATE
-      #% (formating bug in eclipse)
-      private_constant :FILE_LIST_FROM_ARGS,:FILE_LIST_FROM_TRANSFER_SPEC,:FILE_LIST_OPTIONS,
+      # % (formatting bug in eclipse)
+      private_constant :FILE_LIST_FROM_ARGS,
+        :FILE_LIST_FROM_TRANSFER_SPEC,
+        :FILE_LIST_OPTIONS,
         :DEFAULT_TRANSFER_NOTIF_TMPL
       TRANSFER_AGENTS = %i[direct node connect httpgw trsdk].freeze
 
@@ -41,7 +43,7 @@ module Aspera
       end
 
       # @param env external objects: option manager, config file manager
-      def initialize(opt_mgr,config)
+      def initialize(opt_mgr, config)
         @opt_mgr = opt_mgr
         @config = config
         # command line can override transfer spec
@@ -51,18 +53,17 @@ module Aspera
         @progress_listener = Listener::ProgressMulti.new
         # source/destination pair, like "paths" of transfer spec
         @transfer_paths = nil
-        @opt_mgr.set_obj_attr(:ts,self,:option_transfer_spec)
-        @opt_mgr.add_opt_simple(:ts,"override transfer spec values (Hash, use @json: prefix), current=#{@opt_mgr.get_option(:ts)}")
-        @opt_mgr.add_opt_simple(:local_resume,"set resume policy (Hash, use @json: prefix), current=#{@opt_mgr.get_option(:local_resume)}")
-        @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_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')
-        @opt_mgr.add_opt_list(:progress,%i[none native multi],'type of progress bar')
-        @opt_mgr.set_option(:transfer,:direct)
-        @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.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 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')
+        @opt_mgr.add_opt_list(:progress, %i[none native multi], 'Type of progress bar')
+        @opt_mgr.set_option(:transfer, :direct)
+        @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!
       end
 
@@ -77,8 +78,8 @@ module Aspera
         @agent = instance
         @agent.add_listener(Listener::Logger.new)
         # use local progress bar if asked so, or if native and non local ascp (because only local ascp has native progress bar)
-        if @opt_mgr.get_option(:progress,is_type: :mandatory).eql?(:multi) ||
-        (@opt_mgr.get_option(:progress,is_type: :mandatory).eql?(:native) && !instance.class.to_s.eql?('Aspera::Fasp::AgentDirect'))
+        if @opt_mgr.get_option(:progress, is_type: :mandatory).eql?(:multi) ||
+            (@opt_mgr.get_option(:progress, is_type: :mandatory).eql?(:native) && !instance.class.to_s.eql?('Aspera::Fasp::AgentDirect'))
           @agent.add_listener(@progress_listener)
         end
       end
@@ -86,20 +87,20 @@ module Aspera
       # analyze options and create new agent if not already created or set
       def set_agent_by_options
         return nil unless @agent.nil?
-        agent_type = @opt_mgr.get_option(:transfer,is_type: :mandatory)
+        agent_type = @opt_mgr.get_option(:transfer, is_type: :mandatory)
         # agent plugin is loaded on demand to avoid loading unnecessary dependencies
         require "aspera/fasp/agent_#{agent_type}"
         agent_options = @opt_mgr.get_option(:transfer_info)
-        raise CliBadArgument,"the transfer agent configuration shall be Hash, not #{agent_options.class} (#{agent_options}), "\
-          'use either @json:<json> or @preset:<parameter set name>' unless [Hash,NilClass].include?(agent_options.class)
+        raise CliBadArgument, "the transfer agent configuration shall be Hash, not #{agent_options.class} (#{agent_options}), "\
+          'use either @json:<json> or @preset:<parameter set name>' unless [Hash, NilClass].include?(agent_options.class)
         # special case
         if agent_type.eql?(:node) && agent_options.nil?
           param_set_name = @config.get_plugin_default_config_name(:node)
-          raise CliBadArgument,"No default node configured, Please specify --#{:transfer_info.to_s.tr('_','-')}" if param_set_name.nil?
+          raise CliBadArgument, "No default node configured, Please specify --#{:transfer_info.to_s.tr('_', '-')}" if param_set_name.nil?
           agent_options = @config.preset_by_name(param_set_name)
         end
         # special case
-        if agent_type.eql?(:direct) && @opt_mgr.get_option(:progress,is_type: :mandatory).eql?(:native)
+        if agent_type.eql?(:direct) && @opt_mgr.get_option(:progress, is_type: :mandatory).eql?(:native)
           agent_options = {} if agent_options.nil?
           agent_options[:quiet] = false
         end
@@ -128,105 +129,104 @@ 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
         return @transfer_paths unless @transfer_paths.nil?
         # start with lower priority : get paths from transfer spec on command line
-        @transfer_paths = @transfer_spec_cmdline['paths'] if @transfer_spec_cmdline.has_key?('paths')
+        @transfer_paths = @transfer_spec_cmdline['paths'] if @transfer_spec_cmdline.key?('paths')
         # is there a source list option ?
         file_list = @opt_mgr.get_option(:sources)
         case file_list
-        when nil,FILE_LIST_FROM_ARGS
+        when nil, FILE_LIST_FROM_ARGS
           Log.log.debug('getting file list as parameters')
           # get remaining arguments
-          file_list = @opt_mgr.get_next_argument('source file list',expected: :multiple)
-          raise CliBadArgument,'specify at least one file on command line or use '\
+          file_list = @opt_mgr.get_next_argument('source file list', expected: :multiple)
+          raise CliBadArgument, 'specify at least one file on command line or use '\
             "--sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !file_list.is_a?(Array) || file_list.empty?
         when FILE_LIST_FROM_TRANSFER_SPEC
           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)
-          raise CliBadArgument,'transfer spec on command line must have sources' if @transfer_paths.nil? && !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, @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
         when Array
           Log.log.debug('getting file list as extended value')
-          raise CliBadArgument,'sources must be a Array of String' if !file_list.reject{|f|f.is_a?(String)}.empty?
+          raise CliBadArgument, 'sources must be a Array of String' if !file_list.reject{|f|f.is_a?(String)}.empty?
         else
-          raise CliBadArgument,"sources must be a Array, not #{file_list.class}"
+          raise CliBadArgument, "sources must be a Array, not #{file_list.class}"
         end
         # here, file_list is an Array or String
         if !@transfer_paths.nil?
           Log.log.warn('--sources overrides paths from --ts')
         end
-        case @opt_mgr.get_option(:src_type,is_type: :mandatory)
+        case @opt_mgr.get_option(:src_type, is_type: :mandatory)
         when :list
           # when providing a list, just specify source
           @transfer_paths = file_list.map{|i|{'source' => i}}
         when :pair
-          raise CliBadArgument,"When using pair, provide an even number of paths: #{file_list.length}" unless file_list.length.even?
-          @transfer_paths = file_list.each_slice(2).to_a.map{|s,d|{'source' => s,'destination' => d}}
+          raise CliBadArgument, "When using pair, provide an even number of paths: #{file_list.length}" unless file_list.length.even?
+          @transfer_paths = file_list.each_slice(2).to_a.map{|s, d|{'source' => s, 'destination' => d}}
         else raise 'Unsupported src_type'
         end
-        Log.log.debug("paths=#{@transfer_paths}")
+        Log.log.debug{"paths=#{@transfer_paths}"}
         return @transfer_paths
       end
 
       # start a transfer and wait for completion, plugins shall use this method
-      # @param transfer_spec
-      # @param tr_opts specific options for the transfer_agent
-      # tr_opts[:src] specifies how destination_root is set (how transfer spec was generated)
-      # other options are carried to specific agent
-      def start(transfer_spec,tr_opts)
+      # @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)
-        raise 'tr_opts must be hash' unless tr_opts.is_a?(Hash)
         # process :src option
         case transfer_spec['direction']
         when Fasp::TransferSpec::DIRECTION_RECEIVE
           # init default if required in any case
           @transfer_spec_cmdline['destination_root'] ||= destination_folder(transfer_spec['direction'])
         when Fasp::TransferSpec::DIRECTION_SEND
-          case tr_opts[:src]
-          when :direct
-            # init default if required
-            @transfer_spec_cmdline['destination_root'] ||= destination_folder(transfer_spec['direction'])
-          when :node_gen3
+          if transfer_spec.dig('tags', 'aspera', 'node', 'access_key')
+            # gen4
+            @transfer_spec_cmdline.delete('destination_root') if @transfer_spec_cmdline.key?('destination_root_id')
+          elsif transfer_spec.key?('token')
+            # gen3
             # in that case, destination is set in return by application (API/upload_setup)
             # but to_folder was used in initial API call
             @transfer_spec_cmdline.delete('destination_root')
-          when :node_gen4
-            @transfer_spec_cmdline.delete('destination_root') if @transfer_spec_cmdline.has_key?('destination_root_id')
           else
-            raise StandardError,"InternalError: unsupported value: #{tr_opts[:src]}"
+            # init default if required
+            @transfer_spec_cmdline['destination_root'] ||= destination_folder(transfer_spec['direction'])
           end
         end
-
-        # only used here
-        tr_opts.delete(:src)
-
         # update command line paths, unless destination already has one
         @transfer_spec_cmdline['paths'] = transfer_spec['paths'] || ts_source_paths
-
         transfer_spec.merge!(@transfer_spec_cmdline)
+        # remove values that are nil (user wants to delete)
+        transfer_spec.delete_if { |_key, value| value.nil? }
         # create transfer agent
         set_agent_by_options
-        Log.log.debug("transfer agent is a #{@agent.class}")
-        @agent.start_transfer(transfer_spec,tr_opts)
+        Log.log.debug{"transfer agent is a #{@agent.class}"}
+        @agent.start_transfer(transfer_spec, token_regenerator: rest_token)
         # list of : :success or error message
         result = @agent.wait_for_transfers_completion
         @progress_listener.reset
         Fasp::AgentBase.validate_status_list(result)
-        send_email_transfer_notification(transfer_spec,result)
+        send_email_transfer_notification(transfer_spec, result)
         return result
       end
 
-      def send_email_transfer_notification(transfer_spec,statuses)
+      def send_email_transfer_notification(transfer_spec, statuses)
         return if @opt_mgr.get_option(:notif_to).nil?
         global_status = self.class.session_status(statuses)
         email_vars = {

data/lib/aspera/cli/version.rb

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

data/lib/aspera/colors.rb

@@ -5,7 +5,7 @@ class String
   class << self
     private
 
-    def vtcmd(code);"\e[#{code}m";end
+    def vtcmd(code); "\e[#{code}m"; end
   end
   # see https://en.wikipedia.org/wiki/ANSI_escape_code
   # symbol is the method name added to String
@@ -35,11 +35,11 @@ class String
   }.freeze
   private_constant :VTSTYLES
   # defines methods to String, one per entry in VTSTYLES
-  VTSTYLES.each do |name,code|
+  VTSTYLES.each do |name, code|
     if $stderr.tty?
       begin_seq = vtcmd(code)
       end_code = 0 # by default reset all
-      if code <= 7 then 20 + code
+      if code <= 7 then code + 20
       elsif code <= 37 then 39
       elsif code <= 47 then 49
       end

data/lib/aspera/command_line_builder.rb

@@ -6,9 +6,15 @@ 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
-    class<<self
+    # 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)
         case value
@@ -19,40 +25,37 @@ 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.has_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.has_key?(:clswitch) && options.has_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
-    def initialize(param_hash,params_definition)
+    def initialize(param_hash, params_definition)
       @param_hash = param_hash # keep reference so that it can be modified by caller before calling `process_params`
       @params_definition = params_definition
       @result_env = {}
@@ -60,115 +63,116 @@ 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
+    def add_env_args(env, args)
+      Log.log.debug{"ENV=#{@result_env}, ARGS=#{@result_args}"}
+      # 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)}
     end
 
     def process_params
-      @params_definition.keys.each do |k|
+      @params_definition.each_key do |k|
         process_param(k)
       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.has_key?(param_name)
-      parameter_value = @param_hash[param_name]
-
-      #parameter_value=options[:default] if parameter_value.nil? and options.has_key?(:default)
-
+      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}"
+        when :bool then [TrueClass, FalseClass]
+        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.has_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.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

@@ -5,19 +5,19 @@ require 'aspera/rest'
 require 'xmlsimple'
 
 module Aspera
-  class CosNode < Rest
+  class CosNode < Aspera::Node
     class << self
-      def parameters_from_svc_creds(service_credentials,bucket_region)
+      def parameters_from_svc_creds(service_credentials, bucket_region)
         # check necessary contents
         raise 'service_credentials must be a Hash' unless service_credentials.is_a?(Hash)
         %w[apikey resource_instance_id endpoints].each do |field|
-          raise "service_credentials must have a field: #{field}" unless service_credentials.has_key?(field)
+          raise "service_credentials must have a field: #{field}" unless service_credentials.key?(field)
         end
-        Aspera::Log.dump('service_credentials',service_credentials)
+        Aspera::Log.dump('service_credentials', service_credentials)
         # read endpoints from service provided in service credentials
         endpoints = Aspera::Rest.new({base_url: service_credentials['endpoints']}).read('')[:data]
-        Aspera::Log.dump('endpoints',endpoints)
-        storage_endpoint = endpoints.dig('service-endpoints','regional',bucket_region,'public',bucket_region)
+        Aspera::Log.dump('endpoints', endpoints)
+        storage_endpoint = endpoints.dig('service-endpoints', 'regional', bucket_region, 'public', bucket_region)
         raise "no such region: #{bucket_region}" if storage_endpoint.nil?
         return {
           instance_id:      service_credentials['resource_instance_id'],
@@ -28,8 +28,8 @@ module Aspera
     end
     IBM_CLOUD_TOKEN_URL = 'https://iam.cloud.ibm.com/identity'
     TOKEN_FIELD = 'delegated_refresh_token'
-    attr_reader :add_ts
-    def initialize(bucket_name,storage_endpoint,instance_id,api_key,auth_url=IBM_CLOUD_TOKEN_URL)
+
+    def initialize(bucket_name, storage_endpoint, instance_id, api_key, auth_url= IBM_CLOUD_TOKEN_URL)
       @auth_url = auth_url
       @api_key = api_key
       s3_api = Aspera::Rest.new({
@@ -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
@@ -53,18 +53,20 @@ module Aspera
         url_params: {'faspConnectionInfo' => nil}
       )[:http].body
       ats_info = XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
-      Aspera::Log.dump('ats_info',ats_info)
-      super({
-        base_url: ats_info['ATSEndpoint'],
-        auth:     {
-          type:     :basic,
-          username: ats_info['AccessKey']['Id'],
-          password: ats_info['AccessKey']['Secret']}})
-      # prepare transfer spec addition
-      @add_ts = {'tags' => {'aspera' => {'node' => {'storage_credentials' => {
+      Aspera::Log.dump('ats_info', ats_info)
+      @storage_credentials = {
         'type'  => 'token',
         'token' => {TOKEN_FIELD => nil}
-      }}}}}
+      }
+      super(
+        params: {
+          base_url: ats_info['ATSEndpoint'],
+          auth:     {
+            type:     :basic,
+            username: ats_info['AccessKey']['Id'],
+            password: ats_info['AccessKey']['Secret']}},
+        add_tspec: {'tags'=>{'aspera'=>{'node'=>{'storage_credentials'=>@storage_credentials}}}})
+      # update storage_credentials AND Rest params
       generate_token
     end
 
@@ -72,19 +74,19 @@ 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,
           receiver_client_ids: 'aspera_ats'
         }})
       # get delegated token to be placed in rest call header and in transfer tags
-      @add_ts['tags']['aspera']['node']['storage_credentials']['token'][TOKEN_FIELD] = delegated_oauth.get_authorization.gsub(/^Bearer /,'')
-      @params[:headers] = {'X-Aspera-Storage-Credentials' => JSON.generate(@add_ts['tags']['aspera']['node']['storage_credentials'])}
+      @storage_credentials['token'][TOKEN_FIELD] = delegated_oauth.get_authorization.gsub(/^Bearer /, '')
+      @params[:headers] = {'X-Aspera-Storage-Credentials' => JSON.generate(@storage_credentials)}
     end
   end
 end

data/lib/aspera/data_repository.rb

@@ -9,7 +9,7 @@ module Aspera
     include Singleton
     # get binary value from data repository
     def data(id)
-      File.read(File.join(__dir__,'data',id.to_s),mode: 'rb')
+      File.read(File.join(__dir__, 'data', id.to_s), mode: 'rb')
     end
   end
 end