aspera-cli 4.4.0 → 4.7.0

data/lib/aspera/cli/transfer_agent.rb

@@ -1,8 +1,5 @@
-require 'aspera/fasp/local'
-require 'aspera/fasp/parameters'
-require 'aspera/fasp/connect'
-require 'aspera/fasp/node'
-require 'aspera/fasp/http_gw'
+# frozen_string_literal: true
+require 'aspera/fasp/transfer_spec'
 require 'aspera/cli/listener/logger'
 require 'aspera/cli/listener/progress_multi'
 
@@ -16,21 +13,23 @@ module Aspera
       FILE_LIST_FROM_ARGS='@args'
       # special value for --sources : read file list from transfer spec (--ts)
       FILE_LIST_FROM_TRANSFER_SPEC='@ts'
-      DEFAULT_TRANSFER_NOTIF_TMPL=<<END_OF_TEMPLATE
-From: <%=from_name%> <<%=from_email%>>
-To: <<%=to%>>
-Subject: <%=subject%>
+      DEFAULT_TRANSFER_NOTIF_TMPL=<<~END_OF_TEMPLATE
+        From: <%=from_name%> <<%=from_email%>>
+        To: <<%=to%>>
+        Subject: <%=subject%>
 
-Transfer is: <%=global_transfer_status%>
+        Transfer is: <%=global_transfer_status%>
 
-<%=ts.to_yaml%>
-END_OF_TEMPLATE
-      #%
+        <%=ts.to_yaml%>
+      END_OF_TEMPLATE
+      #% (formating bug in eclipse)
       private_constant :FILE_LIST_FROM_ARGS,:FILE_LIST_FROM_TRANSFER_SPEC,:DEFAULT_TRANSFER_NOTIF_TMPL
+      TRANSFER_AGENTS=[:direct,:node,:connect,:httpgw,:trsdk]
+
       # @param env external objects: option manager, config file manager
-      def initialize(env)
-        # same as plugin environment
-        @env=env
+      def initialize(opt_mgr,config)
+        @opt_mgr=opt_mgr
+        @config=config
         # command line can override transfer spec
         @transfer_spec_cmdline={'create_dir'=>true}
         # the currently selected transfer agent
@@ -38,25 +37,21 @@ END_OF_TEMPLATE
         @progress_listener=Listener::ProgressMulti.new
         # source/destination pair, like "paths" of transfer spec
         @transfer_paths=nil
-        options.set_obj_attr(:ts,self,:option_transfer_spec)
-        options.add_opt_simple(:ts,"override transfer spec values (Hash, use @json: prefix), current=#{options.get_option(:ts,:optional)}")
-        options.add_opt_simple(:local_resume,"set resume policy (Hash, use @json: prefix), current=#{options.get_option(:local_resume,:optional)}")
-        options.add_opt_simple(:to_folder,"destination folder for downloaded files")
-        options.add_opt_simple(:sources,"list of source files (see doc)")
-        options.add_opt_simple(:transfer_info,"parameters for transfer agent")
-        options.add_opt_list(:src_type,[:list,:pair],"type of file list")
-        options.add_opt_list(:transfer,[:direct,:httpgw,:connect,:node],"type of transfer agent")
-        options.add_opt_list(:progress,[:none,:native,:multi],"type of progress bar")
-        options.set_option(:transfer,:direct)
-        options.set_option(:src_type,:list)
-        options.set_option(:progress,:native) # use native ascp progress bar as it is more reliable
-        options.parse_options!
+        @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,:optional)}")
+        @opt_mgr.add_opt_simple(:local_resume,"set resume policy (Hash, use @json: prefix), current=#{@opt_mgr.get_option(:local_resume,:optional)}")
+        @opt_mgr.add_opt_simple(:to_folder,'destination folder for downloaded files')
+        @opt_mgr.add_opt_simple(:sources,'list of source files (see doc)')
+        @opt_mgr.add_opt_simple(:transfer_info,'parameters for transfer agent')
+        @opt_mgr.add_opt_list(:src_type,[:list,:pair],'type of file list')
+        @opt_mgr.add_opt_list(:transfer,TRANSFER_AGENTS,'type of transfer agent')
+        @opt_mgr.add_opt_list(:progress,[: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
 
-      def options; @env[:options];end
-
-      def config; @env[:config];end
-
       def option_transfer_spec; @transfer_spec_cmdline; end
 
       # multiple option are merged
@@ -64,12 +59,12 @@ END_OF_TEMPLATE
 
       def option_transfer_spec_deep_merge(ts); @transfer_spec_cmdline.deep_merge!(ts); end
 
-      def set_agent_instance(instance)
+      def agent_instance=(instance)
         @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 options.get_option(:progress,:mandatory).eql?(:multi) or
-        (options.get_option(:progress,:mandatory).eql?(:native) and !options.get_option(:transfer,:mandatory).eql?(:direct))
+        if @opt_mgr.get_option(:progress,:mandatory).eql?(:multi) ||
+        (@opt_mgr.get_option(:progress,:mandatory).eql?(:native) && !instance.class.to_s.eql?('Aspera::Fasp::AgentDirect'))
           @agent.add_listener(@progress_listener)
         end
       end
@@ -77,57 +72,25 @@ END_OF_TEMPLATE
       # analyze options and create new agent if not already created or set
       def set_agent_by_options
         return nil unless @agent.nil?
-        agent_type=options.get_option(:transfer,:mandatory)
-        case agent_type
-        when :direct
-          agent_options=options.get_option(:transfer_info,:optional)
-          agent_options=agent_options.symbolize_keys if agent_options.is_a?(Hash)
-          new_agent=Fasp::Local.new(agent_options)
-          new_agent.quiet=false if options.get_option(:progress,:mandatory).eql?(:native)
-        when :httpgw
-          httpgw_config=options.get_option(:transfer_info,:mandatory)
-          new_agent=Fasp::HttpGW.new(httpgw_config)
-        when :connect
-          new_agent=Fasp::Connect.new
-        when :node
-          # way for code to setup alternate node api in advance
-          # support: @preset:<name>
-          # support extended values
-          node_config=options.get_option(:transfer_info,:optional)
-          # if not specified: use default node
-          if node_config.nil?
-            param_set_name=config.get_plugin_default_config_name(:node)
-            raise CliBadArgument,"No default node configured, Please specify --#{:transfer_info.to_s.gsub('_','-')}" if param_set_name.nil?
-            node_config=config.preset_by_name(param_set_name)
-          end
-          Log.log.debug("node=#{node_config}")
-          raise CliBadArgument,"the node configuration shall be Hash, not #{node_config.class} (#{node_config}), use either @json:<json> or @preset:<parameter set name>" unless node_config.is_a?(Hash)
-          # here, node_config is a Hash
-          node_config=node_config.symbolize_keys
-          # Check mandatory params
-          [:url,:username,:password].each { |k| raise CliBadArgument,"missing parameter [#{k}] in node specification: #{node_config}" unless node_config.has_key?(k) }
-          if node_config[:password].match(/^Bearer /)
-            node_api=Rest.new({
-              base_url: node_config[:url],
-              headers: {
-              'X-Aspera-AccessKey'=>node_config[:username],
-              'Authorization'     =>node_config[:password]}})
-          else
-            node_api=Rest.new({
-              base_url: node_config[:url],
-              auth:     {
-              type:     :basic,
-              username: node_config[:username],
-              password: node_config[:password]
-              }})
-          end
-          new_agent=Fasp::Node.new(node_api)
-          # add root id if it's an access key
-          new_agent.options={root_id: node_config[:root_id]} if node_config.has_key?(:root_id)
-        else
-          raise "Unexpected transfer agent type: #{agent_type}"
+        agent_type=@opt_mgr.get_option(:transfer,:mandatory)
+        require "aspera/fasp/agent_#{agent_type}"
+        agent_options=@opt_mgr.get_option(:transfer_info,:optional)
+        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.gsub('_','-')}" 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,:mandatory).eql?(:native)
+          agent_options={} if agent_options.nil?
+          agent_options[:quiet]=false
         end
-        set_agent_instance(new_agent)
+        agent_options=agent_options.symbolize_keys if agent_options.is_a?(Hash)
+        # get agent instance
+        new_agent=Kernel.const_get("Aspera::Fasp::Agent#{agent_type.capitalize}").new(agent_options)
+        self.agent_instance=new_agent
         return nil
       end
 
@@ -135,14 +98,14 @@ END_OF_TEMPLATE
       # sets default if needed
       # param: 'send' or 'receive'
       def destination_folder(direction)
-        dest_folder=options.get_option(:to_folder,:optional)
-        return dest_folder unless dest_folder.nil?
+        dest_folder=@opt_mgr.get_option(:to_folder,:optional)
+        return File.expand_path(dest_folder) unless dest_folder.nil?
         dest_folder=@transfer_spec_cmdline['destination_root']
         return dest_folder unless dest_folder.nil?
         # default: / on remote, . on local
         case direction.to_s
-        when 'send';dest_folder='/'
-        when 'receive';dest_folder='.'
+        when Fasp::TransferSpec::DIRECTION_SEND then dest_folder='/'
+        when Fasp::TransferSpec::DIRECTION_RECEIVE then dest_folder='.'
         else raise "wrong direction: #{direction}"
         end
         return dest_folder
@@ -150,7 +113,7 @@ END_OF_TEMPLATE
 
       # This is how the list of files to be transfered is specified
       # get paths suitable for transfer spec from command line
-      # @return {:source=>(mandatory), :destination=>(optional)}
+      # @return {source: (mandatory), destination: (optional)}
       # computation is done only once, cache is kept in @transfer_paths
       def ts_source_paths
         # return cache if set
@@ -158,37 +121,37 @@ END_OF_TEMPLATE
         # 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')
         # is there a source list option ?
-        file_list=options.get_option(:sources,:optional)
+        file_list=@opt_mgr.get_option(:sources,:optional)
         case file_list
         when nil,FILE_LIST_FROM_ARGS
-          Log.log.debug("getting file list as parameters")
+          Log.log.debug('getting file list as parameters')
           # get remaining arguments
-          file_list=options.get_next_argument("source file list",: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) or file_list.empty?
+          file_list=@opt_mgr.get_next_argument('source file list',: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=options.get_option(:transfer,:mandatory).eql?(:direct) and Fasp::Parameters.ts_has_file_list(@transfer_spec_cmdline)
-          raise CliBadArgument,"transfer spec on command line must have sources" if @transfer_paths.nil? and !special_case_direct_with_list
+          Log.log.debug('assume list provided in transfer spec')
+          special_case_direct_with_list=@opt_mgr.get_option(:transfer,:mandatory).eql?(:direct) and Fasp::Parameters.ts_has_file_list(@transfer_spec_cmdline)
+          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.select{|f|!f.is_a?(String)}.empty?
+          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?
         else
           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")
+          Log.log.warn('--sources overrides paths from --ts')
         end
-        case options.get_option(:src_type,:mandatory)
+        case @opt_mgr.get_option(:src_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}}
-        else raise "Unsupported src_type"
+        else raise 'Unsupported src_type'
         end
         Log.log.debug("paths=#{@transfer_paths}")
         return @transfer_paths
@@ -201,14 +164,14 @@ END_OF_TEMPLATE
       # other options are carried to specific agent
       def start(transfer_spec,tr_opts)
         # 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)
+        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 'receive'
+        when Fasp::TransferSpec::DIRECTION_RECEIVE
           # init default if required in any case
           @transfer_spec_cmdline['destination_root']||=destination_folder(transfer_spec['direction'])
-        when 'send'
+        when Fasp::TransferSpec::DIRECTION_SEND
           case tr_opts[:src]
           when :direct
             # init default if required
@@ -232,18 +195,19 @@ END_OF_TEMPLATE
 
         transfer_spec.merge!(@transfer_spec_cmdline)
         # create transfer agent
-        self.set_agent_by_options
+        set_agent_by_options
         Log.log.debug("transfer agent is a #{@agent.class}")
         @agent.start_transfer(transfer_spec,tr_opts)
+        # list of : :success or error message
         result=@agent.wait_for_transfers_completion
         @progress_listener.reset
-        Fasp::Manager.validate_status_list(result)
+        Fasp::AgentBase.validate_status_list(result)
         send_email_transfer_notification(transfer_spec,result)
         return result
       end
 
       def send_email_transfer_notification(transfer_spec,statuses)
-        return if options.get_option(:notif_to,:optional).nil?
+        return if @opt_mgr.get_option(:notif_to,:optional).nil?
         global_status=self.class.session_status(statuses)
         email_vars={
           global_transfer_status: global_status,
@@ -251,13 +215,13 @@ END_OF_TEMPLATE
           body: "Transfer is: #{global_status}",
           ts: transfer_spec
         }
-        @env[:config].send_email_template(email_vars,DEFAULT_TRANSFER_NOTIF_TMPL)
+        @config.send_email_template(email_vars,DEFAULT_TRANSFER_NOTIF_TMPL)
       end
 
       # @return :success if all sessions statuses returned by "start" are success
       # else return the first error exception object
       def self.session_status(statuses)
-        error_statuses=statuses.select{|i|!i.eql?(:success)}
+        error_statuses=statuses.reject{|i|i.eql?(:success)}
         return :success if error_statuses.empty?
         return error_statuses.first
       end
@@ -266,7 +230,6 @@ END_OF_TEMPLATE
       def shutdown
         @agent.shutdown if @agent.respond_to?(:shutdown)
       end
-
     end
   end
 end

data/lib/aspera/cli/version.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module Aspera
   module Cli
-    VERSION = "4.4.0"
+    VERSION = '4.7.0'
   end
 end

data/lib/aspera/colors.rb

@@ -1,43 +1,51 @@
+# frozen_string_literal: true
 # simple vt100 colors
 class String
-  private
-  def self.vtcmd(code);"\e[#{code}m";end
+  class<<self
+    private
+
+    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
   # it adds control chars to set color (and reset at the end).
   VTSTYLES = {
-    :bold=>1,
-    :italic=>3,
-    :underline=>4,
-    :blink=>5,
-    :reverse_color=>7,
-    :black=>30,
-    :red=>31,
-    :green=>32,
-    :brown=>33,
-    :blue=>34,
-    :magenta=>35,
-    :cyan=>36,
-    :gray=>37,
-    :bg_black=>40,
-    :bg_red=>41,
-    :bg_green=>42,
-    :bg_brown=>43,
-    :bg_blue=>44,
-    :bg_magenta=>45,
-    :bg_cyan=>46,
-    :bg_gray=>47,
+    bold: 1,
+    italic: 3,
+    underline: 4,
+    blink: 5,
+    reverse_color: 7,
+    black: 30,
+    red: 31,
+    green: 32,
+    brown: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    gray: 37,
+    bg_black: 40,
+    bg_red: 41,
+    bg_green: 42,
+    bg_brown: 43,
+    bg_blue: 44,
+    bg_magenta: 45,
+    bg_cyan: 46,
+    bg_gray: 47
   }
   private_constant :VTSTYLES
   # defines methods to String, one per entry in VTSTYLES
   VTSTYLES.each do |name,code|
-    begin_seq=vtcmd(code)
-    end_seq=vtcmd((code >= 10) ? 0 : code+20+(code.eql?(1)?1:0))
-    if STDERR.tty?
+    if $stderr.tty?
+      begin_seq=vtcmd(code)
+      end_code=
+      if code >= 10 then 0
+      elsif code.eql?(1) then 22
+      else code+20
+      end
+      end_seq=vtcmd(end_code)
       define_method(name){"#{begin_seq}#{self}#{end_seq}"}
     else
       define_method(name){self}
     end
-    public name
   end
 end

data/lib/aspera/command_line_builder.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 module Aspera
   # helper class to build command line from a parameter list (key-value hash)
   # constructor takes hash: { 'param1':'value1', ...}
   # 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
-    # transform yes/no to trye/false
+    # transform yes/no to true/false
     def self.yes_to_true(value)
       case value
-      when 'yes'; return true
-      when 'no'; return false
+      when 'yes' then return true
+      when 'no' then return false
       end
       raise "unsupported value: #{value}"
     end
@@ -22,13 +23,13 @@ module Aspera
         options[:mandatory]||=false
         options[:desc]||=''
         # by default : string, unless it's without arg
-        if ! options.has_key?(:accepted_types)
+        if !options.has_key?(:accepted_types)
           options[:accepted_types]=options[:cltype].eql?(:opt_without_arg) ? :bool : :string
         end
         # single type is placed in array
         options[:accepted_types]=[options[:accepted_types]] unless options[:accepted_types].is_a?(Array)
-        if !options.has_key?(:option_switch) and options.has_key?(:cltype) and [:opt_without_arg,:opt_with_arg].include?(options[:cltype])
-          options[:option_switch]='--'+param_name.to_s.gsub('_','-')
+        if !options.has_key?(:clswitch) && options.has_key?(:cltype) && [:opt_without_arg,:opt_with_arg].include?(options[:cltype])
+          options[:clswitch]='--'+param_name.to_s.gsub('_','-')
         end
       end
     end
@@ -36,7 +37,7 @@ module Aspera
     private
 
     # clvarname : command line variable name
-    def env_name(param_name,options)
+    def env_name(_param_name,options)
       return options[:clvarname]
     end
 
@@ -46,7 +47,7 @@ module Aspera
 
     # @param param_hash
     def initialize(param_hash,params_definition)
-      @param_hash=param_hash  # keep reference so that it can be modified by caller before calling `process_params`
+      @param_hash=param_hash # keep reference so that it can be modified by caller before calling `process_params`
       @params_definition=params_definition
       @result_env={}
       @result_args=[]
@@ -86,42 +87,53 @@ module Aspera
     # @param options : options for type
     def process_param(param_name,action=nil)
       options=@params_definition[param_name]
-      action=options[:cltype] if action.nil?
       # should not happen
-      raise "Internal error: ask processing of param #{param_name}" if options.nil?
+      if options.nil?
+        Log.log.warn("Unknown parameter #{param_name}")
+        return
+      end
+      action=options[:cltype] if action.nil?
       # check mandatory parameter (nil is valid value)
-      raise Fasp::Error.new("mandatory parameter: #{param_name}") if options[:mandatory] and !@param_hash.has_key?(param_name)
+      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)
+
+      # Check parameter type
       expected_classes=options[:accepted_types].map do |s|
         case s
-        when :string; String
-        when :array; Array
-        when :hash; Hash
-        when :int; Integer
-        when :bool; [TrueClass,FalseClass]
+        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}"
         end
       end.flatten
-      # check provided type
-      raise Fasp::Error.new("#{param_name} is : #{parameter_value.class} (#{parameter_value}), shall be #{options[:accepted_types]}, ") unless parameter_value.nil? or expected_classes.include?(parameter_value.class)
+      raise Fasp::Error,"#{param_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)
 
       # process only non-nil values
       return nil if parameter_value.nil?
 
-      if options.has_key?(:translate_values)
+      # 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)
+
+      # convert some values if value on command line needs processing from value in structure
+      case options[:clconvert]
+      when Hash
         # translate using conversion table
-        new_value=options[:translate_values][parameter_value]
-        raise "unsupported value: #{parameter_value}" if new_value.nil?
+        new_value=options[:clconvert][parameter_value]
+        raise "unsupported value: #{parameter_value}, expect: #{options[:clconvert].keys.join(', ')}" if new_value.nil?
         parameter_value=new_value
-      end
-      raise "unsupported value: #{parameter_value}" unless options[:accepted_values].nil? or options[:accepted_values].include?(parameter_value)
-      if options[:encode]
-        # :encode has name of class with encoding method
-        newvalue=Kernel.const_get(options[:encode]).send("encode_#{param_name}",parameter_value)
-        raise Fasp::Error.new("unsupported #{param_name}: #{parameter_value}") if newvalue.nil?
+      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
+      when NilClass
+      else raise "not expected type for clconvert #{options[:clconvert].class} for #{param_name}"
       end
 
       case action
@@ -135,19 +147,21 @@ module Aspera
       when :opt_without_arg # if present and true : just add option without value
         add_param=false
         case parameter_value
-        when false# nothing to put on command line, no creation by default
-        when true; add_param=true
-        else raise Fasp::Error.new("unsupported #{param_name}: #{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}"
         end
-        add_param=!add_param if options[:add_on_false]
-        add_command_line_options([options[:option_switch]]) if add_param
+        add_param= !add_param if options[:add_on_false]
+        add_command_line_options([options[:clswitch]]) 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[:option_switch],v])}
+        parameter_value.each{|v|add_command_line_options([options[:clswitch],v])}
+      when NilClass
+        Log.log.debug("Ignoring parameter: #{param_name}")
       else
-        raise "Error"
+        raise "ERROR: unknown action: #{action}/#{action.class}"
       end
     end
   end

data/lib/aspera/cos_node.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/log'
 require 'aspera/rest'
 require 'xmlsimple'
@@ -11,25 +12,28 @@ module Aspera
       @auth_url=auth_url
       @api_key=api_key
       s3_api=Aspera::Rest.new({
-        :base_url       => storage_endpoint,
-        :not_auth_codes => ['401','403'], # error codes when not authorized
-        :headers        => {'ibm-service-instance-id' => instance_id},
-        :auth           => {
-        :type      => :oauth2,
-        :base_url  => @auth_url,
-        :grant     => :ibm_apikey,
-        :api_key   => @api_key
-        }})
+        base_url:        storage_endpoint,
+        not_auth_codes:  ['401','403'], # error codes when not authorized
+        headers:         {'ibm-service-instance-id' => instance_id},
+        auth:            {
+        type:              :oauth2,
+        base_url:          @auth_url,
+        crtype:            :generic,
+        generic:            {
+        grant_type:          'urn:ibm:params:oauth:grant-type:apikey',
+        response_type:       'cloud_iam',
+        apikey:              @api_key
+      }}})
       # read FASP connection information for bucket
-      xml_result_text=s3_api.call({:operation=>'GET',:subpath=>bucket_name,:headers=>{'Accept'=>'application/xml'},:url_params=>{'faspConnectionInfo'=>nil}})[:http].body
+      xml_result_text=s3_api.call({operation: 'GET',subpath: bucket_name,headers: {'Accept'=>'application/xml'},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']}})
+        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'=>{
         'type'  => 'token',
@@ -42,12 +46,16 @@ module Aspera
     def generate_token
       # OAuth API to get delegated token
       delegated_oauth=Oauth.new({
-        :type       => :oauth2,
-        :base_url   => @auth_url,
-        :grant      => :delegated_refresh,
-        :api_key    => @api_key,
-        :token_field=> TOKEN_FIELD
-      })
+        type:        :oauth2,
+        base_url:    @auth_url,
+        token_field: TOKEN_FIELD,
+        crtype:            :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 delagated 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'])}

data/lib/aspera/data_repository.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/log'
 require 'singleton'
 
@@ -6,8 +7,8 @@ module Aspera
   class DataRepository
     include Singleton
     # get binary value from data repository
-    def get_bin(id)
-      File.read(File.join(File.expand_path(File.dirname(__FILE__)),'data',id.to_s),mode: 'rb')
+    def data(id)
+      File.read(File.join(__dir__,'data',id.to_s),mode: 'rb')
     end
   end
 end