aspera-cli 4.19.0 → 4.20.0

data/lib/aspera/agent/trsdk.rb

@@ -7,6 +7,7 @@ require 'aspera/log'
 require 'aspera/assert'
 require 'json'
 require 'uri'
+require 'transfer_services_pb'
 
 module Aspera
   module Agent
@@ -48,14 +49,12 @@ module Aspera
         **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 = keep
+        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)
         # keep PID for optional shutdown
         @daemon_pid = nil
-        daemon_endpoint = @url
+        daemon_endpoint = url
         Log.log.debug{Log.dump(:daemon_endpoint, daemon_endpoint)}
         # retry loop
         begin
@@ -66,16 +65,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 || @external || @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 @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 @external
-          # location of daemon binary
-          sdk_folder = File.realpath(File.join(Ascp::Installation.instance.sdk_ruby_folder, '..'))
+          Log.log.warn('no daemon present, starting daemon...') if external
           # transferd only supports local ip and port
           daemon_uri = URI.parse("ipv4://#{daemon_endpoint}")
           Aspera.assert(daemon_uri.scheme.eql?('ipv4')){"Invalid scheme daemon URI #{daemon_endpoint}"}
@@ -86,8 +83,8 @@ module Aspera
             fasp_runtime: {
               use_embedded: false,
               user_defined: {
-                bin: sdk_folder,
-                etc: sdk_folder
+                bin: Ascp::Installation.instance.sdk_folder,
+                etc: Ascp::Installation.instance.sdk_folder
               }
             }
           }
@@ -143,24 +140,24 @@ module Aspera
           case response.status
           when :RUNNING
             if !session_started
-              notify_progress(session_id: @transfer_id, type: :session_start)
+              notify_progress(:session_start, session_id: @transfer_id)
               session_started = true
             end
             if bytes_expected.nil? &&
                 !response.sessionInfo.preTransferBytes.eql?(0)
               bytes_expected = response.sessionInfo.preTransferBytes
-              notify_progress(type: :session_size, session_id: @transfer_id, info: bytes_expected)
+              notify_progress(:session_size, session_id: @transfer_id, info: bytes_expected)
             end
-            notify_progress(type: :transfer, session_id: @transfer_id, info: response.transferInfo.bytesTransferred)
+            notify_progress(:transfer, session_id: @transfer_id, info: response.transferInfo.bytesTransferred)
           when :COMPLETED
-            notify_progress(type: :transfer, session_id: @transfer_id, info: bytes_expected) if bytes_expected
-            notify_progress(type: :end, session_id: @transfer_id)
+            notify_progress(:transfer, session_id: @transfer_id, info: bytes_expected) if bytes_expected
+            notify_progress(:end, session_id: @transfer_id)
             break
           when :FAILED, :CANCELED
-            notify_progress(type: :end, session_id: @transfer_id)
+            notify_progress(:end, session_id: @transfer_id)
             raise Transfer::Error, JSON.parse(response.message)['Description']
           when :QUEUED, :UNKNOWN_STATUS, :PAUSED, :ORPHANED
-            notify_progress(session_id: nil, type: :pre_start, info: response.status.to_s.downcase)
+            notify_progress(:pre_start, session_id: nil, info: response.status.to_s.downcase)
           else
             Log.log.error{"unknown status#{response.status}"}
           end

data/lib/aspera/api/alee.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'aspera/api/aoc.rb'
+module Aspera
+  module Api
+    class Alee < Aspera::Rest
+      def initialize(entitlement_id, customer_id, api_domain: AoC::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
+  end
+end

data/lib/aspera/api/aoc.rb

@@ -12,18 +12,9 @@ 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'
+      # use default workspace if it is set, else none
       DEFAULT_WORKSPACE = ''
       # Production domain of AoC
       SAAS_DOMAIN_PROD = 'ibmaspera.com' # cspell:disable-line
@@ -78,42 +69,50 @@ module Aspera
         end
 
         # split host of http://myorg.asperafiles.com in org and domain
-        def url_parts(uri)
+        def split_org_domain(uri)
           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
+          parts[0] = nil if parts[0].eql?('api')
+          return %i{organization domain}.zip(parts).to_h
         end
 
         # @param url [String] URL of AoC public link
         # @return [Hash] information about public link, or nil if not a public link
         def link_info(url)
-          final_uri = Rest.new(base_url: url, redirect_max: MAX_AOC_URL_REDIRECT).read('')[:http].uri
-          raise 'AoC shall redirect to login page' if final_uri.query.nil?
-          decoded_query = Rest.decode_query(final_uri.query)
+          final_uri = Rest.new(base_url: url, redirect_max: MAX_AOC_URL_REDIRECT).call(operation: 'GET')[:http].uri
+          Log.log.trace1{Log.dump(:final_uri, final_uri)}
+          org_domain = split_org_domain(final_uri)
+          if (m = final_uri.path.match(%r{/oauth2/([^/]+)/login$}))
+            org_domain[:organization] = m[1] if org_domain[:organization].nil?
+          else
+            Log.log.debug{"path=#{final_uri.path} does not end with /login"}
+          end
+          raise 'AoC shall redirect to login page with a query' if final_uri.query.nil?
+          query = Rest.query_to_h(final_uri.query)
+          Log.log.trace1{Log.dump(:query, query)}
           # is that a public link ?
-          if decoded_query.key?('token')
+          if query.key?('token')
             Log.log.warn{"Unknown pub link path: #{final_uri.path}"} unless PUBLIC_LINK_PATHS.include?(final_uri.path)
             # ok we get it !
             return {
-              instance_domain: url_parts(final_uri)[1],
+              instance_domain: org_domain[:domain],
               url:             "https://#{final_uri.host}",
-              token:           decoded_query['token']
+              token:           query['token']
             }
           end
-          Log.log.debug{"path=#{final_uri.path} does not end with /login"} unless final_uri.path.end_with?('/login')
-          if decoded_query['state']
+          if query['state']
             # can be a private link
-            state_uri = URI.parse(decoded_query['state'])
-            if state_uri.query && decoded_query['redirect_uri']
-              decoded_state = Rest.decode_query(state_uri.query)
+            state_uri = URI.parse(query['state'])
+            if state_uri.query && query['redirect_uri']
+              decoded_state = Rest.query_to_h(state_uri.query)
               if decoded_state.key?('short_link_url')
                 if (m = state_uri.path.match(%r{/files/workspaces/([0-9]+)/all/([0-9]+):([0-9]+)}))
-                  redirect_uri = URI.parse(decoded_query['redirect_uri'])
-                  parts = url_parts(redirect_uri)
+                  redirect_uri = URI.parse(query['redirect_uri'])
+                  org_domain = split_org_domain(redirect_uri)
                   return {
-                    instance_domain: parts[1],
-                    organization:    parts[0],
+                    instance_domain: org_domain[:domain],
+                    organization:    org_domain[:organization],
                     url:             "https://#{redirect_uri.host}",
                     private_link:    {
                       workspace_id: m[1],
@@ -125,10 +124,10 @@ module Aspera
               end
             end
           end
-          parts = url_parts(URI.parse(url))
+          Log.log.debug{Log.dump(:org_domain, org_domain)}
           return {
-            instance_domain: parts[1],
-            organization:    parts[0]
+            instance_domain: org_domain[:domain],
+            organization:    org_domain[:organization]
           }
         end
       end
@@ -149,7 +148,8 @@ module Aspera
         @workspace_name = workspace
         @cache_user_info = nil
         @cache_url_token_info = nil
-        @context_cache = nil
+        @workspace_info = nil
+        @home_info = nil
         auth_params = {
           type:          :oauth2,
           client_id:     client_id,
@@ -206,7 +206,7 @@ module Aspera
         return nil unless auth_params[:grant_method].eql?(:url_json)
         return @cache_url_token_info unless @cache_url_token_info.nil?
         # TODO: can there be several in list ?
-        @cache_url_token_info = read('url_tokens')[:data].first
+        @cache_url_token_info = read('url_tokens').first
         return @cache_url_token_info
       end
 
@@ -225,7 +225,7 @@ module Aspera
         # get our user's default information
         @cache_user_info =
           begin
-            read('self')[:data]
+            read('self')
           rescue StandardError => e
             raise e if exception
             Log.log.debug{"ignoring error: #{e}"}
@@ -235,11 +235,20 @@ module Aspera
         return @cache_user_info
       end
 
-      # @param application [Symbol] :files or :packages
+      def workspace
+        raise 'internal error: AoC workspace context is not set' if @workspace_info.nil?
+        @workspace_info
+      end
+
+      def home
+        raise 'internal error: AoC home context is not set' if @home_info.nil?
+        @home_info
+      end
+
+      # Set the application context
+      # @param application [Symbol,NilClass] :files or :packages
       # @return [Hash] current context information: workspace, and home node/file if app is "Files"
-      def context(application = nil)
-        return @context_cache unless @context_cache.nil?
-        Aspera.assert(!application.nil?){'application must be set once'}
+      def context=(application)
         Aspera.assert_values(application, %i[files packages])
         ws_id =
           if !public_link.nil?
@@ -249,9 +258,10 @@ module Aspera
             Log.log.debug('Using workspace of private link')
             private_link[:workspace_id]
           elsif @workspace_name.eql?(DEFAULT_WORKSPACE)
-            Log.log.debug('Using default workspace'.green)
-            raise 'User does not have default workspace, please specify workspace' if current_user_info['default_workspace_id'].nil?
-            current_user_info['default_workspace_id']
+            if !current_user_info['default_workspace_id'].nil?
+              Log.log.debug('Using default workspace'.green)
+              current_user_info['default_workspace_id']
+            end
           elsif @workspace_name.nil?
             nil
           else
@@ -261,39 +271,49 @@ module Aspera
           if ws_id.nil?
             nil
           else
-            read("workspaces/#{ws_id}")[:data]
+            read("workspaces/#{ws_id}")
           end
-        @context_cache = if ws_info.nil?
-          {
-            workspace_id:   nil,
-            workspace_name: 'Shared folders'
-          }
-        else
-          {
-            workspace_id:   ws_info['id'],
-            workspace_name: ws_info['name']
-          }
-        end
-        return @context_cache unless application.eql?(:files)
-        if !public_link.nil?
-          assert_public_link_types(['view_shared_file'])
-          @context_cache[:home_node_id] = public_link['data']['node_id']
-          @context_cache[:home_file_id] = public_link['data']['file_id']
-        elsif !private_link.nil?
-          @context_cache[:home_node_id] = private_link[:node_id]
-          @context_cache[:home_file_id] = private_link[:file_id]
-        elsif ws_info
-          @context_cache[:home_node_id] = ws_info['home_node_id']
-          @context_cache[:home_file_id] = ws_info['home_file_id']
-        else
-          # not part of any workspace, but has some folder shared
-          user_info = current_user_info(exception: true) rescue {'read_only_home_node_id' => nil, 'read_only_home_file_id' => nil}
-          @context_cache[:home_node_id] = user_info['read_only_home_node_id']
-          @context_cache[:home_file_id] = user_info['read_only_home_file_id']
-        end
-        raise "Cannot get user's home node id, check your default workspace or specify one" if @context_cache[:home_node_id].to_s.empty?
-        Log.log.debug{Log.dump(:context, @context_cache)}
-        return @context_cache
+        @workspace_info =
+          if ws_info.nil?
+            {
+              id:   nil,
+              name: 'Shared folders'
+            }
+          else
+            {
+              id:   ws_info['id'],
+              name: ws_info['name']
+            }
+          end
+        Log.log.debug{Log.dump(:context, @workspace_info)}
+        return nil unless application.eql?(:files)
+        @home_info =
+          if !public_link.nil?
+            assert_public_link_types(['view_shared_file'])
+            {
+              node_id: public_link['data']['node_id'],
+              file_id: public_link['data']['file_id']
+            }
+          elsif !private_link.nil?
+            {
+              node_id: private_link[:node_id],
+              file_id: private_link[:file_id]
+            }
+          elsif ws_info
+            {
+              node_id: ws_info['home_node_id'],
+              file_id: ws_info['home_file_id']
+            }
+          else
+            # not part of any workspace, but has some folder shared
+            user_info = current_user_info(exception: true) rescue {'read_only_home_node_id' => nil, 'read_only_home_file_id' => nil}
+            {
+              node_id: user_info['read_only_home_node_id'],
+              file_id: user_info['read_only_home_file_id']
+            }
+          end
+        raise "Cannot get user's home node id, check your default workspace or specify one" if @home_info[:node_id].to_s.empty?
+        Log.log.debug{Log.dump(:context, @home_info)}
       end
 
       # @param node_id [String] identifier of node in AoC
@@ -304,9 +324,9 @@ module Aspera
       # @returns [Node] a node API for access key
       def node_api_from(node_id:, workspace_id: nil, workspace_name: nil, scope: Node::SCOPE_USER, package_info: nil)
         Aspera.assert_type(node_id, String)
-        node_info = read("nodes/#{node_id}")[:data]
+        node_info = read("nodes/#{node_id}")
         if workspace_name.nil? && !workspace_id.nil?
-          workspace_name = read("workspaces/#{workspace_id}")[:data]['name']
+          workspace_name = read("workspaces/#{workspace_id}")['name']
         end
         app_info = {
           api:            self, # for callback
@@ -346,7 +366,7 @@ module Aspera
           pkg_data['recipients'].first.is_a?(Hash) &&
           pkg_data['recipients'].first.key?('type') &&
           pkg_data['recipients'].first['type'].eql?('dropbox')
-        meta_schema = read("dropboxes/#{pkg_data['recipients'].first['id']}")[:data]['metadata_schema']
+        meta_schema = read("dropboxes/#{pkg_data['recipients'].first['id']}")['metadata_schema']
         if meta_schema.nil? || meta_schema.empty?
           Log.log.debug('no metadata in shared inbox')
           return
@@ -390,7 +410,7 @@ module Aspera
             # email: user, else dropbox
             entity_type = short_recipient_info.include?('@') ? 'contacts' : 'dropboxes'
             begin
-              full_recipient_info = lookup_by_name(entity_type, short_recipient_info, {'current_workspace_id' => ws_id})
+              full_recipient_info = lookup_by_name(entity_type, short_recipient_info, query: {'current_workspace_id' => ws_id})
             rescue RuntimeError => e
               raise e unless e.message.start_with?(ENTITY_NOT_FOUND)
               # dropboxes cannot be created on the fly
@@ -399,7 +419,7 @@ module Aspera
               full_recipient_info = create('contacts', {
                 'current_workspace_id' => ws_id,
                 'email'                => short_recipient_info
-              }.merge(new_user_option))[:data]
+              }.merge(new_user_option))
             end
             short_recipient_info = if entity_type.eql?('dropboxes')
               {'id' => full_recipient_info['id'], 'type' => 'dropbox'}
@@ -453,7 +473,7 @@ module Aspera
         validate_metadata(package_data) if validate_meta
 
         #  create a new package container
-        created_package = create('packages', package_data)[:data]
+        created_package = create('packages', package_data)
 
         package_node_api = node_api_from(
           node_id: created_package['node_id'],
@@ -463,7 +483,7 @@ module Aspera
         # tell AoC what to expect in package: 1 transfer (can also be done after transfer)
         # TODO: if multi session was used we should probably tell
         # also, currently no "multi-source" , i.e. only from client-side files, unless "node" agent is used
-        update("packages/#{created_package['id']}", {'sent' => true, 'transfers_expected' => 1})[:data]
+        update("packages/#{created_package['id']}", {'sent' => true, 'transfers_expected' => 1})
 
         return {
           spec: package_node_api.transfer_spec_gen4(created_package['contents_file_id'], Transfer::Spec::DIRECTION_SEND),
@@ -524,14 +544,14 @@ module Aspera
       ID_AK_ADMIN = 'ASPERA_ACCESS_KEY_ADMIN'
       # Callback from Plugins::Node
       # add application specific tags to permissions creation
-      # @param create_param [Hash] parameters for creating permissions
+      # @param perm_data [Hash] parameters for creating permissions
       # @param app_info [Hash] application information
-      def permissions_set_create_params(create_param:, app_info:)
+      def permissions_set_create_params(perm_data:, app_info:)
         # workspace shared folder:
         # access_id = "#{ID_AK_ADMIN}_WS_#{app_info[:workspace_id]}"
-        default_params = {
+        defaults = {
           # 'access_type'   => 'user', # mandatory: user or group
-          # 'access_id'     => access_id, # id of user or group
+          # 'access_id'     => access_id, # id of user or group or special
           'tags' => {
             Transfer::Spec::TAG_RESERVED => {
               'files' => {
@@ -543,6 +563,7 @@ module Aspera
                   'shared_by_name'    => current_user_info['name'],
                   'shared_by_email'   => current_user_info['email'],
                   # 'shared_with_name'  => access_id,
+                  # 'share_as'  => new_name_for_folder,
                   'access_key'        => app_info[:node_info]['access_key'],
                   'node'              => app_info[:node_info]['name']
                 }
@@ -550,34 +571,42 @@ module Aspera
             }
           }
         }
-        create_param.deep_merge!(default_params)
-        if create_param.key?('with')
-          contact_info = lookup_by_name(
-            'contacts',
-            create_param['with'],
-            {'current_workspace_id' => app_info[:workspace_id], 'context' => 'share_folder'})
-          create_param.delete('with')
-          create_param['access_type'] = contact_info['source_type']
-          create_param['access_id'] = contact_info['source_id']
-          create_param['tags'][Transfer::Spec::TAG_RESERVED]['files']['workspace']['shared_with_name'] = contact_info['email']
+        perm_data.deep_merge!(defaults)
+        tag_workspace = perm_data['tags'][Transfer::Spec::TAG_RESERVED]['files']['workspace']
+        case perm_data['with']
+        when NilClass
+        when ''
+          perm_data['access_type'] = 'user'
+          perm_data['access_id'] = "#{ID_AK_ADMIN}_WS_#{app_info[:workspace_id]}"
+          tag_workspace['shared_with_name'] = perm_data['access_id']
+        else
+          entity_info = lookup_by_name('contacts', perm_data['with'], query: {'current_workspace_id' => app_info[:workspace_id]})
+          perm_data['access_type'] = entity_info['source_type']
+          perm_data['access_id'] = entity_info['source_id']
+          tag_workspace['shared_with_name'] = entity_info['email']
+        end
+        perm_data.delete('with')
+        if perm_data.key?('as')
+          tag_workspace['share_as'] = perm_data['as']
+          perm_data.delete('as')
         end
         # optional
-        app_info[:opt_link_name] = create_param.delete('link_name')
+        app_info[:opt_link_name] = perm_data.delete('link_name')
       end
 
       # Callback from Plugins::Node
       # send shared folder event to AoC
-      # @param created_data [Hash] response from permission creation
+      # @param event_data [Hash] response from permission creation
       # @param app_info [Hash] hash with app info
       # @param types [Array] event types
-      def permissions_send_event(created_data:, app_info:, types: PERMISSIONS_CREATED)
+      def permissions_send_event(event_data:, app_info:, types: PERMISSIONS_CREATED)
         Aspera.assert_type(types, Array)
         Aspera.assert(!types.empty?)
         event_creation = {
           'types'        => types,
           'node_id'      => app_info[:node_info]['id'],
           'workspace_id' => app_info[:workspace_id],
-          'data'         => created_data
+          'data'         => event_data
         }
         # (optional). The name of the folder to be displayed to the destination user.
         # Use it if its value is different from the "share_as" field.

data/lib/aspera/api/ats.rb

@@ -34,7 +34,7 @@ module Aspera
         if @all_servers_cache.nil?
           @all_servers_cache = []
           CLOUD_NAME.each_key do |name|
-            read("servers/#{name.to_s.upcase}")[:data].each do |i|
+            read("servers/#{name.to_s.upcase}").each do |i|
               @all_servers_cache.push(i)
             end
           end

data/lib/aspera/api/cos_node.rb

@@ -19,7 +19,7 @@ module Aspera
             Aspera.assert(service_credentials.key?(field)){"service_credentials must have a field: #{field}"}
           end
           # read endpoints from service provided in service credentials
-          endpoints = Aspera::Rest.new(base_url: service_credentials['endpoints']).read('')[:data]
+          endpoints = Aspera::Rest.new(base_url: service_credentials['endpoints']).read('')
           Aspera::Log.dump('endpoints', endpoints)
           endpoint = endpoints.dig('service-endpoints', 'regional', bucket_region, 'public', bucket_region)
           raise "no such region: #{bucket_region}" if endpoint.nil?

data/lib/aspera/api/httpgw.rb

@@ -138,7 +138,7 @@ module Aspera
       def upload(transfer_spec)
         # identify this session uniquely
         session_id = SecureRandom.uuid
-        @notify_cb&.call(session_id: nil, type: :pre_start, info: 'starting')
+        @notify_cb&.call(:pre_start, session_id: nil, info: 'starting')
         # process files to send, modify `paths` in transfer_spec
         files_to_send = process_upload_list(transfer_spec)
         # total size of all files is last element
@@ -147,7 +147,7 @@ module Aspera
         Log.log.trace1{Log.dump(:files_to_send, files_to_send)}
         # TODO: check that this is available in endpoints: @api_info['endpoints']
         upload_url = File.join(@gw_root_url, @upload_version, 'upload')
-        @notify_cb&.call(session_id: nil, type: :pre_start, info: 'connecting wss')
+        @notify_cb&.call(:pre_start, session_id: nil, 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
@@ -172,11 +172,11 @@ module Aspera
         }
         # start read thread after handshake
         @ws_read_thread = Thread.new {process_read_thread}
-        @notify_cb&.call(session_id: session_id, type: :session_start)
-        @notify_cb&.call(session_id: session_id, type: :session_size, info: total_bytes_to_transfer)
+        @notify_cb&.call(:session_start, session_id: session_id)
+        @notify_cb&.call(:session_size, session_id: session_id, info: total_bytes_to_transfer)
         sleep(1)
         # notify progress bar
-        @notify_cb&.call(type: :session_size, session_id: session_id, info: total_bytes_to_transfer)
+        @notify_cb&.call(:session_size, session_id: session_id, info: total_bytes_to_transfer)
         # first step send transfer spec
         ws_snd_json(MSG_SEND_TRANSFER_SPEC, transfer_spec)
         # current file index
@@ -223,7 +223,7 @@ module Aspera
                 raise e
               end
               session_sent_bytes += slice_bin_data.length
-              @notify_cb&.call(type: :transfer, session_id: session_id, info: session_sent_bytes)
+              @notify_cb&.call(:transfer, session_id: session_id, info: session_sent_bytes)
               slice_info[:slice] += 1
             end
           ensure
@@ -232,8 +232,8 @@ module Aspera
           file_index += 1
         end
         # throttling may have skipped last one
-        @notify_cb&.call(type: :transfer, session_id: session_id, info: session_sent_bytes)
-        @notify_cb&.call(type: :end, session_id: session_id)
+        @notify_cb&.call(:transfer, session_id: session_id, info: session_sent_bytes)
+        @notify_cb&.call(: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
@@ -256,7 +256,7 @@ module Aspera
           end
           transfer_spec['download_name'] = download_name
         end
-        creation = create('download', {'transfer_spec' => transfer_spec})[:data]
+        creation = create('download', {'transfer_spec' => transfer_spec})
         transfer_uuid = creation['url'].split('/').last
         file_name =
           if transfer_spec['zip_required'] || transfer_spec['paths'].length > 1
@@ -274,6 +274,11 @@ module Aspera
         return @api_info
       end
 
+      # @return the base url of the gateway
+      def base_url
+        return @gw_root_url
+      end
+
       # @param url [String] URL of the HTTP Gateway, without version
       def initialize(
         url:,
@@ -299,7 +304,7 @@ module Aspera
         @synchronous = synchronous
         @notify_cb = notify_cb
         # get API info
-        @api_info = read('info')[:data].freeze
+        @api_info = read('info').freeze
         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