aspera-cli 4.19.0 → 4.20.0

data/lib/aspera/api/node.rb

@@ -33,6 +33,8 @@ module Aspera
       ACCESS_LEVELS = %w[delete list mkdir preview read rename write].freeze
       HEADER_X_ASPERA_ACCESS_KEY = 'X-Aspera-AccessKey'
       HEADER_X_TOTAL_COUNT = 'X-Total-Count'
+      HEADER_X_CACHE_CONTROL = 'X-Aspera-Cache-Control'
+      HEADER_X_NEXT_ITER_TOKEN = 'X-Aspera-Next-Iteration-Token'
       SCOPE_USER = 'user:all'
       SCOPE_ADMIN = 'admin:all'
       PATH_SEPARATOR = '/'
@@ -42,9 +44,17 @@ module Aspera
 
       # class instance variable, access with accessors on class
       @use_standard_ports = true
+      @use_node_cache = true
 
       class << self
         attr_accessor :use_standard_ports
+        attr_accessor :use_node_cache
+
+        def cache_control_headers
+          h = {'Accept' => 'application/json'}
+          h[HEADER_X_CACHE_CONTROL] = 'no-cache' unless use_node_cache
+          h
+        end
 
         # For access keys: provide expression to match entry in folder
         def file_matcher(match_expression)
@@ -146,6 +156,11 @@ module Aspera
         end
       end
 
+      # Call node API, possibly adding cache control header, as globally specified
+      def read_with_cache(subpath, query=nil)
+        return call(operation: 'GET', subpath: subpath, headers: self.class.cache_control_headers, query: query)[:data]
+      end
+
       # update transfer spec with special additional tags
       def add_tspec_info(tspec)
         tspec.deep_merge!(@add_tspec) unless @add_tspec.nil?
@@ -171,7 +186,7 @@ module Aspera
       def entry_has_link_information(entry)
         # if target information is missing in folder, try to get it on entry
         if entry['target_node_id'].nil? || entry['target_id'].nil?
-          link_entry = read("files/#{entry['id']}")[:data]
+          link_entry = read("files/#{entry['id']}")
           entry['target_node_id'] = link_entry['target_node_id']
           entry['target_id'] = link_entry['target_id']
         end
@@ -200,13 +215,19 @@ module Aspera
           # get folder content
           folder_contents =
             begin
-              read("files/#{current_item[:id]}/files")[:data]
+              read("files/#{current_item[:id]}/files")
             rescue StandardError => e
               Log.log.warn{"#{current_item[:path]}: #{e.class} #{e.message}"}
               []
             end
           Log.log.debug{Log.dump(:folder_contents, folder_contents)}
           folder_contents.each do |entry|
+            if entry.key?('error')
+              if entry['error'].is_a?(Hash) && entry['error'].key?('user_message')
+                Log.log.error(entry['error']['user_message'])
+              end
+              next
+            end
             relative_path = File.join(current_item[:path], entry['name'])
             Log.log.debug{"process_folder_tree: checking #{relative_path}"}
             # call block, continue only if method returns true
@@ -228,16 +249,16 @@ module Aspera
         end
       end
 
-      # Navigate the path from given file id
+      # Navigate the path from given file id on current node, and return the node and file id of target.
+      # If the path ends with a "/" or process_last_link is true then if the last item in path is a link, it is followed.
       # @param top_file_id [String] id initial file id
-      # @param path [String]  file path
+      # @param path [String] file or folder path (end with "/" is like setting process_last_link)
+      # @param process_last_link [Boolean] if true, follow the last link
       # @return [Hash] {.api,.file_id}
-      def resolve_api_fid(top_file_id, path)
+      def resolve_api_fid(top_file_id, path, process_last_link=false)
         Aspera.assert_type(top_file_id, String)
         Aspera.assert_type(path, String)
-        # if last element is a link and followed by "/", we list the content of that folder, else we return the link
-        process_last_link = path.end_with?(PATH_SEPARATOR)
-        # keep only non-empty elements
+        process_last_link ||= path.end_with?(PATH_SEPARATOR)
         path_elements = path.split(PATH_SEPARATOR).reject(&:empty?)
         return {api: self, file_id: top_file_id} if path_elements.empty?
         resolve_state = {path: path_elements, result: nil, process_last_link: process_last_link}
@@ -265,7 +286,7 @@ module Aspera
           full_spec = create(
             'files/download_setup',
             {transfer_requests: [{transfer_request: {paths: [{source: '/'}]}}]}
-          )[:data]['transfer_specs'].first['transfer_spec']
+          )['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)
@@ -317,13 +338,13 @@ module Aspera
           if !@app_info.nil? && !@app_info[:node_info]['transfer_url'].nil? && !@app_info[:node_info]['transfer_url'].empty?
             transfer_spec['remote_host'] = @app_info[:node_info]['transfer_url']
           end
-          info = read('info')[:data]
+          info = read('info')
           # get the transfer user from info on access key
           transfer_spec['remote_user'] = info['transfer_user'] if info['transfer_user']
           # get settings from name.value array to hash key.value
           settings = info['settings']&.each_with_object({}){|i, h|h[i['name']] = i['value']}
           # check WSS ports
-          %w[wss_enabled wss_port].each do |i|
+          Transfer::Spec::WSS_FIELDS.each do |i|
             transfer_spec[i] = settings[i] if settings.key?(i)
           end if settings.is_a?(Hash)
         else
@@ -380,7 +401,7 @@ module Aspera
         return true
       end
 
-      def process_find_files(entry, _path, state)
+      def process_find_files(entry, path, state)
         state[:found].push(entry.merge({'path' => path})) if state[:test_block].call(entry)
         # test all files deeply
         return true

data/lib/aspera/ascmd.rb

@@ -22,7 +22,54 @@ module Aspera
       mv:     2,
       rm:     1
     }.freeze
-    private_constant :OPS_ARGS
+
+    # protocol is based on Type-Length-Value
+    # type start at one, but array index start at zero
+    ENUM_START = 1
+
+    # description of result structures (see ascmdtypes.h).
+    # Base types are big endian
+    # key = name of type
+    # index in array `fields` is the type (minus ENUM_START)
+    # decoding always start at `result`
+    # some fields have special handling indicated by `special`
+    # field_list, list_tlv_list, list_tlv_restart are composed with a list of TLV
+    TYPES_DESCR = {
+      result: {decode: :field_list,
+               fields: [{name: :file, is_a: :stat}, {name: :dir, is_a: :stat, special: :list_tlv_list}, {name: :size, is_a: :size}, {name: :error, is_a: :error},
+                        {name: :info, is_a: :info}, {name: :success, is_a: nil, special: :return_true}, {name: :exit, is_a: nil},
+                        {name: :df, is_a: :mnt, special: :list_tlv_restart}, {name: :md5sum, is_a: :md5sum}]},
+      stat:   {decode: :field_list,
+               fields: [{name: :name, is_a: :zstr}, {name: :size, is_a: :int64}, {name: :mode, is_a: :int32, check: nil}, {name: :zmode, is_a: :zstr},
+                        {name: :uid, is_a: :int32, check: nil}, {name: :zuid, is_a: :zstr}, {name: :gid, is_a: :int32, check: nil}, {name: :zgid, is_a: :zstr},
+                        {name: :ctime, is_a: :epoch}, {name: :zctime, is_a: :zstr}, {name: :mtime, is_a: :epoch}, {name: :zmtime, is_a: :zstr},
+                        {name: :atime, is_a: :epoch}, {name: :zatime, is_a: :zstr}, {name: :symlink, is_a: :zstr}, {name: :errno, is_a: :int32},
+                        {name: :errstr, is_a: :zstr}]},
+      info:   {decode: :field_list,
+               fields: [{name: :platform, is_a: :zstr}, {name: :version, is_a: :zstr}, {name: :lang, is_a: :zstr}, {name: :territory, is_a: :zstr},
+                        {name: :codeset, is_a: :zstr}, {name: :lc_ctype, is_a: :zstr}, {name: :lc_numeric, is_a: :zstr}, {name: :lc_time, is_a: :zstr},
+                        {name: :lc_all, is_a: :zstr}, {name: :dev, is_a: :zstr, special: :list_multiple}, {name: :browse_caps, is_a: :zstr},
+                        {name: :protocol, is_a: :zstr}]},
+      size:   {decode: :field_list,
+               fields: [{name: :size, is_a: :int64}, {name: :fcount, is_a: :int32}, {name: :dcount, is_a: :int32}, {name: :failed_fcount, is_a: :int32},
+                        {name: :failed_dcount, is_a: :int32}]},
+      error:  {decode: :field_list,
+               fields: [{name: :errno, is_a: :int32}, {name: :errstr, is_a: :zstr}]},
+      mnt:    {decode: :field_list,
+               fields: [{name: :fs, is_a: :zstr}, {name: :dir, is_a: :zstr}, {name: :is_a, is_a: :zstr}, {name: :total, is_a: :int64},
+                        {name: :used, is_a: :int64}, {name: :free, is_a: :int64}, {name: :fcount, is_a: :int64}, {name: :errno, is_a: :int32},
+                        {name: :errstr, is_a: :zstr}]},
+      md5sum: {decode: :field_list, fields: [{name: :md5sum, is_a: :zstr}]},
+      int8:   {decode: :base, unpack: 'C', size: 1},
+      int32:  {decode: :base, unpack: 'L>', size: 4},
+      int64:  {decode: :base, unpack: 'Q>', size: 8},
+      epoch:  {decode: :base, unpack: 'Q>', size: 8},
+      zstr:   {decode: :base, unpack: 'Z*'},
+      blist:  {decode: :buffer_list}
+    }.freeze
+
+    private_constant :TYPES_DESCR, :ENUM_START, :OPS_ARGS
+
     # list of supported actions
     OPERATIONS = OPS_ARGS.keys.freeze
 
@@ -55,6 +102,7 @@ module Aspera
       arg_batches.each do |args|
         command = [main_command]
         # enclose arguments in double quotes, protect backslash and double quotes
+        # ascmd uses space as token separator, and optional quotes ('") or \ to escape
         args.each do |v|
           command.push(%Q{"#{v.gsub(/["\\]/){|s|"\\#{s}"}}"})
         end
@@ -106,47 +154,6 @@ module Aspera
       def extended_message; "ascmd: errno=#{@errno} errstr=\"#{@errstr}\" command=#{@command} arguments=#{@arguments&.join(',')}"; end
     end
 
-    # description of result structures (see ascmdtypes.h). Base types are big endian
-    # key = name of type
-    TYPES_DESCR = {
-      result: {decode: :field_list,
-               fields: [{name: :file, is_a: :stat}, {name: :dir, is_a: :stat, special: :sub_struct}, {name: :size, is_a: :size}, {name: :error, is_a: :error},
-                        {name: :info, is_a: :info}, {name: :success, is_a: nil, special: :return_true}, {name: :exit, is_a: nil},
-                        {name: :df, is_a: :mnt, special: :restart_on_first}, {name: :md5sum, is_a: :md5sum}]},
-      stat:   {decode: :field_list,
-               fields: [{name: :name, is_a: :zstr}, {name: :size, is_a: :int64}, {name: :mode, is_a: :int32, check: nil}, {name: :zmode, is_a: :zstr},
-                        {name: :uid, is_a: :int32, check: nil}, {name: :zuid, is_a: :zstr}, {name: :gid, is_a: :int32, check: nil}, {name: :zgid, is_a: :zstr},
-                        {name: :ctime, is_a: :epoch}, {name: :zctime, is_a: :zstr}, {name: :mtime, is_a: :epoch}, {name: :zmtime, is_a: :zstr},
-                        {name: :atime, is_a: :epoch}, {name: :zatime, is_a: :zstr}, {name: :symlink, is_a: :zstr}, {name: :errno, is_a: :int32},
-                        {name: :errstr, is_a: :zstr}]},
-      info:   {decode: :field_list,
-               fields: [{name: :platform, is_a: :zstr}, {name: :version, is_a: :zstr}, {name: :lang, is_a: :zstr}, {name: :territory, is_a: :zstr},
-                        {name: :codeset, is_a: :zstr}, {name: :lc_ctype, is_a: :zstr}, {name: :lc_numeric, is_a: :zstr}, {name: :lc_time, is_a: :zstr},
-                        {name: :lc_all, is_a: :zstr}, {name: :dev, is_a: :zstr, special: :multiple}, {name: :browse_caps, is_a: :zstr},
-                        {name: :protocol, is_a: :zstr}]},
-      size:   {decode: :field_list,
-               fields: [{name: :size, is_a: :int64}, {name: :fcount, is_a: :int32}, {name: :dcount, is_a: :int32}, {name: :failed_fcount, is_a: :int32},
-                        {name: :failed_dcount, is_a: :int32}]},
-      error:  {decode: :field_list,
-               fields: [{name: :errno, is_a: :int32}, {name: :errstr, is_a: :zstr}]},
-      mnt:    {decode: :field_list,
-               fields: [{name: :fs, is_a: :zstr}, {name: :dir, is_a: :zstr}, {name: :is_a, is_a: :zstr}, {name: :total, is_a: :int64},
-                        {name: :used, is_a: :int64}, {name: :free, is_a: :int64}, {name: :fcount, is_a: :int64}, {name: :errno, is_a: :int32},
-                        {name: :errstr, is_a: :zstr}]},
-      md5sum: {decode: :field_list, fields: [{name: :md5sum, is_a: :zstr}]},
-      int8:   {decode: :base, unpack: 'C', size: 1},
-      int32:  {decode: :base, unpack: 'L>', size: 4},
-      int64:  {decode: :base, unpack: 'Q>', size: 8},
-      epoch:  {decode: :base, unpack: 'Q>', size: 8},
-      zstr:   {decode: :base, unpack: 'Z*'},
-      blist:  {decode: :buffer_list}
-    }.freeze
-
-    # protocol enum start at one, but array index start at zero
-    ENUM_START = 1
-
-    private_constant :TYPES_DESCR, :ENUM_START
-
     class << self
       # get description of structure's field, @param struct_name, @param typed_buffer provides field name
       def field_description(struct_name, typed_buffer)
@@ -175,6 +182,7 @@ module Aspera
           Log.log.trace1{"#{'   .' * indent_level}-> base:#{byte_array} -> #{result}"}
           result = Time.at(result) if type_name.eql?(:epoch)
         when :buffer_list
+          # return a list of type_buffer
           result = []
           until buffer.empty?
             btype = parse(buffer, :int8, indent_level)
@@ -193,16 +201,16 @@ module Aspera
             field_info = field_description(type_name, typed_buffer)
             Log.log.trace1{"#{'   .' * indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green}
             case field_info[:special]
-            when nil
+            when nil # normal case
               result[field_info[:name]] = parse(typed_buffer[:buffer], field_info[:is_a], indent_level)
-            when :return_true
+            when :return_true # nothing to parse, just return true
               result[field_info[:name]] = true
-            when :sub_struct
-              result[field_info[:name]] = parse(typed_buffer[:buffer], :blist, indent_level).map{|r|parse(r[:buffer], field_info[:is_a], indent_level)}
-            when :multiple
+            when :list_multiple # field appears multiple times, and is an array of values (base type)
               result[field_info[:name]] ||= []
               result[field_info[:name]].push(parse(typed_buffer[:buffer], field_info[:is_a], indent_level))
-            when :restart_on_first
+            when :list_tlv_list # field is an array of values in a list of buffers
+              result[field_info[:name]] = parse(typed_buffer[:buffer], :blist, indent_level).map{|r|parse(r[:buffer], field_info[:is_a], indent_level)}
+            when :list_tlv_restart # field is an array of values, but a new value is started on index 1
               fl = result[field_info[:name]] = []
               parse(typed_buffer[:buffer], :blist, indent_level).map do |tb|
                 fl.push({}) if tb[:btype].eql?(ENUM_START)

data/lib/aspera/ascp/installation.rb

@@ -5,16 +5,16 @@ require 'aspera/environment'
 require 'aspera/data_repository'
 require 'aspera/ascp/products'
 require 'aspera/log'
+require 'aspera/rest'
 require 'aspera/assert'
 require 'aspera/web_server_simple'
 require 'English'
 require 'singleton'
 require 'xmlsimple'
-require 'zlib'
 require 'base64'
 require 'fileutils'
 require 'openssl'
-
+require 'yaml'
 module Aspera
   module Ascp
     # Singleton that tells where to find ascp and other local resources (keys..) , using the "path(:name)" method.
@@ -28,7 +28,7 @@ module Aspera
       include Singleton
       # protobuf generated files from sdk
       EXT_RUBY_PROTOBUF = '_pb.rb'
-      RB_SDK_FOLDER = 'lib'
+      RB_SDK_SUBFOLDER = 'lib'
       DEFAULT_ASPERA_CONF = <<~END_OF_CONFIG_FILE
         <?xml version='1.0' encoding='UTF-8'?>
         <CONF version="2">
@@ -43,9 +43,13 @@ module Aspera
       # all ascp files (in SDK)
       EXE_FILES = %i[ascp ascp4 async].freeze
       FILES = %i[transferd ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].unshift(*EXE_FILES).freeze
-      private_constant :EXT_RUBY_PROTOBUF, :RB_SDK_FOLDER, :DEFAULT_ASPERA_CONF, :FILES
+      TRANSFER_SDK_LOCATION_URL = 'https://ibm.biz/sdk_location'
+      FILE_SCHEME_PREFIX = 'file:///'
+      SDK_ARCHIVE_FOLDERS = ['/bin/', '/aspera/'].freeze
+      private_constant :EXT_RUBY_PROTOBUF, :RB_SDK_SUBFOLDER, :DEFAULT_ASPERA_CONF, :FILES, :TRANSFER_SDK_LOCATION_URL, :FILE_SCHEME_PREFIX
       # options for SSH client private key
       CLIENT_SSH_KEY_OPTIONS = %i{dsa_rsa rsa per_client}.freeze
+
       # set ascp executable path
       def ascp_path=(v)
         @path_to_ascp = v
@@ -55,12 +59,6 @@ module Aspera
         path(:ascp)
       end
 
-      def sdk_ruby_folder
-        ruby_pb_folder = File.join(sdk_folder, RB_SDK_FOLDER)
-        FileUtils.mkdir_p(ruby_pb_folder)
-        return ruby_pb_folder
-      end
-
       # location of SDK files
       def sdk_folder=(v)
         Log.log.debug{"sdk_folder=#{v}"}
@@ -83,7 +81,7 @@ module Aspera
       def use_ascp_from_product(product_name)
         if product_name.eql?(FIRST_FOUND)
           pl = Products.installed_products.first
-          raise "no FASP installation found\nPlease check manual on how to install FASP." if pl.nil?
+          raise "ascp found: no Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf ascp install" if pl.nil?
         else
           pl = Products.installed_products.find{|i|i[:name].eql?(product_name)}
           raise "no such product installed: #{product_name}" if pl.nil?
@@ -177,7 +175,7 @@ module Aspera
         return nil unless File.exist?(exe_path)
         exe_version = nil
         cmd_out = %x("#{exe_path}" #{vers_arg})
-        raise "An error occurred when testing #{ascp_filename}: #{cmd_out}" unless $CHILD_STATUS == 0
+        raise "An error occurred when testing #{exe_path}: #{cmd_out}" unless $CHILD_STATUS == 0
         # get version from ascp, only after full extract, as windows requires DLLs (SSL/TLS/etc...)
         m = cmd_out.match(/ version ([0-9.]+)/)
         exe_version = m[1].gsub(/\.$/, '') unless m.nil?
@@ -229,54 +227,113 @@ module Aspera
         return data
       end
 
+      # information for `ascp info`
       def ascp_info
-        files = file_paths
-        return files.merge(ascp_pvcl_info).merge(ascp_ssl_info)
+        ascp_data = file_paths
+        ascp_data.merge!(ascp_pvcl_info)
+        ascp_data['sdk_locations'] = TRANSFER_SDK_LOCATION_URL
+        ascp_data.merge!(ascp_ssl_info)
+        return ascp_data
+      end
+
+      # Loads YAML from cloud with locations of SDK archives for all platforms
+      # @return location structure
+      def sdk_locations
+        yaml_text = Aspera::Rest.new(base_url: TRANSFER_SDK_LOCATION_URL, redirect_max: 3).call(operation: 'GET')[:data]
+        YAML.load(yaml_text)
+      end
+
+      # @return the url for download of SDK archive for the given platform and version
+      def sdk_url_for_platform(platform: nil, version: nil)
+        locations = sdk_locations
+        platform = Environment.architecture if platform.nil?
+        locations = locations.select{|l|l['platform'].eql?(platform)}
+        raise "No SDK for platform: #{platform}" if locations.empty?
+        version = locations.max_by { |entry| Gem::Version.new(entry['version']) }['version'] if version.nil?
+        info = locations.select{|entry| entry['version'].eql?(version)}
+        raise "No such version: #{version} for #{platform}" if info.empty?
+        return info.first['url']
+      end
+
+      def extract_archive_files(sdk_archive_path)
+        raise 'missing block' unless block_given?
+        case sdk_archive_path
+        # Windows and Mac use zip
+        when /\.zip$/
+          require 'zip'
+          # extract files from archive
+          Zip::File.open(sdk_archive_path) do |zip_file|
+            zip_file.each do |entry|
+              next if entry.name.end_with?('/')
+              yield(entry.name, entry.get_input_stream)
+            end
+          end
+        # Other Unixes use tar.gz
+        when /\.tar\.gz/
+          require 'zlib'
+          require 'rubygems/package'
+          Zlib::GzipReader.open(sdk_archive_path) do |gzip|
+            Gem::Package::TarReader.new(gzip) do |tar|
+              tar.each do |entry|
+                next if entry.directory?
+                yield(entry.full_name, entry)
+              end
+            end
+          end
+        else
+          raise "unknown archive extension: #{sdk_archive_path}"
+        end
       end
 
       # download aspera SDK or use local file
       # extracts ascp binary for current system architecture
+      # @param url [String] URL to SDK archive, or SpecialValues::DEF
       # @return ascp version (from execution)
-      def install_sdk(sdk_url)
-        # SDK is organized by architecture, check this first, in case architecture is not supported
-        arch_filter = "#{Environment.architecture}/"
-        require 'zip'
-        sdk_zip_path = File.join(Dir.tmpdir, 'sdk.zip')
-        if sdk_url.start_with?('file:')
+      def install_sdk(url: nil, folder: nil, backup: true, with_exe: true, &block)
+        url = sdk_url_for_platform if url.nil? || url.eql?('DEF')
+        folder = sdk_folder if folder.nil?
+        subfolder_lambda = block
+        if subfolder_lambda.nil?
+          subfolder_lambda = ->(name) do
+            if SDK_ARCHIVE_FOLDERS.any?{|i|name.include?(i)}
+              '/'
+            elsif name.end_with?(EXT_RUBY_PROTOBUF)
+              RB_SDK_SUBFOLDER
+            end
+          end
+        end
+        if url.start_with?('file:')
           # require specific file scheme: the path part is "relative", or absolute if there are 4 slash
-          raise 'use format: file:///<path>' unless sdk_url.start_with?('file:///')
-          sdk_zip_path = sdk_url.gsub(%r{^file:///}, '')
+          raise 'use format: file:///<path>' unless url.start_with?(FILE_SCHEME_PREFIX)
+          sdk_archive_path = url[FILE_SCHEME_PREFIX.length..-1]
+          delete_archive = false
         else
-          Aspera::Rest.new(base_url: sdk_url, redirect_max: 3).call(operation: 'GET', save_to_file: sdk_zip_path)
+          sdk_archive_path = File.join(Dir.tmpdir, File.basename(url))
+          Aspera::Rest.new(base_url: url, redirect_max: 3).call(operation: 'GET', save_to_file: sdk_archive_path)
+          delete_archive = true
         end
         # rename old install
-        if !Dir.empty?(sdk_folder)
+        if backup && !Dir.empty?(folder)
           Log.log.warn('Previous install exists, renaming folder.')
-          File.rename(sdk_folder, "#{sdk_folder}.#{Time.now.strftime('%Y%m%d%H%M%S')}")
+          File.rename(folder, "#{folder}.#{Time.now.strftime('%Y%m%d%H%M%S')}")
           # TODO: delete old archives ?
         end
-        # extract files from archive
-        Zip::File.open(sdk_zip_path) do |zip_file|
-          zip_file.each do |entry|
-            # skip folder entries
-            next if entry.name.end_with?('/')
-            dest_folder = nil
-            # binaries
-            dest_folder = sdk_folder if entry.name.include?(arch_filter)
-            # ruby adapters
-            dest_folder = sdk_ruby_folder if entry.name.end_with?(EXT_RUBY_PROTOBUF)
-            next if dest_folder.nil?
-            File.open(File.join(dest_folder, File.basename(entry.name)), 'wb') do |output_stream|
-              IO.copy_stream(entry.get_input_stream, output_stream)
-            end
+        extract_archive_files(sdk_archive_path) do |entry_name, entry_stream|
+          subfolder = subfolder_lambda.call(entry_name)
+          next if subfolder.nil?
+          dest_folder = File.join(folder, subfolder)
+          FileUtils.mkdir_p(dest_folder)
+          File.open(File.join(dest_folder, File.basename(entry_name)), 'wb') do |output_stream|
+            IO.copy_stream(entry_stream, output_stream)
           end
         end
-        File.unlink(sdk_zip_path) rescue nil # Windows may give error
+        File.unlink(sdk_archive_path) rescue nil if delete_archive # Windows may give error
+        return unless with_exe
         # ensure license file are generated so that ascp invocation for version works
         path(:aspera_license)
         path(:aspera_conf)
         sdk_ascp_file = Products.ascp_filename
-        sdk_ascp_path = File.join(sdk_folder, sdk_ascp_file)
+        sdk_ascp_path = File.join(folder, sdk_ascp_file)
         raise "No #{sdk_ascp_file} found in SDK archive" unless File.exist?(sdk_ascp_path)
         EXE_FILES.each do |exe_sym|
           exe_path = sdk_ascp_path.gsub('ascp', exe_sym.to_s)
@@ -289,7 +346,7 @@ module Aspera
         transferd_version = get_exe_version(sdk_daemon_path, 'version')
         sdk_name = 'IBM Aspera Transfer SDK'
         sdk_version = transferd_version || sdk_ascp_version
-        File.write(File.join(sdk_folder, Products::INFO_META_FILE), "<product><name>#{sdk_name}</name><version>#{sdk_version}</version></product>")
+        File.write(File.join(folder, Products::INFO_META_FILE), "<product><name>#{sdk_name}</name><version>#{sdk_version}</version></product>")
         return sdk_name, sdk_version
       end
 

data/lib/aspera/ascp/management.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'aspera/assert'
+
 module Aspera
   module Ascp
     # processing of ascp management port events
@@ -237,8 +239,7 @@ module Aspera
           @last_event = @event_build
           @event_build = nil
           return @last_event
-        else
-          raise "mgt port: unexpected line: [#{line}]"
+        else Aspera.error_unexpected_value(line){'mgt port'}
         end
         return nil
       end

data/lib/aspera/ascp/products.rb

@@ -56,6 +56,18 @@ module Aspera
               log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera_Connect'),
               run_root: File.join(Dir.home, 'Library', 'Application Support', 'Aspera', 'Aspera Connect'),
               sub_bin:  File.join('Contents', 'Resources')
+            }, {
+              expected: CONNECT,
+              app_root: File.join(Dir.home, 'Applications', 'IBM Aspera Connect.app'),
+              log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera_Connect'),
+              run_root: File.join(Dir.home, 'Library', 'Application Support', 'Aspera', 'Aspera Connect'),
+              sub_bin:  File.join('Contents', 'Resources')
+            }, {
+              expected: CONNECT,
+              app_root: File.join('', 'Applications', 'IBM Aspera Connect.app'),
+              log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera_Connect'),
+              run_root: File.join(Dir.home, 'Library', 'Application Support', 'Aspera', 'Aspera Connect'),
+              sub_bin:  File.join('Contents', 'Resources')
             }, {
               expected: CLI_V1,
               app_root: File.join(Dir.home, 'Applications', 'Aspera CLI'),

data/lib/aspera/assert.rb

@@ -8,13 +8,13 @@ module Aspera
   end
   class << self
     # the block is executed in the context of the Aspera module
-    def assert(assertion, info = nil, level: 2, exception_class: AssertError)
+    def assert(assertion, info = nil, exception_class: AssertError)
       raise InternalError, 'bad assert: both info and block given' unless info.nil? || !block_given?
       return if assertion
       message = 'assertion failed'
       info = yield if block_given?
       message = "#{message}: #{info}" if info
-      message = "#{message}: #{caller(level..level).first}"
+      message = "#{message}: #{caller.find{|call|!call.start_with?(__FILE__)}}"
       raise exception_class, message
     end
 
@@ -22,13 +22,18 @@ module Aspera
     # @param value [Object] the value to check
     # @param type [Class] the expected type
     def assert_type(value, type, exception_class: AssertError)
-      assert(value.is_a?(type), level: 3, exception_class: exception_class){"#{block_given? ? "#{yield}: " : nil}expecting #{type}, but have #{value.inspect}"}
+      assert(value.is_a?(type), exception_class: exception_class){"#{block_given? ? "#{yield}: " : nil}expecting #{type}, but have #{value.inspect}"}
     end
 
     # assert that value is one of the given values
+    # @param value value to check
+    # @param values accepted values
+    # @param exception_class exception in case of no match
     def assert_values(value, values, exception_class: AssertError)
-      assert(values.include?(value), level: 3, exception_class: exception_class) do
-        "#{block_given? ? "#{yield}: " : nil}expecting one of #{values.inspect}, but have #{value.inspect}"
+      assert(values.include?(value), exception_class: exception_class) do
+        val_list = values.inspect
+        val_list = "one of #{val_list}" if values.is_a?(Array)
+        "#{block_given? ? "#{yield}: " : nil}expecting #{val_list}, but have #{value.inspect}"
       end
     end