aspera-cli 4.17.0 → 4.18.0

data/lib/aspera/agent/httpgw.rb

@@ -2,312 +2,13 @@
 
 require 'aspera/agent/base'
 require 'aspera/transfer/spec'
-require 'aspera/transfer/faux_file'
+require 'aspera/api/httpgw'
 require 'aspera/log'
 require 'aspera/assert'
-require 'aspera/rest'
-require 'securerandom'
-require 'websocket'
-require 'base64'
-require 'json'
 
 module Aspera
   module Agent
-    # Start a transfer using Aspera HTTP Gateway, using web socket secure for uploads
-    # ref: https://api.ibm.com/explorer/catalog/aspera/product/ibm-aspera/api/http-gateway-api/doc/guides-toc
-    # https://developer.ibm.com/apis/catalog?search=%22aspera%20http%22
-    # HTTP GW Upload protocol:
-    #   #     type                Contents            Ack                 Counter
-    # v1
-    #   0     JSON.transfer_spec  Transfer Spec       "end upload"        sent_general
-    #   1..   JSON.slice_upload   File base64 chunks  "end upload"        sent_general
-    # v2
-    #   0     JSON.transfer_spec  Transfer Spec       "end upload"        sent_general
-    #   1     JSON.slice_upload   File start          "end_slice_upload"  sent_v2_delimiter
-    #   2..   Binary              File binary chunks  "end upload"        sent_general
-    #   last  JSON.slice_upload   File end            "end_slice_upload"  sent_v2_delimiter
     class Httpgw < Base
-      MSG_SEND_TRANSFER_SPEC = 'transfer_spec'
-      MSG_SEND_SLICE_UPLOAD = 'slice_upload'
-      MSG_RECV_DATA_RECEIVED_SIGNAL = 'end upload'
-      MSG_RECV_SLICE_UPLOAD_SIGNAL = 'end_slice_upload'
-      # upload API versions
-      API_V1 = 'v1'
-      API_V2 = 'v2'
-      # options available in CLI (transfer_info)
-      DEFAULT_OPTIONS = {
-        url:               :required,
-        upload_chunk_size: 64_000,
-        api_version:       API_V2,
-        synchronous:       false
-      }.freeze
-      DEFAULT_BASE_PATH = '/aspera/http-gwy'
-      THR_RECV = 'recv'
-      LOG_WS_SEND = 'ws: send: '.red
-      LOG_WS_RECV = "ws: #{THR_RECV}: ".green
-      private_constant :DEFAULT_OPTIONS, :MSG_RECV_DATA_RECEIVED_SIGNAL, :MSG_RECV_SLICE_UPLOAD_SIGNAL, :API_V1, :API_V2
-
-      # send message on http gw web socket
-      def ws_snd_json(msg_type, payload)
-        if msg_type.eql?(MSG_SEND_SLICE_UPLOAD) && @options[:api_version].eql?(API_V2)
-          @shared_info[:count][:sent_v2_delimiter] += 1
-        else
-          @shared_info[:count][:sent_general] += 1
-        end
-        Log.log.debug do
-          log_data = payload.dup
-          log_data[:data] = "[data #{log_data[:data].length} bytes]" if log_data.key?(:data)
-          "#{LOG_WS_SEND}json: #{msg_type}: #{JSON.generate(log_data)}"
-        end
-        ws_send(ws_type: :text, data: JSON.generate({msg_type => payload}))
-      end
-
-      # send data on http gw web socket
-      def ws_send(ws_type:, data:)
-        Log.log.debug{"#{LOG_WS_SEND}sending: #{ws_type} (#{data&.length || 0} bytes)"}
-        @shared_info[:count][:sent_general] += 1 if ws_type.eql?(:binary)
-        frame_generator = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: ws_type, version: @ws_handshake.version)
-        @ws_io.write(frame_generator.to_s)
-        if @options[:synchronous]
-          @shared_info[:mutex].synchronize do
-            # if read thread exited, there will be no more updates
-            # we allow for 1 of difference else it stays blocked
-            while @ws_read_thread.alive? &&
-                @shared_info[:read_exception].nil? &&
-                (((@shared_info[:count][:sent_general] - @shared_info[:count][:received_general]) > 1) ||
-                  ((@shared_info[:count][:received_v2_delimiter] - @shared_info[:count][:sent_v2_delimiter]) > 1))
-              if !@shared_info[:cond_var].wait(@shared_info[:mutex], 2.0)
-                Log.log.debug{"#{LOG_WS_SEND}#{'timeout'.blue}: #{@shared_info[:count]}"}
-              end
-            end
-          end
-        end
-        raise @shared_info[:read_exception] unless @shared_info[:read_exception].nil?
-        Log.log.debug{"#{LOG_WS_SEND}counts: #{@shared_info[:count]}"}
-      end
-
-      # message processing for read thread
-      def process_received_message(message)
-        Log.log.debug{"#{LOG_WS_RECV}message: [#{message}] (#{message.class})"}
-        if message.eql?(MSG_RECV_DATA_RECEIVED_SIGNAL)
-          @shared_info[:mutex].synchronize do
-            @shared_info[:count][:received_general] += 1
-            @shared_info[:cond_var].signal
-          end
-        elsif message.eql?(MSG_RECV_SLICE_UPLOAD_SIGNAL)
-          @shared_info[:mutex].synchronize do
-            @shared_info[:count][:received_v2_delimiter] += 1
-            @shared_info[:cond_var].signal
-          end
-        else
-          message.chomp!
-          error_message =
-            if message.start_with?('"') && message.end_with?('"')
-              # remove double quotes : 1..-2
-              JSON.parse(Base64.strict_decode64(message.chomp[1..-2]))['message']
-            elsif message.start_with?('{') && message.end_with?('}')
-              JSON.parse(message)['message']
-            else
-              "unknown message from gateway: [#{message}]"
-            end
-          raise error_message
-        end
-      end
-
-      # main function of read thread
-      def process_read_thread
-        Log.log.debug{"#{LOG_WS_RECV}read thread started"}
-        frame_parser = ::WebSocket::Frame::Incoming::Client.new(version: @ws_handshake.version)
-        until @ws_io.eof?
-          begin # rubocop:disable Style/RedundantBegin
-            # ready byte by byte until frame is ready
-            # blocking read
-            byte = @ws_io.read(1)
-            Log.log.trace1{"#{LOG_WS_RECV}read: #{byte} (#{byte.class}) eof=#{@ws_io.eof?}"}
-            frame_parser << byte
-            frame_ok = frame_parser.next
-            next if frame_ok.nil?
-            process_received_message(frame_ok.data.to_s)
-            Log.log.debug{"#{LOG_WS_RECV}counts: #{@shared_info[:count]}"}
-          rescue => e
-            Log.log.debug{"#{LOG_WS_RECV}Exception: #{e}"}
-            @shared_info[:mutex].synchronize do
-              @shared_info[:read_exception] = e
-              @shared_info[:cond_var].signal
-            end
-            break
-          end # begin/rescue
-        end # loop
-        Log.log.debug do
-          "#{LOG_WS_RECV}exception: #{@shared_info[:read_exception]},cls=#{@shared_info[:read_exception].class})"
-        end unless @shared_info[:read_exception].nil?
-        Log.log.debug{"#{LOG_WS_RECV}read thread stopped (ws eof=#{@ws_io.eof?})"}
-      end
-
-      def upload(transfer_spec)
-        # identify this session uniquely
-        session_id = SecureRandom.uuid
-        notify_progress(session_id: nil, type: :pre_start, info: 'starting')
-        # total size of all files
-        total_bytes_to_transfer = 0
-        # we need to keep track of actual file path because transfer spec is modified to be sent in web socket
-        files_to_read = []
-        # get source root or nil
-        source_root = transfer_spec.key?('source_root') && !transfer_spec['source_root'].empty? ? transfer_spec['source_root'] : nil
-        # source root is ignored by GW, used only here
-        transfer_spec.delete('source_root')
-        # compute total size of files to upload (for progress)
-        # modify transfer spec to be suitable for GW
-        transfer_spec['paths'].each do |item|
-          # save actual file location to be able read contents later
-          file_to_add = Transfer::FauxFile.open(item['source'])
-          if file_to_add
-            item['source'] = file_to_add.path
-            item['file_size'] = file_to_add.size
-          else
-            file_to_add = item['source']
-            # add source root if needed
-            file_to_add = File.join(source_root, file_to_add) unless source_root.nil?
-            # GW expects a simple file name in 'source' but if user wants to change the name, we take it
-            item['source'] = File.basename(item['destination'].nil? ? item['source'] : item['destination'])
-            item['file_size'] = File.size(file_to_add)
-          end
-          # save so that we can actually read the file later
-          files_to_read.push(file_to_add)
-          total_bytes_to_transfer += item['file_size']
-        end
-        # TODO: check that this is available in endpoints: @api_info['endpoints']
-        upload_url = File.join(@gw_base_url, @options[:api_version], 'upload')
-        notify_progress(session_id: nil, type: :pre_start, info: 'connecting wss')
-        # open web socket to end point (equivalent to Net::HTTP.start)
-        http_session = Rest.start_http_session(upload_url)
-        # get the underlying socket i/o
-        @ws_io = Rest.io_http_session(http_session)
-        @ws_handshake = ::WebSocket::Handshake::Client.new(url: upload_url, headers: {})
-        @ws_io.write(@ws_handshake.to_s)
-        sleep(0.1)
-        @ws_handshake << @ws_io.readuntil("\r\n\r\n")
-        Aspera.assert(@ws_handshake.finished?){'Error in websocket handshake'}
-        Log.log.debug{"#{LOG_WS_SEND}handshake success"}
-        # start read thread after handshake
-        @ws_read_thread = Thread.new {process_read_thread}
-        notify_progress(session_id: session_id, type: :session_start)
-        notify_progress(session_id: session_id, type: :session_size, info: total_bytes_to_transfer)
-        sleep(1)
-        # data shared between main thread and read thread
-        @shared_info = {
-          read_exception: nil, # error message if any in callback
-          count:          {
-            sent_general:          0,
-            received_general:      0,
-            sent_v2_delimiter:     0,
-            received_v2_delimiter: 0
-          },
-          mutex:          Mutex.new,
-          cond_var:       ConditionVariable.new
-        }
-        # notify progress bar
-        notify_progress(type: :session_size, session_id: session_id, info: total_bytes_to_transfer)
-        # first step send transfer spec
-        Log.log.debug{Log.dump(:ws_spec, transfer_spec)}
-        ws_snd_json(MSG_SEND_TRANSFER_SPEC, transfer_spec)
-        # current file index
-        file_index = 0
-        # aggregate size sent
-        session_sent_bytes = 0
-        # process each file
-        transfer_spec['paths'].each do |item|
-          slice_info = {
-            name:       nil,
-            # TODO: get mime type?
-            type:       'application/octet-stream',
-            size:       item['file_size'],
-            slice:      0, # current slice index
-            # index of last slice (i.e number of slices - 1)
-            last_slice: (item['file_size'] - 1) / @options[:upload_chunk_size],
-            fileIndex:  file_index
-          }
-          file = files_to_read[file_index]
-          if file.is_a?(Transfer::FauxFile)
-            slice_info[:name] = file.path
-          else
-            file = File.open(file)
-            slice_info[:name] = File.basename(item[item['destination'].nil? ? 'source' : 'destination'])
-          end
-          begin
-            until file.eof?
-              slice_bin_data = file.read(@options[:upload_chunk_size])
-              # interrupt main thread if read thread failed
-              raise @shared_info[:read_exception] unless @shared_info[:read_exception].nil?
-              begin
-                if @options[:api_version].eql?(API_V1)
-                  slice_info[:data] = Base64.strict_encode64(slice_bin_data)
-                  ws_snd_json(MSG_SEND_SLICE_UPLOAD, slice_info)
-                else
-                  # send once, before data, at beginning
-                  ws_snd_json(MSG_SEND_SLICE_UPLOAD, slice_info) if slice_info[:slice].eql?(0)
-                  ws_send(ws_type: :binary, data: slice_bin_data)
-                  Log.log.debug{"#{LOG_WS_SEND}buffer: file: #{file_index}, slice: #{slice_info[:slice]}/#{slice_info[:last_slice]}"}
-                  # send once, after data, at end
-                  ws_snd_json(MSG_SEND_SLICE_UPLOAD, slice_info) if slice_info[:slice].eql?(slice_info[:last_slice])
-                end
-              rescue Errno::EPIPE => e
-                raise @shared_info[:read_exception] unless @shared_info[:read_exception].nil?
-                raise e
-              rescue Net::ReadTimeout => e
-                Log.log.warn{'A timeout condition using HTTPGW may signal a permission problem on destination. Check ascp logs on httpgw.'}
-                raise e
-              end
-              session_sent_bytes += slice_bin_data.length
-              notify_progress(type: :transfer, session_id: session_id, info: session_sent_bytes)
-              slice_info[:slice] += 1
-            end
-          ensure
-            file.close
-          end
-          file_index += 1
-        end # loop on files
-        # throttling may have skipped last one
-        notify_progress(type: :transfer, session_id: session_id, info: session_sent_bytes)
-        notify_progress(type: :end, session_id: session_id)
-        ws_send(ws_type: :close, data: nil)
-        Log.log.debug("Finished upload, waiting for end of #{THR_RECV} thread.")
-        @ws_read_thread.join
-        Log.log.debug{'Read thread joined'}
-        # session no more used
-        @ws_io = nil
-        http_session&.finish
-      end
-
-      def download(transfer_spec)
-        transfer_spec['zip_required'] ||= false
-        transfer_spec['source_root'] ||= '/'
-        # is normally provided by application, like package name
-        if !transfer_spec.key?('download_name')
-          # by default it is the name of first file
-          download_name = File.basename(transfer_spec['paths'].first['source'])
-          # we remove extension
-          download_name = download_name.gsub(/\.@gw_api.*$/, '')
-          # ands add indication of number of files if there is more than one
-          if transfer_spec['paths'].length > 1
-            download_name += " #{transfer_spec['paths'].length} Files"
-          end
-          transfer_spec['download_name'] = download_name
-        end
-        creation = @gw_api.create('v1/download', {'transfer_spec' => transfer_spec})[:data]
-        transfer_uuid = creation['url'].split('/').last
-        file_name =
-          if transfer_spec['zip_required'] || transfer_spec['paths'].length > 1
-            # it is a zip file if zip is required or there is more than 1 file
-            transfer_spec['download_name'] + '.zip'
-          else
-            # it is a plain file if we don't require zip and there is only one file
-            File.basename(transfer_spec['paths'].first['source'])
-          end
-        file_path = File.join(transfer_spec['destination_root'], file_name)
-        @gw_api.call(operation: 'GET', subpath: "v1/download/#{transfer_uuid}", save_to_file: file_path)
-      end
-
       # start FASP transfer based on transfer spec (hash table)
       # note that it is asynchronous
       # HTTP download only supports file list
@@ -319,13 +20,13 @@ module Aspera
         transfer_spec['authentication'] ||= 'token'
         case transfer_spec['direction']
         when Transfer::Spec::DIRECTION_SEND
-          upload(transfer_spec)
+          @gw_api.upload(transfer_spec)
         when Transfer::Spec::DIRECTION_RECEIVE
-          download(transfer_spec)
+          @gw_api.download(transfer_spec)
         else
           raise "unexpected direction: [#{transfer_spec['direction']}]"
         end
-      end # start_transfer
+      end
 
       # wait for completion of all jobs started
       # @return list of :success or error message
@@ -335,29 +36,27 @@ module Aspera
       end
 
       # TODO: is that useful?
-      def url=(api_url); end
+      # def url=(api_url); end
 
       private
 
-      def initialize(opts)
-        super(opts)
-        @options = Base.options(default: DEFAULT_OPTIONS, options: opts)
-        # remove /v1 from end of user-provided GW url: we need the base url only
-        @gw_base_url = @options[:url].gsub(%r{/v1/*$}, '')
-        @gw_api = Rest.new(base_url: @gw_base_url)
-        @api_info = @gw_api.read('v1/info')[:data]
-        Log.log.debug{Log.dump(:api_info, @api_info)}
-        # web socket endpoint: by default use v2 (newer gateways), without base64 encoding
-        # is the latest supported? else revert to old api
-        if !@options[:api_version].eql?(API_V1)
-          if !@api_info['endpoints'].any?{|i|i.include?(@options[:api_version])}
-            Log.log.warn{"API version #{@options[:api_version]} not supported, reverting to #{API_V1}"}
-            @options[:api_version] = API_V1
-          end
-        end
-        @options.freeze
-        Log.log.debug{Log.dump(:agent_options, @options)}
-      end
-    end # AgentHttpgw
+      def initialize(
+        url:,
+        api_version: Api::Httpgw::API_V2,
+        upload_chunk_size: 64_000,
+        synchronous:       false,
+        **base_options
+      )
+        super(**base_options)
+        @gw_api = Api::Httpgw.new(
+          # remove /v1 from end of user-provided GW url: we need the base url only
+          url:               url.gsub(%r{/#{Api::Httpgw::API_V1}/*$}o, ''),
+          api_version:       api_version,
+          upload_chunk_size: upload_chunk_size,
+          synchronous:       synchronous,
+          notify_cb:         ->(**event) { notify_progress(**event) }
+        )
+      end
+    end
   end
 end

data/lib/aspera/agent/node.rb

@@ -13,36 +13,35 @@ module Aspera
     # this singleton class is used by the CLI to provide a common interface to start a transfer
     # before using it, the use must set the `node_api` member.
     class Node < Base
-      DEFAULT_OPTIONS = {
-        url:      :required,
-        username: :required,
-        password: :required,
-        root_id:  nil
-      }.freeze
-      # option include: root_id if the node is an access key
-      # attr_writer :options
-
-      def initialize(opts)
-        Aspera.assert_type(opts, Hash){'node agent options'}
-        super(opts)
-        options = Base.options(default: DEFAULT_OPTIONS, options: opts)
+      # @param url [String] the base url of the node api
+      # @param username [String] the username to use for the node api
+      # @param password [String] the password to use for the node api
+      # @param root_id [String] root file id if the node is an access key
+      # @param base_options [Hash] options for base class
+      def initialize(
+        url:,
+        username:,
+        password:,
+        root_id: nil,
+        **base_options
+      )
+        super(**base_options)
         # root id is required for access key
-        @root_id = options[:root_id]
-        rest_params = { base_url: options[:url]}
-        if OAuth::Factory.bearer?(options[:password])
+        @root_id = root_id
+        rest_params = { base_url: url}
+        if OAuth::Factory.bearer?(password)
           Aspera.assert(!@root_id.nil?){'root_id not allowed for access key'}
-          rest_params[:headers] = Api::Node.bearer_headers(options[:password], access_key: options[:username])
+          rest_params[:headers] = Api::Node.bearer_headers(password, access_key: username)
         else
           rest_params[:auth] = {
             type:     :basic,
-            username: options[:username],
-            password: options[:password]
+            username: username,
+            password: password
           }
         end
         @node_api = Rest.new(**rest_params)
         # TODO: currently only supports one transfer. This is bad shortcut. but ok for CLI.
         @transfer_id = nil
-        # Log.log.debug{Log.dump(:agent_options, @options)}
       end
 
       # used internally to ensure node api is set before using.

data/lib/aspera/agent/trsdk.rb

@@ -17,13 +17,6 @@ module Aspera
       PORT_SEP = ':'
       # port zero means select a random available high port
       AUTO_LOCAL_TCP_PORT = "#{PORT_SEP}0"
-      DEFAULT_OPTIONS = {
-        url:      AUTO_LOCAL_TCP_PORT,
-        external: false,         # expect that an external daemon is already running
-        keep:     false          # do not shutdown daemon on exit
-      }.freeze
-      private_constant :DEFAULT_OPTIONS
-
       class << self
         # Well, the port number is only in log file
         def daemon_port_from_log(log_file)
@@ -44,19 +37,25 @@ module Aspera
         end
       end
 
-      # options come from transfer_info
-      def initialize(user_opts={})
-        super(user_opts)
-        @options = Base.options(default: DEFAULT_OPTIONS, options: user_opts)
-        is_local_auto_port = @options[:url].eql?(AUTO_LOCAL_TCP_PORT)
-        raise 'Cannot use options `keep` or `external` with port zero' if is_local_auto_port && (@options[:keep] || @options[:external])
-        Log.log.debug{Log.dump(:agent_options, @options)}
+      # @param url [String] URL of the transfer manager daemon
+      # @param external [Boolean] if true, expect that an external daemon is already running
+      # @param keep [Boolean] if true, do not shutdown daemon on exit
+      # @param base_options [Hash] base options
+      def initialize(
+        url: AUTO_LOCAL_TCP_PORT,
+        external: false,
+        keep:     false,
+        **base_options
+      )
+        super(**base_options)
+        is_local_auto_port = @url.eql?(AUTO_LOCAL_TCP_PORT)
+        raise 'Cannot use options `keep` or `external` with port zero' if is_local_auto_port && (@keep || @external)
         # load SDK stub class on demand, as it's an optional gem
         $LOAD_PATH.unshift(Ascp::Installation.instance.sdk_ruby_folder)
         require 'transfer_services_pb'
         # keep PID for optional shutdown
         @daemon_pid = nil
-        daemon_endpoint = @options[:url]
+        daemon_endpoint = @url
         Log.log.debug{Log.dump(:daemon_endpoint, daemon_endpoint)}
         # retry loop
         begin
@@ -67,14 +66,14 @@ module Aspera
           # Initiate actual connection
           get_info_response = @transfer_client.get_info(Transfersdk::InstanceInfoRequest.new)
           Log.log.debug{"Daemon info: #{get_info_response}"}
-          Log.log.warn{'Attached to existing daemon'} unless @daemon_pid || @options[:external] || @options[:keep]
+          Log.log.warn{'Attached to existing daemon'} unless @daemon_pid || @external || @keep
           at_exit{shutdown}
         rescue GRPC::Unavailable => e
           # if transferd is external: do not start it, or other error
-          raise if @options[:external] || !e.message.include?('failed to connect')
+          raise if @external || !e.message.include?('failed to connect')
           # we already tried to start a daemon, but it failed
           Aspera.assert(@daemon_pid.nil?){"Daemon started with PID #{@daemon_pid}, but connection failed to #{daemon_endpoint}}"}
-          Log.log.warn('no daemon present, starting daemon...') if @options[:external]
+          Log.log.warn('no daemon present, starting daemon...') if @external
           # location of daemon binary
           sdk_folder = File.realpath(File.join(Ascp::Installation.instance.sdk_ruby_folder, '..'))
           # transferd only supports local ip and port
@@ -111,7 +110,7 @@ module Aspera
             nil
           end
           Log.log.debug{"Daemon started with pid #{@daemon_pid}"}
-          Process.detach(@daemon_pid) if @options[:keep]
+          Process.detach(@daemon_pid) if @keep
           at_exit {shutdown}
           # update port for next connection attempt (if auto high port was requested)
           daemon_endpoint = "#{LOCAL_SOCKET_ADDR}#{PORT_SEP}#{self.class.daemon_port_from_log(log_stdout)}" if is_local_auto_port
@@ -171,7 +170,7 @@ module Aspera
       end
 
       def shutdown
-        stop_daemon unless @options[:keep]
+        stop_daemon unless @keep
       end
 
       def stop_daemon

data/lib/aspera/api/aoc.rb

@@ -12,15 +12,25 @@ require 'cgi'
 
 module Aspera
   module Api
+    SAAS_DOMAIN_PROD = 'ibmaspera.com'
+    class Alee < Aspera::Rest
+      def initialize(entitlement_id, customer_id, api_domain: SAAS_DOMAIN_PROD, version: 'v1')
+        super(
+          base_url: "https://api.#{api_domain}/metering/#{version}",
+          headers:  {'X-Aspera-Entitlement-Authorization' => Rest.basic_token(entitlement_id, customer_id)}
+        )
+      end
+    end
+
     class AoC < Aspera::Rest
       PRODUCT_NAME = 'Aspera on Cloud'
       DEFAULT_WORKSPACE = ''
       # Production domain of AoC
-      PROD_DOMAIN = 'ibmaspera.com' # cspell:disable-line
+      SAAS_DOMAIN_PROD = 'ibmaspera.com' # cspell:disable-line
       # to avoid infinite loop in pub link redirection
       MAX_AOC_URL_REDIRECT = 10
       CLIENT_ID_PREFIX = 'aspera.'
-      # Well-known AoC globals client apps
+      # Well-known AoC global client apps
       GLOBAL_CLIENT_APPS = DataRepository::ELEMENTS.select{|i|i.to_s.start_with?(CLIENT_ID_PREFIX)}.freeze
       # cookie prefix so that console can decode identity
       COOKIE_PREFIX_CONSOLE_AOC = 'aspera.aoc'
@@ -63,20 +73,13 @@ module Aspera
         end
 
         # base API url depends on domain, which could be "qa.xxx"
-        def api_base_url(organization: 'api', api_domain: PROD_DOMAIN)
+        def api_base_url(organization: 'api', api_domain: SAAS_DOMAIN_PROD)
           return "https://#{organization}.#{api_domain}"
         end
 
-        def metering_api(entitlement_id, customer_id, api_domain=PROD_DOMAIN)
-          return Rest.new(
-            base_url: "#{api_base_url(api_domain: api_domain)}/metering/v1",
-            headers:  {'X-Aspera-Entitlement-Authorization' => Rest.basic_token(entitlement_id, customer_id)}
-          )
-        end
-
         # split host of http://myorg.asperafiles.com in org and domain
         def url_parts(uri)
-          raise "No host found in URL.Please check URL format: https://myorg.#{PROD_DOMAIN}" if uri.host.nil?
+          raise "No host found in URL.Please check URL format: https://myorg.#{SAAS_DOMAIN_PROD}" if uri.host.nil?
           parts = uri.host.split('.', 2)
           Aspera.assert(parts.length == 2){"expecting a public FQDN for #{PRODUCT_NAME}"}
           return parts
@@ -128,11 +131,11 @@ module Aspera
             organization:    parts[0]
           }
         end
-      end # static methods
+      end
 
       attr_reader :private_link
 
-      def initialize(subpath: API_V1, url:, auth:, client_id: nil, client_secret: nil, scope: nil, redirect_uri: nil, private_key: nil, passphrase: nil, username: nil,
+      def initialize(url:, auth:, subpath: API_V1, client_id: nil, client_secret: nil, scope: nil, redirect_uri: nil, private_key: nil, passphrase: nil, username: nil,
         password: nil, workspace: nil, secret_finder: nil)
         # test here because link may set url
         raise ArgumentError, 'Missing mandatory option: url' if url.nil?
@@ -405,7 +408,7 @@ module Aspera
             end
           else # unexpected extended value, must be String or Hash
             raise "#{recipient_list_field} item must be a String (email, shared inbox) or Hash (id,type)"
-          end # type of recipient info
+          end
           # add original or resolved recipient info
           resolved_list.push(short_recipient_info)
         end

data/lib/aspera/api/cos_node.rb

@@ -52,9 +52,9 @@ module Aspera
         # read FASP connection information for bucket
         xml_result_text = s3_api.call(
           operation: 'GET',
-          subpath: bucket,
-          headers: {'Accept' => 'application/xml'},
-          url_params: {'faspConnectionInfo' => nil}
+          subpath:   bucket,
+          headers:   {'Accept' => 'application/xml'},
+          query:     {'faspConnectionInfo' => nil}
         )[:http].body
         ats_info = XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
         Aspera::Log.dump('ats_info', ats_info)
@@ -87,7 +87,7 @@ module Aspera
           receiver_client_ids: 'aspera_ats'
         )
         # get delegated token to be placed in rest call header and in transfer tags
-        @storage_credentials['token'][TOKEN_FIELD] = OAuth::Factory.bearer_extract(delegated_oauth.get_authorization)
+        @storage_credentials['token'][TOKEN_FIELD] = OAuth::Factory.bearer_extract(delegated_oauth.token)
         @headers['X-Aspera-Storage-Credentials'] = JSON.generate(@storage_credentials)
       end
     end