aspera-cli 4.27.2 → 4.27.4

data/lib/aspera/api/httpgw.rb

@@ -9,8 +9,10 @@ require 'securerandom'
 require 'websocket'
 require 'base64'
 require 'json'
+require 'aspera/rainbow'
+using Rainbow
 
-# throw exception on error, instead of error code
+# Throw exception on error, instead of error code
 WebSocket.should_raise = true
 
 module Aspera
@@ -29,7 +31,7 @@ module Aspera
     #   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 < Aspera::Rest
+    class Httpgw < Aspera::Rest::Client
       DEFAULT_BASE_PATH = '/aspera/http-gwy'
       INFO_ENDPOINT = 'info'
       MSG_SEND_TRANSFER_SPEC = 'transfer_spec'
@@ -40,27 +42,24 @@ module Aspera
       API_V1 = 'v1'
       API_V2 = 'v2'
       THR_RECV = 'recv'
-      LOG_WS_SEND = 'ws: send: '.red
-      LOG_WS_RECV = "ws: #{THR_RECV}: ".green
       private_constant :MSG_RECV_DATA_RECEIVED_SIGNAL, :MSG_RECV_SLICE_UPLOAD_SIGNAL
-      # send message on http gw web socket
+
+      # Send message on http gw web socket
+      # @param msg_type [String] type of message to send
+      # @param payload [Hash] Data to send
       def ws_snd_json(msg_type, payload)
         if msg_type.eql?(MSG_SEND_SLICE_UPLOAD) && @upload_version.eql?(API_V2)
           @shared_info[:count][:sent_v2_delimiter] += 1
         else
           @shared_info[:count][:sent_general] += 1
         end
-        Log.log.trace1 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
+        Log.dump("#{log_ws_send} #{msg_type}", level: :trace1) { payload.dup.tap { |d| d[:data] = "[data #{d[:data].length} bytes]" if d.key?(:data) } }
         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.trace1 { "#{LOG_WS_SEND}sending: #{ws_type} (#{data&.length || 0} bytes)" }
+        Log.log.trace1 { "#{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)
@@ -72,12 +71,12 @@ module Aspera
                 @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))
-              Log.log.trace1 { "#{LOG_WS_SEND}#{'timeout'.blue}: #{@shared_info[:count]}" } if !@shared_info[:cond_var].wait(@shared_info[:mutex], 2.0)
+              Log.log.trace1 { "#{log_ws_send}#{'timeout'.blue}: #{@shared_info[:count]}" } if !@shared_info[:cond_var].wait(@shared_info[:mutex], 2.0)
             end
           end
         end
         raise @shared_info[:read_exception] unless @shared_info[:read_exception].nil?
-        Log.log.trace2 { "#{LOG_WS_SEND}counts: #{@shared_info[:count]}" }
+        Log.log.trace2 { "#{log_ws_send}counts: #{@shared_info[:count]}" }
       end
 
       # Check header ourself and give precise error message, as websocket will only throw error without details
@@ -85,13 +84,13 @@ module Aspera
       # @return [String] Response Header
       def validated_ws_response_header(header)
         first_line = header.split("\r\n").first
-        raise RestCallError.new({messages: ["Unexpected: #{first_line}", 'Expected: 101 Switching Protocols']}) unless first_line.split(/\s+/, 3)[1].eql?('101')
+        raise Rest::CallError.new({messages: ["Unexpected: #{first_line}", 'Expected: 101 Switching Protocols']}) unless first_line.split(/\s+/, 3)[1].eql?('101')
         header
       end
 
       # message processing for read thread
       def process_received_message(message)
-        Log.log.debug { "#{LOG_WS_RECV}message: [#{message}] (#{message.class})" }
+        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
@@ -117,23 +116,23 @@ module Aspera
         end
       end
 
-      # main function of read thread
+      # Main function of read thread
       def process_read_thread
-        Log.log.debug { "#{LOG_WS_RECV}read thread started" }
+        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
             # ready byte by byte until frame is ready
             # blocking read
             byte = @ws_io.read(1)
-            Log.log.trace2 { "#{LOG_WS_RECV}read: #{byte} (#{byte.class}) eof=#{@ws_io.eof?}" }
+            Log.log.trace2 { "#{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.trace2 { "#{LOG_WS_RECV}counts: #{@shared_info[:count]}" }
+            Log.log.trace2 { "#{log_ws_recv}counts: #{@shared_info[:count]}" }
           rescue => e
-            Log.log.debug { "#{LOG_WS_RECV}Exception: #{e}" }
+            Log.log.debug { "#{log_ws_recv}Exception: #{e}" }
             @shared_info[:mutex].synchronize do
               @shared_info[:read_exception] = e
               @shared_info[:cond_var].signal
@@ -142,9 +141,9 @@ module Aspera
           end
         end
         Log.log.debug do
-          "#{LOG_WS_RECV}exception: #{@shared_info[:read_exception]},cls=#{@shared_info[:read_exception].class})"
+          "#{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?})" }
+        Log.log.debug { "#{log_ws_recv}read thread stopped (ws eof=#{@ws_io.eof?})" }
       end
 
       def upload(transfer_spec)
@@ -170,7 +169,7 @@ module Aspera
         # Get whole HTTP response header, Check and process
         # no need to check `finished?` or result of `<<` (true), as we give the whole header at once
         @ws_handshake << validated_ws_response_header(@ws_io.readuntil("\r\n\r\n"))
-        Log.log.debug { "#{LOG_WS_SEND}handshake success" }
+        Log.log.debug { "#{log_ws_send}handshake success" }
         # data shared between main thread and read thread
         @shared_info = {
           read_exception: nil, # error message if any in callback
@@ -224,7 +223,7 @@ module Aspera
                   # 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.trace1 { "#{LOG_WS_SEND}buffer: file: #{file_index}, slice: #{slice_info[:slice]}/#{last_slice}" }
+                  Log.log.trace1 { "#{log_ws_send}buffer: file: #{file_index}, slice: #{slice_info[:slice]}/#{last_slice}" }
                   # send once, after data, at end
                   ws_snd_json(MSG_SEND_SLICE_UPLOAD, slice_info) if slice_info[:slice].eql?(last_slice)
                 end
@@ -255,12 +254,11 @@ module Aspera
         # session no more used
         @ws_io = nil
         http_session&.finish
-        @notify_cb&.call(:end)
       end
 
       def download(transfer_spec)
         transfer_spec['source_root'] ||= '/'
-        default_file_name = transfer_spec['paths'].first['source']
+        default_file_name = transfer_spec['paths'].first&.fetch('source')
         source_is_folder = %w[. /].include?(default_file_name)
         default_file_name = 'http_download' if source_is_folder
         transfer_spec['zip_required'] ||= source_is_folder || transfer_spec['paths'].length > 1
@@ -283,17 +281,20 @@ module Aspera
             # it is a plain file if we don't require zip and there is only one file
             File.basename(default_file_name)
           end
-        file_path = File.join(transfer_spec['destination_root'], file_name)
-        call(operation: 'GET', subpath: "download/#{transfer_uuid}", save_to: file_path)
+        call(
+          operation: 'GET',
+          subpath: "download/#{transfer_uuid}",
+          save_to: File.join(transfer_spec['destination_root'], file_name)
+        )
       end
 
       def info
-        return @api_info
+        @api_info
       end
 
       # @return [String] the base url of the gateway
       def base_url
-        return @gw_root_url
+        @gw_root_url
       end
 
       # @param url [String] URL of the HTTP Gateway, without version
@@ -306,10 +307,10 @@ module Aspera
         **opts
       )
         Log.dump(:gw_url, url)
-        # add scheme if missing
+        # Add scheme if missing
         url = "https://#{url}" unless url.match?(%r{^[a-z]{1,6}://})
         Aspera.assert(url.start_with?('https://'), type: Error) { 'GW URL shall be with scheme https' }
-        # remove trailing slash and version (o=only once) if present
+        # Remove trailing slash and version (o=only once) if present
         # TODO: issue warning ?
         url = url.chomp('/').gsub(%r{/#{API_V1}$}o, '')
         # assume GW is always under specific path (TODO: remove this ?)
@@ -339,6 +340,10 @@ module Aspera
 
       private
 
+      # Log prefixes (evaluated on each call, as colors can be enabled or disabled by option)
+      def log_ws_send = 'ws: send: '.red
+      def log_ws_recv = "ws: #{THR_RECV}: ".green
+
       # compute total size of files to upload (for progress)
       # modify transfer spec to be suitable for HTTPGW
       # @param transfer_spec [Hash] transfer specification
@@ -372,8 +377,7 @@ module Aspera
             until folders_to_process.empty?
               folder = folders_to_process.shift
               # read all entries
-              Dir.entries(folder).each do |entry|
-                next if entry.eql?('.') || entry.eql?('..')
+              Dir.each_child(folder) do |entry|
                 entry_path = File.join(folder, entry)
                 if File.directory?(entry_path)
                   folders_to_process.push(entry_path)
@@ -396,7 +400,6 @@ module Aspera
         end
         transfer_spec['paths'] = files_to_send.map { |i| {'source' => i[:name]} }
         files_to_send.push(total_bytes_to_transfer)
-        return files_to_send
       end
     end
   end

data/lib/aspera/api/node.rb

@@ -12,6 +12,8 @@ require 'openssl'
 require 'pathname'
 require 'zlib'
 require 'net/ssh/buffer'
+require 'aspera/rainbow'
+using Rainbow
 
 module Aspera
   module Api
@@ -33,7 +35,7 @@ module Aspera
 
     # Aspera Node API client
     # with gen4 extensions (access keys)
-    class Node < Rest
+    class Node < Rest::Client
       # Format of node scope : node.<access key>:<scope>
       module Scope
         # Node sub-scopes
@@ -42,6 +44,26 @@ module Aspera
         # Separator between node.AK and user:all
         SEPARATOR = ':'
         NODE_PREFIX = 'node.'
+
+        extend self
+
+        # Encode node API scope
+        # @param access_key [String] Access Key
+        # @param scope [String] internal scope
+        # @return [String] full node scope
+        def join(access_key:, scope:)
+          ["#{NODE_PREFIX}#{access_key}", scope].join(SEPARATOR)
+        end
+
+        # Decode node scope into access key and scope
+        # @param scope [String] scope string to split
+        # @return [Hash] decoded scope with access key and scope parts
+        def split(scope)
+          items = scope.split(Scope::SEPARATOR, 2)
+          Aspera.assert(items.length.eql?(2)) { "invalid scope: #{scope}" }
+          Aspera.assert(items[0].start_with?(NODE_PREFIX)) { "invalid scope: #{scope}" }
+          {access_key: items[0].delete_prefix(NODE_PREFIX), scope: items[1]}
+        end
       end
       # Delimiter in decoded node token
       SIGNATURE_DELIMITER = '==SIGNATURE=='
@@ -54,10 +76,10 @@ module Aspera
       HEADER_X_ASPERA_ACCESS_KEY = 'X-Aspera-AccessKey'
       HEADER_X_CACHE_CONTROL = 'X-Aspera-Cache-Control'
       HEADER_X_NEXT_ITER_TOKEN = 'X-Aspera-Next-Iteration-Token'
+      HEADER_X_TOTAL_COUNT = 'X-Total-Count'
       HEADER_ACCEPT_VERSION = 'Accept-Version'
       # / in cloud
       PATH_SEPARATOR = '/'
-      HEADER_X_TOTAL_COUNT = 'X-Total-Count'
 
       # Register node special token decoder
       OAuth::Factory.instance.register_decoder(lambda { |token| Node.decode_bearer_token(token) })
@@ -133,22 +155,6 @@ module Aspera
           [folder.join(PATH_SEPARATOR), inside]
         end
 
-        # Node API scopes
-        # @return [String] node scope
-        def token_scope(access_key, scope)
-          return [Scope::NODE_PREFIX, access_key, Scope::SEPARATOR, scope].join('')
-        end
-
-        # Decode node scope into access key and scope
-        # @param scope [String] scope string to decode
-        # @return [Hash] decoded scope with access key and scope parts
-        def decode_scope(scope)
-          items = scope.split(Scope::SEPARATOR, 2)
-          Aspera.assert(items.length.eql?(2)) { "invalid scope: #{scope}" }
-          Aspera.assert(items[0].start_with?(Scope::NODE_PREFIX)) { "invalid scope: #{scope}" }
-          return {access_key: items[0].delete_prefix(Scope::NODE_PREFIX), scope: items[1]}
-        end
-
         # Create an Aspera Node bearer token
         # @param access_key [String] Access key identifier
         # @param payload [String] JSON payload to be included in the token
@@ -162,9 +168,8 @@ module Aspera
           # Manage convenience parameters
           expiration_sec = payload['_validity'] || BEARER_TOKEN_VALIDITY_DEFAULT
           payload.delete('_validity')
-          scope = payload['_scope'] || Scope::USER
-          payload.delete('_scope')
-          payload['scope'] ||= token_scope(access_key, scope)
+          scope = payload.delete('_scope') || Scope::USER
+          payload['scope'] ||= Scope.join(access_key: access_key, scope: scope)
           payload['auth_type'] ||= 'access_key'
           payload['expires_at'] ||= (Time.now + expiration_sec).utc.strftime('%FT%TZ')
           payload_json = JSON.generate(payload)
@@ -185,7 +190,7 @@ module Aspera
         def bearer_headers(bearer_auth, access_key: nil)
           # If username is not provided, use the access key from the token
           if access_key.nil?
-            access_key = Node.decode_scope(Node.decode_bearer_token(OAuth::Factory.bearer_token(bearer_auth))['scope'])[:access_key]
+            access_key = Node::Scope.split(Node.decode_bearer_token(OAuth::Factory.bearer_token(bearer_auth))['scope'])[:access_key]
             Aspera.assert(!access_key.nil?, 'access_key could not be determined from token')
           end
           return {
@@ -233,7 +238,7 @@ module Aspera
         end
         Log.log.warn { "Cannot resolve link with node id #{node_id}, no resolver" }
         return
-      rescue RestCallError => e
+      rescue Rest::CallError => e
         Log.log.warn { "Cannot resolve link with node id #{node_id}: #{e.message}" }
         return
       end
@@ -287,7 +292,7 @@ module Aspera
             query['page'] = 0
           end
           loop do
-            RestParameters.instance.spinner_cb.call(folder_items.count)
+            Rest::Parameters.instance.spinner_cb.call(folder_items.count)
             data, http = read("files/#{file_id}/files", query, headers: headers, ret: :both)
             folder_items.concat(data)
             if use_v4
@@ -304,7 +309,7 @@ module Aspera
           Log.log.warn { "#{path || file_id}: #{e.class} #{e.message}" }
           Log.log.debug { (['Backtrace:'] + e.backtrace).join("\n") }
         ensure
-          RestParameters.instance.spinner_cb.call(folder_items.count, action: :success)
+          Rest::Parameters.instance.spinner_cb.call(folder_items.count, action: :success)
         end
         folder_items
       end
@@ -326,7 +331,7 @@ module Aspera
         until folders_to_explore.empty?
           # Consume first in job list
           current_item = folders_to_explore.shift
-          Log.log.debug { "Exploring #{current_item[:path]}".bg_green }
+          Log.log.debug { "Exploring #{current_item[:path]}".bg(:green) }
           # Get folder content
           folder_contents = read_folder_content(current_item[:id], query, exception: false, path: current_item[:path])
           Log.dump(:folder_contents, folder_contents)
@@ -452,7 +457,7 @@ module Aspera
         create(
           'files/download_setup',
           {transfer_requests: [{transfer_request: {paths: [{source: '/'}]}}]}
-        )['transfer_specs'].first['transfer_spec']
+        )['transfer_specs'].first&.fetch('transfer_spec')
       end
 
       # Get generic part of transfer spec with transport parameters only
@@ -527,7 +532,7 @@ module Aspera
 
       # Executes `GET` call in loop using `iteration_token` (`/ops/transfers`)
       # @param iteration [Array]   a single element array with the iteration token or nil
-      # @param call_args [Hash]    additional arguments to pass to `Rest.call`
+      # @param call_args [Hash]    additional arguments to pass to `Rest::Client#call`
       # @return [Array] list of items returned by the API call
       def read_with_paging(subpath, query = nil, iteration: nil, **call_args)
         Aspera.assert_type(iteration, Array, NilClass) { 'iteration' }
@@ -535,7 +540,7 @@ module Aspera
         Aspera.assert(!call_args.key?(:query), ':query must not be in call_args (use query parameter)')
         query = {} if query.nil?
         query[:iteration_token] = iteration[0] unless iteration.nil? || iteration[0].nil?
-        max = query.delete(RestList::MAX_ITEMS)
+        max = query.delete(Rest::List::MAX_ITEMS)
         # Return empty list immediately if max is 0
         return [] if max&.zero?
         item_list = []
@@ -551,7 +556,7 @@ module Aspera
             break
           end
           # Update progress spinner
-          RestParameters.instance.spinner_cb.call(item_list.length)
+          Rest::Parameters.instance.spinner_cb.call(item_list.length)
           # Parse Link header according to RFC 8288 to extract next iteration token
           next_url = LinkHeader.parse(http['Link']).find_href(rel: 'next')
           next_iteration_token = nil
@@ -572,7 +577,7 @@ module Aspera
           query[:iteration_token] = next_iteration_token
         end
         # Signal completion
-        RestParameters.instance.spinner_cb.call(action: :success)
+        Rest::Parameters.instance.spinner_cb.call(action: :success)
         # save iteration token if needed
         iteration[0] = query[:iteration_token] unless iteration.nil?
         item_list
@@ -582,7 +587,7 @@ module Aspera
       #
       # @param subpath [String] API Path
       # @param query [Hash, nil] Optional query parameters for the API request
-      # @param kwargs [Hash] Other parameters for Rest.read
+      # @param kwargs [Hash] Other parameters for Rest::Client#read
       #
       # @return [Array<Hash>] List of folder entries (files, folders, links)
       def read_with_pages(subpath, query = nil, **kwargs)
@@ -592,7 +597,7 @@ module Aspera
         query['page'] ||= 1
         suffix = nil
         loop do
-          RestParameters.instance.spinner_cb.call("#{items.count}#{suffix}")
+          Rest::Parameters.instance.spinner_cb.call("#{items.count}#{suffix}")
           data, http = read(subpath, query, **kwargs, ret: :both)
           items.concat(data)
           break if data.length < query['per_page']
@@ -603,7 +608,7 @@ module Aspera
         Log.log.warn { "#{e.class} #{e.message}" }
         Log.log.debug { (['Backtrace:'] + e.backtrace).join("\n") }
       ensure
-        RestParameters.instance.spinner_cb.call(items.count, action: :success)
+        Rest::Parameters.instance.spinner_cb.call(items.count, action: :success)
         return items # rubocop:disable Lint/EnsureReturn
       end
 

data/lib/aspera/ascmd.rb

@@ -3,9 +3,11 @@
 # cspell:ignore ascmd smode errstr zstr zmode zuid zgid zctime zatime zmtime fcount dcount btype blist codeset lc_ctype ascmdtypes
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/rainbow'
+using Rainbow
 
 module Aspera
-  # Run +ascmd+ commands using specified executor (usually, remotely on transfer node)
+  # Run `ascmd` commands using specified executor (usually, remotely on transfer node)
   # Equivalent of SDK "command client"
   # execute: "ascmd -h" to get syntax
   # Note: "ls" can take filters: as_ls -f *.txt -f *.bin /

data/lib/aspera/ascp/installation.rb

@@ -42,6 +42,14 @@ module Aspera
       # policy for product selection
       FIRST_FOUND = 'FIRST'
 
+      class << self
+        # @param value [String, nil] value of option `sdk_folder`
+        # @return [Boolean] true if value selects a product instead of a folder
+        def product_selector?(value)
+          value.is_a?(String) && value.start_with?(USE_PRODUCT_PREFIX)
+        end
+      end
+
       # Loads YAML from cloud with locations of SDK archives for all platforms
       # @return [Hash] location structure
       def sdk_locations
@@ -55,30 +63,25 @@ module Aspera
         end
       end
 
-      # Set `ascp` executable "location"
+      # Set `ascp` executable "location" (option `sdk_folder`)
       # It can be:
-      # - Full path to folder where `ascp` executable is located
-      # - "product:PRODUCT_NAME" to use ascp from named product
+      # - Full path to folder where `ascp` executable is located, also used as SDK folder (keys, conf)
+      # - "product:PRODUCT_NAME" to use ascp from named product, SDK folder stays the default one
       # - "product:FIRST" to use ascp from first found product
+      # @param ascp_location [String] folder or product selector
+      # @return [nil]
       def sdk_folder=(ascp_location)
         Aspera.assert_type(ascp_location, String) { 'ascp_location' }
         Aspera.assert(!ascp_location.empty?, 'ascp location cannot be empty: check your config file')
-        folder =
-          if ascp_location.start_with?(USE_PRODUCT_PREFIX)
-            product_name = ascp_location.delete_prefix(USE_PRODUCT_PREFIX)
-            if product_name.eql?(FIRST_FOUND)
-              pl = installed_products.first
-              Aspera.assert(!pl.nil?) { "No Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf transferd install" }
-            else
-              pl = installed_products.find { |i| i[:name].eql?(product_name) }
-              Aspera.assert(!pl.nil?) { "No such product installed: #{product_name}" }
-            end
-            File.dirname(pl[:ascp_path])
-          else
-            ascp_location.include?('/ascp') ? File.dirname(ascp_location) : ascp_location
-          end
-        Log.log.debug { "ascp_folder=#{folder}" }
-        Products::Transferd.sdk_directory = folder
+        @ascp_folder = nil
+        if self.class.product_selector?(ascp_location)
+          # Resolved on first use: product scan requires the SDK folder, which is set later
+          @ascp_product = ascp_location.delete_prefix(USE_PRODUCT_PREFIX)
+          Log.log.debug { "ascp_product=#{@ascp_product}" }
+        else
+          @ascp_product = nil
+          Products::Transferd.sdk_directory = ascp_location.include?('/ascp') ? File.dirname(ascp_location) : ascp_location
+        end
         nil
       end
 
@@ -114,8 +117,9 @@ module Aspera
         case file_type
         when *EXE_FILES
           file_is_required = file_type.eql?(:ascp)
-          file = Products::Transferd.transferd_path
-          file = File.join(File.dirname(file), Environment.instance.exe_file(file_type.to_s)) unless file_type.eql?(:transferd)
+          file = sdk_exe_path(file_type)
+          # transferd always comes from SDK
+          file = File.join(product_ascp_folder, File.basename(file)) unless @ascp_product.nil? || file_type.eql?(:transferd)
         when :ssh_private_dsa, :ssh_private_rsa
           # assume last 3 letters are type
           type = file_type.to_s[-3..].to_sym
@@ -282,7 +286,7 @@ module Aspera
         end
       end
 
-      # Downloads and extracts the SDK archive for the current platform into +folder+
+      # Downloads and extracts the SDK archive for the current platform into `folder`
       # @param folder  [String]      Destination folder path
       # @param url     [nil, String] URL to SDK archive, if nil: default url for version
       # @param version [nil, String] Specific version, if nil: latest version
@@ -306,9 +310,9 @@ module Aspera
         if UriReader.file?(url)
           archive_io.write(File.binread(UriReader.file_path(url)))
         else
-          Rest.new(base_url: url, redirect_max: 3).call(operation: 'GET', save_to: archive_io)
-          archive_io.rewind
+          Rest::Client.new(base_url: url, redirect_max: 3).call(operation: 'GET', save_to: archive_io)
         end
+        archive_io.rewind
         extract_archive_files(url, archive_io) do |entry_name, entry_stream, link_target|
           dest_folder = if block_given?
             yield(entry_name)
@@ -385,10 +389,13 @@ module Aspera
         folder = Products::Transferd.sdk_directory
         download_sdk(folder: folder, url: url, version: version)
         # Ensure necessary files are there, or generate them, restrict file access on SDK executables
+        # (executables of SDK, even if `ascp` of another product is selected)
         SDK_FILES.each do |file_id_sym|
-          file_path = path(file_id_sym)
-          if file_path && EXE_FILES.include?(file_id_sym)
+          if EXE_FILES.include?(file_id_sym)
+            file_path = sdk_exe_path(file_id_sym)
             Environment.restrict_file_access(file_path, mode: 0o755) if File.exist?(file_path)
+          else
+            path(file_id_sym)
           end
         end
         # Generate meta data XML file in SDK if needed, based on actual binaries versions
@@ -399,8 +406,8 @@ module Aspera
           sdk_name = meta_data.scan(%r{<name>(.*?)</name>}).flatten.first || 'unknown'
           sdk_version = meta_data.scan(%r{<version>(.*?)</version>}).flatten.first || 'unknown'
         else
-          sdk_ascp_version = get_ascp_version(path(:ascp))
-          transferd_version = get_exe_version(path(:transferd), 'version')
+          sdk_ascp_version = get_ascp_version(sdk_exe_path(:ascp))
+          transferd_version = get_exe_version(sdk_exe_path(:transferd), 'version')
           sdk_name = 'IBM Aspera Transfer SDK'
           sdk_version = transferd_version || sdk_ascp_version
           File.write(meta_data_file, "<product><name>#{sdk_name}</name><version>#{sdk_version}</version></product>")
@@ -435,6 +442,34 @@ module Aspera
         # cache for installed products found
         @found_products = nil
         @transferd_urls = TRANSFERD_ARCHIVE_LOCATION_URL
+        # product selected with option `sdk_folder`, or nil to use SDK folder
+        @ascp_product = nil
+        # cache for folder of `ascp` of selected product
+        @ascp_folder = nil
+      end
+
+      # @param file_type [Symbol] one of EXE_FILES
+      # @return [String] path to executable in SDK folder
+      def sdk_exe_path(file_type)
+        file = Products::Transferd.transferd_path
+        file = File.join(File.dirname(file), Environment.instance.exe_file(file_type.to_s)) unless file_type.eql?(:transferd)
+        return file
+      end
+
+      # @return [String] folder of `ascp` of product selected with option `sdk_folder`
+      def product_ascp_folder
+        if @ascp_folder.nil?
+          if @ascp_product.eql?(FIRST_FOUND)
+            pl = installed_products.first
+            Aspera.assert(!pl.nil?) { "No Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli config ascp install" }
+          else
+            pl = installed_products.find { |i| i[:name].eql?(@ascp_product) }
+            Aspera.assert(!pl.nil?) { "No such product installed: #{@ascp_product}" }
+          end
+          @ascp_folder = File.dirname(pl[:ascp_path])
+          Log.log.debug { "ascp_folder=#{@ascp_folder}" }
+        end
+        return @ascp_folder
       end
 
       public

data/lib/aspera/ascp/management.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/assert'
+require 'aspera/string_ext'
 
 module Aspera
   module Ascp

data/lib/aspera/assert.rb

@@ -17,6 +17,10 @@ module Aspera
   class AssertError < Error
   end
 
+  # Raised when a looked up entity is not found
+  class EntityNotFound < Error
+  end
+
   class << self
     # Replaces `raise` in assertion
     # Allows sending exception, or just error log, when type is `:error`