aspera-cli 4.24.2 → 4.25.0

data/lib/aspera/agent/direct.rb

@@ -186,20 +186,21 @@ module Aspera
         Log.log.debug('fasp local shutdown')
       end
 
+      # @param id [String] Transfer session identifier
       # @return [Array] list of sessions for a job
-      def sessions_by_job(job_id)
-        @sessions.select{ |session| session[:job_id].eql?(job_id)}
+      def sessions_by_job(id)
+        @sessions.select{ |session| session[:job_id].eql?(id)}
       end
 
       # Send command to management port of command (used in `asession).
       # Examples:
       # {'type'=>'START','source'=>_path_,'destination'=>_path_}
       # {'type'=>'DONE'}
-      # @param data [Hash]   Command on mgt port
-      # @param id   [String] Optional identifier or transfer session
+      # @param data [Hash]   Command on mgt port (snake case)
+      # @param id   [String] Optional identifier of transfer session
       def send_command(data, id: nil)
         Log.dump(:command, data)
-        sessions = id ? @sessions.select{ |session| session[:job_id].eql?(id)} : @sessions
+        sessions = id ? sessions_by_job(id) : @sessions
         if sessions.empty?
           Log.log.warn('No transfer session')
           return
@@ -251,11 +252,14 @@ module Aspera
         Aspera.assert_type(session, Hash)
         notify_progress(:sessions_init, info: 'starting')
         begin
+          # do not use
           capture_stderr = false
           stderr_r, stderr_w = nil
           spawn_args = {}
           command_pid = nil
-          command_arguments = []
+          # get location of command executable (ascp, async)
+          command_path = Ascp::Installation.instance.path(name)
+          command_arguments = [command_path]
           if @monitor
             # we use Socket directly, instead of TCPServer, as it gives access to lower level options
             socket_class = defined?(JRUBY_VERSION) ? ServerSocket : Socket
@@ -266,20 +270,18 @@ module Aspera
             mgt_server_socket.listen(1)
             # build arguments and add mgt port
             command_arguments = if name.eql?(:async)
-              ["--exclusive-mgmt-port=#{mgt_server_socket.local_address.ip_port}"]
+              [command_path, "--exclusive-mgmt-port=#{mgt_server_socket.local_address.ip_port}"]
             else
-              ['-M', mgt_server_socket.local_address.ip_port.to_s]
+              [command_path, '-M', mgt_server_socket.local_address.ip_port.to_s]
             end
           end
           command_arguments.concat(args)
           if capture_stderr
             # capture process stderr
             stderr_r, stderr_w = IO.pipe
-            spawn_args[err] = stderr_w
+            spawn_args[:err] = stderr_w
           end
-          # get location of command executable (ascp, async)
-          command_path = Ascp::Installation.instance.path(name)
-          command_pid = Environment.secure_spawn(env: env, exec: command_path, args: command_arguments, **spawn_args)
+          command_pid = Environment.secure_execute(*command_arguments, mode: :background, env: env, **spawn_args)
           # close here, but still used in other process (pipe)
           stderr_w&.close
           notify_progress(:sessions_init, info: "waiting for #{name} to start")

data/lib/aspera/agent/factory.rb

@@ -16,15 +16,18 @@ module Aspera
         Aspera::Agent.const_get(agent.to_s.capitalize).new(**options)
       end
 
-      # Discover available agents
-      # @return [Array] list of symbols of agents
-      def list
+      IGNORED_ITEMS = %i[factory base]
+      # Available agents: :long : Capitalized name string, :short : single character symbol
+      ALL =
         Dir.children(File.dirname(File.expand_path(__FILE__)))
           .select{ |file| file.end_with?(Environment::RB_EXT)}
           .map{ |file| File.basename(file, Environment::RB_EXT).to_sym}
-          .reject{ |item| IGNORED_ITEMS.include?(item)}
-      end
-      IGNORED_ITEMS = %i[factory base]
+          .reject{ |item| IGNORED_ITEMS.include?(item)}.each_with_object({}) do |agent_sym, hash|
+          hash[agent_sym] = {
+            long:  agent_sym.to_s.capitalize,
+            short: agent_sym.eql?(:direct) ? :a : agent_sym.to_s[0].to_sym
+          }.freeze
+        end.freeze
       private_constant :IGNORED_ITEMS
     end
   end

data/lib/aspera/agent/transferd.rb

@@ -21,10 +21,10 @@ module Aspera
 
       private_constant :LOCAL_SOCKET_ADDR, :PORT_SEP, :AUTO_LOCAL_TCP_PORT
 
-      # @param url   [String] URL of the transfer manager daemon
-      # @param start [Bool]   if false, expect that an external daemon is already running
-      # @param stop  [Bool]   if false, do not shutdown daemon on exit
-      # @param base  [Hash]   base class options
+      # @param url   [String]  URL of the transfer manager daemon
+      # @param start [Boolean] If `false`, expect that an external daemon is already running
+      # @param stop  [Boolean] If `false`, do not shutdown daemon on exit
+      # @param base  [Hash]    Base class options
       def initialize(
         url:   AUTO_LOCAL_TCP_PORT,
         start: true,
@@ -79,9 +79,9 @@ module Aspera
           log_stdout = "#{transferd_base_tmp}.out"
           log_stderr = "#{transferd_base_tmp}.err"
           File.write(conf_file, config.to_json)
-          @daemon_pid = Environment.secure_spawn(
-            exec: Ascp::Installation.instance.path(:transferd),
-            args: ['--config', conf_file],
+          @daemon_pid = Environment.secure_execute(
+            Ascp::Installation.instance.path(:transferd), '--config', conf_file,
+            mode: :background,
             out: log_stdout,
             err: log_stderr
           )
@@ -170,7 +170,7 @@ module Aspera
       def stop_daemon
         if !@daemon_pid.nil?
           Log.log.debug("Stopping daemon #{@daemon_pid}")
-          Process.kill(:INT, @daemon_pid)
+          Process.kill(:KILL, @daemon_pid)
           _, status = Process.wait2(@daemon_pid)
           Log.log.debug("daemon stopped #{status}")
           @daemon_pid = nil

data/lib/aspera/api/aoc.rb

@@ -33,7 +33,7 @@ module Aspera
       # types of events for shared folder creation
       # Node events: permission.created permission.modified permission.deleted
       PERMISSIONS_CREATED = ['permission.created'].freeze
-      # Special name when creating workspace shared folders
+      # Special user identifier when creating workspace shared folders
       ID_AK_ADMIN = 'ASPERA_ACCESS_KEY_ADMIN'
 
       private_constant :MAX_AOC_URL_REDIRECT,
@@ -48,11 +48,13 @@ module Aspera
         :ID_AK_ADMIN
 
       # various API scopes supported
-      SCOPE_FILES_SELF = 'self'
-      SCOPE_FILES_USER = 'user:all'
-      SCOPE_FILES_ADMIN = 'admin:all'
-      SCOPE_FILES_ADMIN_USER = 'admin-user:all'
-      SCOPE_FILES_ADMIN_USER_USER = "#{SCOPE_FILES_ADMIN_USER}+#{SCOPE_FILES_USER}"
+      module Scope
+        SELF = 'self'
+        USER = 'user:all'
+        ADMIN = 'admin:all'
+        ADMIN_USER = 'admin-user:all'
+        ADMIN_USER_USER = "#{ADMIN_USER}+#{USER}"
+      end
       FILES_APP = 'files'
       PACKAGES_APP = 'packages'
       API_V1 = 'api/v1'
@@ -73,7 +75,7 @@ module Aspera
         # split host of URL into organization and domain
         def split_org_domain(uri)
           Aspera.assert_type(uri, URI)
-          raise "No host found in URL.Please check URL format: https://myorg.#{SAAS_DOMAIN_PROD}" if uri.host.nil?
+          Aspera.assert(!uri.host.nil?){"No host found in URL. Please check URL format: https://myorg.#{SAAS_DOMAIN_PROD}"}
           parts = uri.host.split('.', 2)
           Aspera.assert(parts.length == 2){"expecting a public FQDN for #{PRODUCT_NAME}"}
           parts[0] = nil if parts[0].eql?('api')
@@ -89,7 +91,7 @@ module Aspera
         # @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).call(operation: 'GET')[:http].uri
+          final_uri = Rest.new(base_url: url, redirect_max: MAX_AOC_URL_REDIRECT).call(operation: 'GET', ret: :resp).uri
           Log.dump(:final_uri, final_uri, level: :trace1)
           org_domain = split_org_domain(final_uri)
           if (m = final_uri.path.match(%r{/oauth2/([^/]+)/login$}))
@@ -97,7 +99,7 @@ module Aspera
           else
             Log.log.debug{"path=#{final_uri.path} does not end with /login"}
           end
-          raise Error, 'AoC shall redirect to login page with a query' if final_uri.query.nil?
+          Aspera.assert(!final_uri.query.nil?, 'AoC shall redirect to login page with a query', type: Error)
           query = Rest.query_to_h(final_uri.query)
           Log.dump(:query, query, level: :trace1)
           # is that a public link ?
@@ -141,9 +143,10 @@ module Aspera
         end
 
         # Call block with same query using paging and response information.
-        # Block must return a hash with :data and :http keys
+        # Block must return an Array with data and http response
         # @return [Hash] {items: , total: }
-        def call_paging(query: {}, formatter: nil)
+        def call_paging(query: nil, formatter: nil)
+          query = {} if query.nil?
           Aspera.assert_type(query, Hash){'query'}
           Aspera.assert(block_given?)
           # set default large page if user does not specify own parameters. AoC Caps to 1000 anyway
@@ -158,33 +161,62 @@ module Aspera
           loop do
             new_query = query.clone
             new_query['page'] = current_page
-            result = yield(new_query)
-            Aspera.assert(result[:data])
-            Aspera.assert(result[:http])
-            total_count = result[:http]['X-Total-Count']
+            result_data, result_http = yield(new_query)
+            Aspera.assert(result_http)
+            total_count = result_http['X-Total-Count']&.to_i
             page_count += 1
             current_page += 1
-            add_items = result[:data]
+            add_items = result_data
+            break if add_items.nil?
             break if add_items.empty?
             # append new items to full list
             item_list += add_items
             break if !max_items.nil? && item_list.count >= max_items
             break if !max_pages.nil? && page_count >= max_pages
+            break if total_count&.<=(item_list.count)
             formatter&.long_operation_running("#{item_list.count} / #{total_count}") unless total_count.eql?(item_list.count.to_s)
           end
           formatter&.long_operation_terminated
           item_list = item_list[0..max_items - 1] if !max_items.nil? && item_list.count > max_items
           return {items: item_list, total: total_count}
         end
+
+        # @param id [String] Identifier or workspace
+        # @return [Hash] suitable for permission filtering
+        def workspace_access(id)
+          {
+            'access_type' => 'user',
+            'access_id'   => "#{ID_AK_ADMIN}_WS_#{id}"
+          }
+        end
+
+        # @param permission [Hash] Shared folder information
+        # @return [Boolean] `true` if internal access
+        def workspace_access?(permission)
+          permission['access_id'].start_with?("#{ID_AK_ADMIN}_WS_")
+        end
       end
 
       attr_reader :private_link
 
-      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 ParameterError, 'Missing mandatory option: url' if url.nil?
-        raise ParameterError, 'Missing mandatory option: scope' if scope.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
+        Aspera.assert(url, 'Missing mandatory option: url', type: ParameterError)
+        Aspera.assert(scope, 'Missing mandatory option: scope', type: ParameterError)
         # default values for client id
         client_id, client_secret = self.class.get_client_info if client_id.nil?
         # access key secrets are provided out of band to get node api access
@@ -197,10 +229,12 @@ module Aspera
         @workspace_info = nil
         @home_info = nil
         auth_params = {
-          type:          :oauth2,
-          client_id:     client_id,
-          client_secret: client_secret,
-          scope:         scope
+          type:   :oauth2,
+          params: {
+            client_id:     client_id,
+            client_secret: client_secret,
+            scope:         scope
+          }
         }
         # analyze type of url
         url_info = AoC.link_info(url)
@@ -209,7 +243,7 @@ module Aspera
         auth_params[:grant_method] = if url_info.key?(:token)
           :url_json
         else
-          raise ParameterError, 'Missing mandatory option: auth' if auth.nil?
+          Aspera.assert(auth, 'Missing mandatory option: auth', type: ParameterError)
           auth
         end
         # this is the base API url
@@ -219,27 +253,27 @@ module Aspera
         # fill other auth parameters based on OAuth method
         case auth_params[:grant_method]
         when :web
-          raise ParameterError, 'Missing mandatory option: redirect_uri' if redirect_uri.nil?
+          Aspera.assert(redirect_uri, 'Missing mandatory option: redirect_uri', type: ParameterError)
           auth_params[:redirect_uri] = redirect_uri
         when :jwt
-          raise ParameterError, 'Missing mandatory option: private_key' if private_key.nil?
-          raise ParameterError, 'Missing mandatory option: username' if username.nil?
+          Aspera.assert(private_key, 'Missing mandatory option: private_key', type: ParameterError)
+          Aspera.assert(username, 'Missing mandatory option: username', type: ParameterError)
           auth_params[:private_key_obj] = OpenSSL::PKey::RSA.new(private_key, passphrase)
           auth_params[:payload] = {
-            iss: auth_params[:client_id], # issuer
+            iss: client_id, # issuer
             sub: username, # subject
             aud: JWT_AUDIENCE
           }
           # add jwt payload for global client id
-          auth_params[:payload][:org] = url_info[:organization] if GLOBAL_CLIENT_APPS.include?(auth_params[:client_id])
+          auth_params[:payload][:org] = url_info[:organization] if GLOBAL_CLIENT_APPS.include?(client_id)
           auth_params[:cache_ids] = [url_info[:organization]]
         when :url_json
-          auth_params[:url] = {grant_type: 'url_token'} # URL arguments
+          auth_params[:url] = {grant_type: 'url_token'} # Query arguments
           auth_params[:json] = {url_token: url_info[:token]} # JSON body
           # password protection of link
           auth_params[:json][:password] = password unless password.nil?
           # basic auth required for /token
-          auth_params[:auth] = {type: :basic, username: auth_params[:client_id], password: auth_params[:client_secret]}
+          auth_params[:auth] = {type: :basic, username: client_id, password: client_secret}
         else Aspera.error_unexpected_value(auth_params[:grant_method]){'auth, use one of: :web, :jwt'}
         end
         super(
@@ -250,10 +284,9 @@ module Aspera
 
       # read using the query and paging
       # @return [Hash] {items: , total: }
-      def read_with_paging(subpath, query: {}, formatter: nil)
+      def read_with_paging(subpath, query = nil, formatter: nil)
         return self.class.call_paging(query: query, formatter: formatter) do |paged_query|
-          # Use `call` instead of `read` to get headers
-          call(operation: 'GET', subpath: subpath, headers: {'Accept' => Rest::MIME_JSON}, query: paged_query)
+          read(subpath, query: paged_query, ret: :both)
         end
       end
 
@@ -352,16 +385,17 @@ module Aspera
               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?
+        Aspera.assert(!@home_info[:node_id].to_s.empty?, "Cannot get user's home node id, check your default workspace or specify one", type: Error)
         Log.dump(:context, @home_info)
         @home_info
       end
 
-      # @param node_id [String] identifier of node in AoC
-      # @param workspace_id [String] workspace identifier
-      # @param workspace_name [String] workspace name
-      # @param scope e.g. Node::SCOPE_USER, or nil (requires secret)
-      # @param package_info [Hash] created package information
+      # Return a Node API for given node id, in a given context (files, packages), for the given scope.
+      # @param node_id        [String] identifier of node in AoC
+      # @param workspace_id   [String,nil] workspace identifier
+      # @param workspace_name [String,nil] workspace name
+      # @param scope          [String,nil] e.g. Node::SCOPE_USER, or Node::SCOPE_ADMIN, or nil (requires secret)
+      # @param package_info   [Hash,nil] created package information
       # @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)
@@ -380,18 +414,22 @@ module Aspera
           app_info[:package_name] = package_info['name']
         end
         node_params = {base_url: node_info['url']}
-        # if secret is available
-        if scope.nil?
+        ak_secret = @secret_finder&.lookup_secret(url: node_info['url'], username: node_info['access_key'])
+        # If secret is available, or no scope, use basic auth
+        if scope.nil? || ak_secret
+          Aspera.assert(ak_secret, "Secret not found for access key #{node_info['access_key']}@#{node_info['url']}", type: Error)
           node_params[:auth] = {
             type:     :basic,
             username: node_info['access_key'],
-            password: @secret_finder&.lookup_secret(url: node_info['url'], username: node_info['access_key'], mandatory: true)
+            password: ak_secret
           }
         else
           # OAuth bearer token
           node_params[:auth] = auth_params.clone
-          node_params[:auth][:scope] = Node.token_scope(node_info['access_key'], scope)
-          # special header required for bearer token only
+          node_params[:auth][:params] ||= {}
+          node_params[:auth][:params][:scope] = Node.token_scope(node_info['access_key'], scope)
+          node_params[:auth][:params][:owner_access] = true if scope.eql?(Node::SCOPE_ADMIN)
+          # Special header required for bearer token only
           node_params[:headers] = {Node::HEADER_X_ASPERA_ACCESS_KEY => node_info['access_key']}
         end
         node_params[:app_info] = app_info
@@ -423,37 +461,38 @@ module Aspera
         end
         meta_schema.each do |field|
           provided = pkg_meta.select{ |i| i['name'].eql?(field['name'])}
-          raise "only one field with name #{field['name']} allowed" if provided.count > 1
-          raise "missing mandatory field: #{field['name']}" if field['required'] && provided.empty?
+          Aspera.assert(provided.count <= 1, type: Error){"only one field with name #{field['name']} allowed"}
+          Aspera.assert(!provided.empty?, type: Error){"missing mandatory field: #{field['name']}"} if field['required']
         end
       end
 
       # Normalize package creation recipient lists as expected by AoC API
       # AoC expects {type: , id: }, but ascli allows providing either the native values or just a name
       # in that case, the name is resolved and replaced with {type: , id: }
-      # @param package_data The whole package creation payload
-      # @param recipient_list_field The field in structure, i.e. recipients or bcc_recipients
-      # @return nil package_data is modified
-      def resolve_package_recipients(package_data, ws_id, recipient_list_field, new_user_option)
-        return unless package_data.key?(recipient_list_field)
-        Aspera.assert_type(package_data[recipient_list_field], Array){recipient_list_field}
+      # @param package_data    [Hash]   The whole package creation payload
+      # @param rcpt_lst_field  [String] The field in structure, i.e. recipients or bcc_recipients
+      # @param new_user_option [Hash]   Additionnal fields for contact creation
+      # @return nil, `package_data` is modified
+      def resolve_package_recipients(package_data, rcpt_lst_field, new_user_option)
+        return unless package_data.key?(rcpt_lst_field)
+        Aspera.assert_type(package_data[rcpt_lst_field], Array){rcpt_lst_field}
         new_user_option = {'package_contact' => true} if new_user_option.nil?
         Aspera.assert_type(new_user_option, Hash){'new_user_option'}
+        ws_id = package_data['workspace_id']
         # list with resolved elements
         resolved_list = []
-        package_data[recipient_list_field].each do |short_recipient_info|
+        package_data[rcpt_lst_field].each do |short_recipient_info|
           case short_recipient_info
           when Hash # native API information, check keys
-            Aspera.assert(short_recipient_info.keys.sort.eql?(%w[id type])){"#{recipient_list_field} element shall have fields: id and type"}
+            Aspera.assert(short_recipient_info.keys.sort.eql?(%w[id type])){"#{rcpt_lst_field} element shall have fields: id and type"}
           when String # CLI helper: need to resolve provided name to type/id
             # email: user, else dropbox
             entity_type = short_recipient_info.include?('@') ? 'contacts' : 'dropboxes'
             begin
               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)
+            rescue EntityNotFound
               # dropboxes cannot be created on the fly
-              raise "No such shared inbox in workspace #{ws_id}" if entity_type.eql?('dropboxes')
+              Aspera.assert_values(entity_type, 'contacts', type: Error){"No such shared inbox in workspace #{ws_id}"}
               # unknown user: create it as external user
               full_recipient_info = create('contacts', {
                 'current_workspace_id' => ws_id,
@@ -465,14 +504,13 @@ module Aspera
             else
               {'id' => full_recipient_info['source_id'], 'type' => full_recipient_info['source_type']}
             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)"
+          else Aspera.error_unexpected_value(short_recipient_info.class.name){"#{rcpt_lst_field} item must be a String (email, shared inbox) or Hash (id,type)"}
           end
           # add original or resolved recipient info
           resolved_list.push(short_recipient_info)
         end
         # replace with resolved elements
-        package_data[recipient_list_field] = resolved_list
+        package_data[rcpt_lst_field] = resolved_list
         return
       end
 
@@ -505,8 +543,8 @@ module Aspera
         # package_data['file_names']||=[..list of filenames to transfer...]
 
         # lookup users
-        resolve_package_recipients(package_data, package_data['workspace_id'], 'recipients', new_user_option)
-        resolve_package_recipients(package_data, package_data['workspace_id'], 'bcc_recipients', new_user_option)
+        resolve_package_recipients(package_data, 'recipients', new_user_option)
+        resolve_package_recipients(package_data, 'bcc_recipients', new_user_option)
 
         validate_metadata(package_data) if validate_meta
 
@@ -622,8 +660,7 @@ module Aspera
         when NilClass
         when ''
           # workspace shared folder
-          perm_data['access_type'] = 'user'
-          perm_data['access_id'] = "#{ID_AK_ADMIN}_WS_#{app_info[:workspace_id]}"
+          perm_data.merge!(self.class.workspace_access(app_info[:workspace_id]))
           tag_workspace['shared_with_name'] = perm_data['access_id']
         else
           entity_info = lookup_by_name('contacts', shared_with, query: {'current_workspace_id' => app_info[:workspace_id]})

data/lib/aspera/api/ats.rb

@@ -5,6 +5,7 @@ require 'aspera/rest'
 
 module Aspera
   module Api
+    # ATS API without authentication
     class Ats < Aspera::Rest
       SERVICE_BASE_URL = 'https://ats.aspera.io'
       # currently supported clouds

data/lib/aspera/api/cos_node.rb

@@ -55,8 +55,9 @@ module Aspera
           operation: 'GET',
           subpath:   bucket,
           headers:   {'Accept' => 'application/xml'},
-          query:     {'faspConnectionInfo' => nil}
-        )[:http].body
+          query:     {'faspConnectionInfo' => nil},
+          ret:       :resp
+        ).body
         ats_info = XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
         Log.dump(:ats_info, ats_info)
         @storage_credentials = {

data/lib/aspera/api/faspex.rb

@@ -28,24 +28,25 @@ module Aspera
 
     def create_token
       # Exchange context (passcode) for code
-      resp = api.call(
+      http = api.call(
         operation: 'GET',
         subpath:   @path_authorize,
         query: {
           response_type: :code,
           state:         @context,
-          client_id:     client_id,
+          client_id:     params[:client_id],
           redirect_uri:  @redirect_uri
         },
-        exception: false
+        exception: false,
+        ret:       :resp
       )
       # code / state located in redirected URL query
-      info = Rest.query_to_h(URI.parse(resp[:http]['Location']).query)
+      info = Rest.query_to_h(URI.parse(http['Location']).query)
       Log.dump(:info, info)
       raise Error, info['action_message'] if info['action_message']
       Aspera.assert(info['code']){'Missing code in answer'}
       # Exchange code for token
-      return create_token_call(optional_scope_client_id.merge(
+      return create_token_call(base_params.merge(
         grant_type:   'authorization_code',
         code:         info['code'],
         redirect_uri: @redirect_uri
@@ -133,7 +134,7 @@ module Aspera
           case auth
           when :public_link
             # Get URL of final redirect of public link
-            redir_url = Rest.new(base_url: url, redirect_max: 3).call(operation: 'GET')[:http].uri.to_s
+            redir_url = Rest.new(base_url: url, redirect_max: 3).call(operation: 'GET', ret: :resp).uri.to_s
             Log.dump(:redir_url, redir_url, level: :trace1)
             # get context from query
             encoded_context = Rest.query_to_h(URI.parse(redir_url).query)['context']
@@ -145,7 +146,7 @@ module Aspera
             base_url = redir_url.gsub(%r{/public/.*}, '').gsub(/\?.*/, '')
             # Get web UI client_id and redirect_uri
             # TODO: change this for something more reliable
-            config = JSON.parse(Rest.new(base_url: "#{base_url}/config.js", redirect_max: 3).call(operation: 'GET')[:data].sub(/^[^=]+=/, '').gsub(/([a-z_]+):/, '"\1":').delete("\n ").tr("'", '"')).symbolize_keys
+            config = JSON.parse(Rest.new(base_url: "#{base_url}/config.js", redirect_max: 3).call(operation: 'GET').sub(/^[^=]+=/, '').gsub(/([a-z_]+):/, '"\1":').delete("\n ").tr("'", '"')).symbolize_keys
             Log.dump(:configjs, config)
             {
               base_url: "#{base_url}/#{PATH_API_V5}",
@@ -154,7 +155,9 @@ module Aspera
                 base_url:     "#{base_url}/#{PATH_AUTH}",
                 grant_method: :faspex_pub_link,
                 context:      encoded_context,
-                client_id:    config[:client_id],
+                params:       {
+                  client_id: config[:client_id]
+                },
                 redirect_uri: config[:redirect_uri]
               }
             }
@@ -176,7 +179,9 @@ module Aspera
                 type:         :oauth2,
                 base_url:     "#{url}/#{PATH_AUTH}",
                 grant_method: :web,
-                client_id:    client_id,
+                params:       {
+                  client_id: client_id
+                },
                 redirect_uri: redirect_uri
               }
             }
@@ -189,7 +194,9 @@ module Aspera
                 type:            :oauth2,
                 base_url:        "#{url}/#{PATH_AUTH}",
                 grant_method:    :jwt,
-                client_id:       client_id,
+                params:          {
+                  client_id: client_id
+                },
                 payload:         {
                   iss: client_id, # issuer
                   aud: client_id, # audience (this field is not clear...)

data/lib/aspera/api/node.rb

@@ -386,21 +386,19 @@ module Aspera
         return oauth.authorization(refresh: true)
       end
 
+      # Get a base download transfer spec (gen3)
+      # @return [Hash] Base transfer spec
+      def base_spec
+        create(
+          'files/download_setup',
+          {transfer_requests: [{transfer_request: {paths: [{source: '/'}]}}]}
+        )['transfer_specs'].first['transfer_spec']
+      end
+
       # Get generic part of transfer spec with transport parameters only
       # @return [Hash] Base transfer spec
       def transport_params
-        if @std_t_spec_cache.nil?
-          # Retrieve values from API (and keep a copy/cache)
-          full_spec = create(
-            'files/download_setup',
-            {transfer_requests: [{transfer_request: {paths: [{source: '/'}]}}]}
-          )['transfer_specs'].first['transfer_spec']
-          # Set available fields
-          @std_t_spec_cache = Transfer::Spec::TRANSPORT_FIELDS.each_with_object({}) do |i, h|
-            h[i] = full_spec[i] if full_spec.key?(i)
-          end
-        end
-        return @std_t_spec_cache
+        @std_t_spec_cache ||= base_spec.slice(*Transfer::Spec::TRANSPORT_FIELDS).freeze
       end
 
       # Create transfer spec for gen4

data/lib/aspera/ascmd.rb

@@ -89,13 +89,12 @@ module Aspera
     # Version 2 allows use of reverse proxy with multiple addresses.
     # @param [Symbol] one of OPERATIONS
     # @param [Array] parameters for "as" command
-    # @return result of command, type depends on command (bool, array, hash)
+    # @return [Boolean,Array,Hash] result of command, type depends on command
     def execute_single(action_sym, arguments, version: 1, host: nil)
       arguments = [] if arguments.nil?
       Log.log.debug{"execute_single:#{action_sym}:#{arguments}"}
       Aspera.assert_type(action_sym, Symbol)
-      Aspera.assert_type(arguments, Array)
-      Aspera.assert(arguments.all?(String), 'arguments must be strings')
+      Aspera.assert_array_all(arguments, String){'arguments'}
       remote_cmd = 'ascmd'
       # lines of commands (String's)
       command_lines = []