aspera-cli 4.9.0 → 4.11.0

data/lib/aspera/cli/transfer_agent.rb

@@ -3,6 +3,7 @@
 require 'aspera/fasp/transfer_spec'
 require 'aspera/cli/listener/logger'
 require 'aspera/cli/listener/progress_multi'
+require 'aspera/cli/info'
 
 module Aspera
   module Cli
@@ -14,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%>>
@@ -24,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,
+      # % (formating 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
 
@@ -39,8 +42,10 @@ module Aspera
         end
       end
 
+      attr_accessor :token_regenerator
+
       # @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
@@ -50,19 +55,22 @@ 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
+        # 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_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!
+        Fasp::TransferSpec.ascp_opts_to_ts(@transfer_spec_cmdline, @opt_mgr.get_option(:ascp_opts))
       end
 
       def option_transfer_spec; @transfer_spec_cmdline; end
@@ -76,8 +84,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
@@ -85,20 +93,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
@@ -135,106 +143,99 @@ module Aspera
         # 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) &&
+            @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
+          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)
+      def start(transfer_spec)
         # 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.token_regenerator = @token_regenerator if @agent.respond_to?(:token_regenerator=)
+        @agent.start_transfer(transfer_spec)
         # 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 = {
           global_transfer_status: global_status,
-          subject:                "ascli transfer: #{global_status}",
+          subject:                "#{PROGRAM_NAME} transfer: #{global_status}",
           body:                   "Transfer is: #{global_status}",
           ts:                     transfer_spec
         }
-        @config.send_email_template(email_vars,DEFAULT_TRANSFER_NOTIF_TMPL)
+        @config.send_email_template(email_template_default: DEFAULT_TRANSFER_NOTIF_TMPL, values: email_vars)
       end
 
       # shut down if agent requires it

data/lib/aspera/cli/version.rb

@@ -2,6 +2,6 @@
 
 module Aspera
   module Cli
-    VERSION = '4.9.0'
+    VERSION = '4.11.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

@@ -7,8 +7,8 @@ module Aspera
   # 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
+    CLTYPE_OPTIONS = %i[opt_without_arg opt_with_arg].freeze
+    class << self
       # transform yes/no to true/false
       def yes_to_true(value)
         case value
@@ -20,21 +20,21 @@ module Aspera
 
       # 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|
+        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)
+          # options[:accepted_types]=:bool if options[:cltype].eql?(:envvar) and !options.has_key?(:accepted_types)
           # by default : not mandatory
           options[:mandatory] ||= false
           options[:desc] ||= ''
           # by default : string, unless it's without arg
-          if !options.has_key?(:accepted_types)
+          if !options.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)
           # 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 !options.key?(:clswitch) && options.key?(:cltype) && CLTYPE_OPTIONS.include?(options[:cltype])
+            options[:clswitch] = '--' + param_name.to_s.tr('_', '-')
           end
         end
       end
@@ -43,7 +43,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
 
@@ -52,7 +52,7 @@ module Aspera
     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 = {}
@@ -62,13 +62,13 @@ module Aspera
 
     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)}
+      @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}")
+    def add_env_args(env, args)
+      Log.log.debug{"ENV=#{@result_env}, ARGS=#{@result_args}"}
       warn_unrecognized_params
       env.merge!(@result_env)
       args.push(*@result_args)
@@ -82,7 +82,7 @@ module Aspera
     end
 
     def process_params
-      @params_definition.keys.each do |k|
+      @params_definition.each_key do |k|
         process_param(k)
       end
     end
@@ -91,19 +91,19 @@ module Aspera
     # @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)
+    def process_param(param_name, action=nil)
       options = @params_definition[param_name]
       # should not happen
       if options.nil?
-        Log.log.warn("Unknown parameter #{param_name}")
+        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, "Missing mandatory parameter: #{param_name}" if options[:mandatory] && !@param_hash.has_key?(param_name)
+      raise Fasp::Error, "Missing mandatory parameter: #{param_name}" if options[:mandatory] && !@param_hash.key?(param_name)
       parameter_value = @param_hash[param_name]
 
-      #parameter_value=options[:default] if parameter_value.nil? and options.has_key?(:default)
+      # parameter_value=options[:default] if parameter_value.nil? and options.has_key?(:default)
 
       # Check parameter type
       expected_classes = options[:accepted_types].map do |s|
@@ -112,11 +112,11 @@ module Aspera
         when :array then Array
         when :hash then Hash
         when :int then Integer
-        when :bool then [TrueClass,FalseClass]
+        when :bool then [TrueClass, FalseClass]
         else raise "INTERNAL: unexpected value: #{s}"
         end
       end.flatten
-      raise Fasp::Error,"#{param_name} is : #{parameter_value.class} (#{parameter_value}), shall be #{options[:accepted_types]}, " \
+      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)
 
@@ -124,7 +124,7 @@ module Aspera
       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 "Value #{parameter_value} is not allowed for #{param_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]
@@ -135,8 +135,8 @@ module Aspera
         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)
+        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
@@ -144,13 +144,13 @@ module Aspera
       end
 
       case action
-      when :ignore,:defer # ignore this parameter or process later
+      when :ignore, :defer # ignore this parameter or process later
         return
       when :get_value # just get value
         return parameter_value
       when :envvar # set in env var
         # define ascp parameter in env var from transfer spec
-        @result_env[env_name(param_name,options)] = parameter_value
+        @result_env[env_name(param_name, options)] = parameter_value
       when :opt_without_arg # if present and true : just add option without value
         add_param = false
         case parameter_value
@@ -161,12 +161,12 @@ module Aspera
         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.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])}
+        parameter_value.each{|v|add_command_line_options([options[:clswitch], v])}
       when NilClass
-        Log.log.debug("Ignoring parameter: #{param_name}")
+        Log.log.debug{"Ignoring parameter: #{param_name}"}
       else
         raise "ERROR: unknown action: #{action}/#{action.class}"
       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({
@@ -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
 
@@ -83,8 +85,8 @@ module Aspera
           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

data/lib/aspera/environment.rb

@@ -10,12 +10,16 @@ module Aspera
     OS_X = :osx
     OS_LINUX = :linux
     OS_AIX = :aix
-    OS_LIST = [OS_WINDOWS,OS_X,OS_LINUX,OS_AIX].freeze
+    OS_LIST = [OS_WINDOWS, OS_X, OS_LINUX, OS_AIX].freeze
     CPU_X86_64 = :x86_64
     CPU_PPC64 = :ppc64
     CPU_PPC64LE = :ppc64le
     CPU_S390 = :s390
-    CPU_LIST = [CPU_X86_64,CPU_PPC64,CPU_PPC64LE,CPU_S390].freeze
+    CPU_LIST = [CPU_X86_64, CPU_PPC64, CPU_PPC64LE, CPU_S390].freeze
+
+    BITS_PER_BYTE = 8
+    MEBI = 1024 * 1024
+    BYTES_PER_MEBIBIT = MEBI / BITS_PER_BYTE
 
     class << self
       def ruby_version
@@ -24,9 +28,9 @@ module Aspera
 
       def os
         case RbConfig::CONFIG['host_os']
-        when /mswin/,/msys/,/mingw/,/cygwin/,/bccwin/,/wince/,/emc/
+        when /mswin/, /msys/, /mingw/, /cygwin/, /bccwin/, /wince/, /emc/
           return OS_WINDOWS
-        when /darwin/,/mac os/
+        when /darwin/, /mac os/
           return OS_X
         when /linux/
           return OS_LINUX
@@ -39,9 +43,9 @@ module Aspera
 
       def cpu
         case RbConfig::CONFIG['host_cpu']
-        when /x86_64/,/x64/
+        when /x86_64/, /x64/
           return CPU_X86_64
-        when /powerpc/,/ppc64/
+        when /powerpc/, /ppc64/
           return CPU_PPC64LE if os.eql?(OS_LINUX)
           return CPU_PPC64
         when /s390/
@@ -65,9 +69,9 @@ module Aspera
       # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably than %HOMEDRIVE%%HOMEPATH%
       # so, tell Ruby the right way
       def fix_home
-        return unless os.eql?(OS_WINDOWS) && ENV.has_key?('USERPROFILE') && Dir.exist?(ENV['USERPROFILE'])
+        return unless os.eql?(OS_WINDOWS) && ENV.key?('USERPROFILE') && Dir.exist?(ENV['USERPROFILE'])
         ENV['HOME'] = ENV['USERPROFILE']
-        Log.log.debug("Windows: set home to USERPROFILE: #{ENV['HOME']}")
+        Log.log.debug{"Windows: set home to USERPROFILE: #{ENV['HOME']}"}
       end
 
       def empty_binding
@@ -76,19 +80,35 @@ module Aspera
 
       # secure execution of Ruby code
       def secure_eval(code)
-        Kernel.send('lave'.reverse,code,empty_binding, __FILE__, __LINE__)
+        Kernel.send('lave'.reverse, code, empty_binding, __FILE__, __LINE__)
       end
 
       # value is provided in block
-      def write_file_restricted(path,force: false)
+      def write_file_restricted(path, force: false)
         raise 'coding error, missing content block' unless block_given?
         if force || !File.exist?(path)
           File.unlink(path) rescue nil # Windows may give error
-          File.write(path,yield)
-          File.chmod(0400,path)
+          File.write(path, yield)
+          restrict_file_access(path)
         end
         return path
       end
-    end
-  end
-end
+
+      def restrict_file_access(path, mode: nil)
+        if mode.nil?
+          # or FileUtils ?
+          if File.file?(path)
+            mode = 0o600
+          elsif File.directory?(path)
+            mode = 0o700
+          else
+            Log.log.debug{"No restriction can be set for #{path}"}
+          end
+        end
+        File.chmod(mode, path) unless mode.nil?
+      rescue => e
+        Log.log.warn(e.message)
+      end
+    end # self
+  end # Environment
+end # Aspera