aspera-cli 4.7.0 → 4.8.0

data/lib/aspera/cli/transfer_agent.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'aspera/fasp/transfer_spec'
 require 'aspera/cli/listener/logger'
 require 'aspera/cli/listener/progress_multi'
@@ -10,10 +11,10 @@ module Aspera
     # provides CLI options to select one of the transfer agents (FASP/ascp client)
     class TransferAgent
       # special value for --sources : read file list from arguments
-      FILE_LIST_FROM_ARGS='@args'
+      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
+      FILE_LIST_FROM_TRANSFER_SPEC = '@ts'
+      DEFAULT_TRANSFER_NOTIF_TMPL = <<~END_OF_TEMPLATE
         From: <%=from_name%> <<%=from_email%>>
         To: <<%=to%>>
         Subject: <%=subject%>
@@ -24,28 +25,28 @@ module Aspera
       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]
+      TRANSFER_AGENTS = %i[direct node connect httpgw trsdk].freeze
 
       # @param env external objects: option manager, config file manager
       def initialize(opt_mgr,config)
-        @opt_mgr=opt_mgr
-        @config=config
+        @opt_mgr = opt_mgr
+        @config = config
         # command line can override transfer spec
-        @transfer_spec_cmdline={'create_dir'=>true}
+        @transfer_spec_cmdline = {'create_dir' => true}
         # the currently selected transfer agent
-        @agent=nil
-        @progress_listener=Listener::ProgressMulti.new
+        @agent = nil
+        @progress_listener = Listener::ProgressMulti.new
         # source/destination pair, like "paths" of transfer spec
-        @transfer_paths=nil
+        @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,: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(: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 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(: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_list(:progress,[:none,:native,:multi],'type of progress bar')
+        @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
@@ -60,11 +61,11 @@ module Aspera
       def option_transfer_spec_deep_merge(ts); @transfer_spec_cmdline.deep_merge!(ts); end
 
       def agent_instance=(instance)
-        @agent=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 @opt_mgr.get_option(:progress,:mandatory).eql?(:multi) ||
-        (@opt_mgr.get_option(:progress,: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
@@ -72,25 +73,27 @@ 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,: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,: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)
+        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)
         # 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)
+          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?
+          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
+        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
-        agent_options=agent_options.symbolize_keys if agent_options.is_a?(Hash)
+        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
+        new_agent = Kernel.const_get("Aspera::Fasp::Agent#{agent_type.capitalize}").new(agent_options)
+        self.agent_instance = new_agent
         return nil
       end
 
@@ -98,14 +101,14 @@ module Aspera
       # sets default if needed
       # param: 'send' or 'receive'
       def destination_folder(direction)
-        dest_folder=@opt_mgr.get_option(:to_folder,:optional)
+        dest_folder = @opt_mgr.get_option(:to_folder)
         return File.expand_path(dest_folder) unless dest_folder.nil?
-        dest_folder=@transfer_spec_cmdline['destination_root']
+        dest_folder = @transfer_spec_cmdline['destination_root']
         return dest_folder unless dest_folder.nil?
         # default: / on remote, . on local
         case direction.to_s
-        when Fasp::TransferSpec::DIRECTION_SEND then dest_folder='/'
-        when Fasp::TransferSpec::DIRECTION_RECEIVE then 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
@@ -119,18 +122,19 @@ 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.has_key?('paths')
         # is there a source list option ?
-        file_list=@opt_mgr.get_option(:sources,:optional)
+        file_list = @opt_mgr.get_option(:sources)
         case file_list
         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',: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?
+          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,:mandatory).eql?(:direct) and Fasp::Parameters.ts_has_file_list(@transfer_spec_cmdline)
+          (special_case_direct_with_list = @opt_mgr.get_option(:transfer,is_type: :mandatory).eql?(:direct)) && 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
@@ -144,13 +148,13 @@ module Aspera
         if !@transfer_paths.nil?
           Log.log.warn('--sources overrides paths from --ts')
         end
-        case @opt_mgr.get_option(:src_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}}
+          @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}}
+          @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}")
@@ -170,12 +174,12 @@ module Aspera
         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'])
+          @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'])
+            @transfer_spec_cmdline['destination_root'] ||= destination_folder(transfer_spec['direction'])
           when :node_gen3
             # in that case, destination is set in return by application (API/upload_setup)
             # but to_folder was used in initial API call
@@ -191,7 +195,7 @@ module Aspera
         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_cmdline['paths'] = transfer_spec['paths'] || ts_source_paths
 
         transfer_spec.merge!(@transfer_spec_cmdline)
         # create transfer agent
@@ -199,7 +203,7 @@ module Aspera
         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
+        result = @agent.wait_for_transfers_completion
         @progress_listener.reset
         Fasp::AgentBase.validate_status_list(result)
         send_email_transfer_notification(transfer_spec,result)
@@ -207,13 +211,13 @@ module Aspera
       end
 
       def send_email_transfer_notification(transfer_spec,statuses)
-        return if @opt_mgr.get_option(:notif_to,:optional).nil?
-        global_status=self.class.session_status(statuses)
-        email_vars={
+        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}",
-          body: "Transfer is: #{global_status}",
-          ts: transfer_spec
+          subject:                "ascli transfer: #{global_status}",
+          body:                   "Transfer is: #{global_status}",
+          ts:                     transfer_spec
         }
         @config.send_email_template(email_vars,DEFAULT_TRANSFER_NOTIF_TMPL)
       end
@@ -221,7 +225,7 @@ module Aspera
       # @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.reject{|i|i.eql?(:success)}
+        error_statuses = statuses.reject{|i|i.eql?(:success)}
         return :success if error_statuses.empty?
         return error_statuses.first
       end

data/lib/aspera/cli/version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 module Aspera
   module Cli
-    VERSION = '4.7.0'
+    VERSION = '4.8.0'
   end
 end

data/lib/aspera/colors.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+
 # simple vt100 colors
 class String
-  class<<self
+  class << self
     private
 
     def vtcmd(code);"\e[#{code}m";end
@@ -10,39 +11,39 @@ class String
   # 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,
+    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
-  }
+    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
+  }.freeze
   private_constant :VTSTYLES
   # defines methods to String, one per entry in VTSTYLES
   VTSTYLES.each do |name,code|
     if $stderr.tty?
-      begin_seq=vtcmd(code)
-      end_code=
-      if code >= 10 then 0
-      elsif code.eql?(1) then 22
-      else code+20
+      begin_seq = vtcmd(code)
+      end_code = 0 # by default reset all
+      if code <= 7 then 20 + code
+      elsif code <= 37 then 39
+      elsif code <= 47 then 49
       end
-      end_seq=vtcmd(end_code)
+      end_seq = vtcmd(end_code)
       define_method(name){"#{begin_seq}#{self}#{end_seq}"}
     else
       define_method(name){self}

data/lib/aspera/command_line_builder.rb

@@ -1,38 +1,44 @@
 # 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 true/false
-    def self.yes_to_true(value)
-      case value
-      when 'yes' then return true
-      when 'no' then return false
+    # 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
+      # transform yes/no to true/false
+      def yes_to_true(value)
+        case value
+        when 'yes' then return true
+        when 'no' then return false
+        end
+        raise "unsupported value: #{value}"
       end
-      raise "unsupported value: #{value}"
-    end
 
-    # Called by provider of definition before constructor of this class so that params_definition has all mandatory fields
-    def self.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
-        options[:mandatory]||=false
-        options[:desc]||=''
-        # 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
-        # single type is placed in array
-        options[:accepted_types]=[options[:accepted_types]] unless options[:accepted_types].is_a?(Array)
-        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('_','-')
+      # 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
+          options[:mandatory] ||= false
+          options[:desc] ||= ''
+          # 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
+          # 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('_','-')
+          end
         end
       end
-    end
+  end
 
     private
 
@@ -47,11 +53,11 @@ 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`
-      @params_definition=params_definition
-      @result_env={}
-      @result_args=[]
-      @used_param_names=[]
+      @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 = []
+      @used_param_names = []
     end
 
     def warn_unrecognized_params
@@ -86,21 +92,21 @@ module Aspera
     # @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]
+      options = @params_definition[param_name]
       # should not happen
       if options.nil?
         Log.log.warn("Unknown parameter #{param_name}")
         return
       end
-      action=options[:cltype] if action.nil?
+      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)
-      parameter_value=@param_hash[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|
+      expected_classes = options[:accepted_types].map do |s|
         case s
         when :string then String
         when :array then Array
@@ -110,7 +116,8 @@ module Aspera
         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]}, " unless parameter_value.nil? || 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
@@ -123,15 +130,15 @@ module Aspera
       case options[:clconvert]
       when Hash
         # translate using conversion table
-        new_value=options[:clconvert][parameter_value]
+        new_value = options[:clconvert][parameter_value]
         raise "unsupported value: #{parameter_value}, expect: #{options[:clconvert].keys.join(', ')}" if new_value.nil?
-        parameter_value=new_value
+        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
+        parameter_value = newvalue
       when NilClass
       else raise "not expected type for clconvert #{options[:clconvert].class} for #{param_name}"
       end
@@ -145,17 +152,17 @@ module Aspera
         # define ascp parameter in env var from transfer spec
         @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
+        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
+        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_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)
+        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

data/lib/aspera/cos_node.rb

@@ -1,64 +1,90 @@
 # frozen_string_literal: true
+
 require 'aspera/log'
 require 'aspera/rest'
 require 'xmlsimple'
 
 module Aspera
   class CosNode < Rest
+    class << self
+      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)
+        end
+        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)
+        raise "no such region: #{bucket_region}" if storage_endpoint.nil?
+        return {
+          instance_id:      service_credentials['resource_instance_id'],
+          service_api_key:  service_credentials['apikey'],
+          storage_endpoint: "https://#{storage_endpoint}"
+        }
+      end
+    end
+    IBM_CLOUD_TOKEN_URL = 'https://iam.cloud.ibm.com/identity'
+    TOKEN_FIELD = 'delegated_refresh_token'
     attr_reader :add_ts
-    IBM_CLOUD_TOKEN_URL='https://iam.cloud.ibm.com/identity'
-    TOKEN_FIELD='delegated_refresh_token'
     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({
-        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
-      }}})
+      @auth_url = auth_url
+      @api_key = api_key
+      s3_api = Aspera::Rest.new({
+        base_url:       storage_endpoint,
+        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:  {
+            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
-      ats_info=XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
+      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'=>{
+      @add_ts = {'tags' => {'aspera' => {'node' => {'storage_credentials' => {
         'type'  => 'token',
-        'token' => {TOKEN_FIELD=>nil}
-        }}}}}
+        'token' => {TOKEN_FIELD => nil}
+      }}}}}
       generate_token
     end
 
     # potentially call this if delegated token is expired
     def generate_token
       # OAuth API to get delegated token
-      delegated_oauth=Oauth.new({
+      delegated_oauth = Oauth.new({
         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'])}
+        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 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'])}
     end
   end
 end

data/lib/aspera/data_repository.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'aspera/log'
 require 'singleton'