aspera-cli 4.24.1 → 4.25.0.pre

data/lib/aspera/faspex_postproc.rb

@@ -8,7 +8,7 @@ require 'aspera/log'
 require 'aspera/assert'
 
 module Aspera
-  # this class answers the Faspex /send API and creates a package on Aspera on Cloud
+  # Start a Faspex-4 style post-processing script using Faspex-5 webhook
   class Faspex4PostProcServlet < WEBrick::HTTPServlet::AbstractServlet
     ALLOWED_PARAMETERS = %i[root script_folder fail_on_error timeout_seconds].freeze
     def initialize(server, parameters)

data/lib/aspera/keychain/factory.rb

@@ -12,8 +12,7 @@ module Aspera
         # @param folder   [String] folder to store the vault (if needed)
         # @param password [String] password to open the vault
         def create(info, name, folder, password)
-          Aspera.assert_type(info, Hash)
-          Aspera.assert(info.values.all?(String)){'vault info shall have only string values'}
+          Aspera.assert_hash_all(info, Symbol, String){'vault info shall have only string values'}
           info = info.symbolize_keys
           vault_type = info.delete(:type)
           Aspera.assert_values(vault_type, LIST.map(&:to_s)){'vault.type'}

data/lib/aspera/keychain/macos_security.rb

@@ -73,7 +73,7 @@ module Aspera
           end
 
           def list(options = {})
-            Aspera.assert_values(options[:domain], DOMAINS, type: ArgumentError){'domain'} unless options[:domain].nil?
+            Aspera.assert_values(options[:domain], DOMAINS, type: ParameterError){'domain'} unless options[:domain].nil?
             key_chains(execute('list-keychains', options, LIST_OPTIONS))
           end
 

data/lib/aspera/log.rb

@@ -15,7 +15,7 @@ $VERBOSE = nil
 
 # Extend Ruby logger with trace levels
 class Logger
-  # Two additionnal trace levels
+  # Two additional trace levels
   TRACE_MAX = 2
 
   # Add custom level to logger severity, below debug level
@@ -23,9 +23,12 @@ class Logger
     1.upto(TRACE_MAX).each{ |level| const_set(:"TRACE#{level}", - level)}
   end
 
-  # Hash : key: log level int, value: uppercase log level label
+  # Hash
+  # key   [Integer] Log level (e.g. 0 for DEBUG)
+  # value [Symbol]  Uppercase log level label (e.g. :DEBUG)
   SEVERITY_LABEL = Severity.constants.each_with_object({}){ |name, hash| hash[Severity.const_get(name)] = name}
 
+  # Override
   # @param severity [Integer] Log severity as int
   # @return [String] Log severity upper case label
   def format_severity(severity)
@@ -106,6 +109,31 @@ module Aspera
       ensure
         $stderr = real_stderr
       end
+
+      # Returns the last 2 containers (module/class) and method caller
+      def caller_method
+        stack = caller
+        i = stack.rindex{ |line| line.include?('Logger')}
+        frame = stack[i + 1] if i && stack[i + 1]
+        return '???' unless frame
+        # Extract the "Class::Module::Method" or "Class#method" part
+        full = frame[/'([^']+)'/, 1]
+        return '???' unless full
+        # Split into class/module and method parts
+        parts = full.split(/(::|#)/)
+        # Reconstruct keeping only last two class/module names + separator + method
+        if parts.include?('#')
+          sep_index = parts.index('#')
+          classes = parts[0...sep_index].join
+          method = parts[sep_index + 1]
+        else
+          classes = parts[0..-2].join
+          method = parts.last
+        end
+        class_parts = classes.split('::')
+        selected_classes = class_parts.last(2).join('::')
+        "#{selected_classes}.#{method}"
+      end
     end
 
     attr_reader :logger_type, :logger
@@ -119,6 +147,7 @@ module Aspera
     # Set log level of underlying logger given symbol level
     # @param new_level [Symbol] One of LEVELS
     def level=(new_level)
+      Aspera.assert_values(new_level, LEVELS)
       @logger.level = Logger::Severity.const_get(new_level.to_sym.upcase)
     end
 
@@ -140,10 +169,8 @@ module Aspera
     # Get symbol of debug level of underlying logger
     # @return [Symbol] One of LEVELS
     def level
-      Logger::Severity.constants.each do |name|
-        return name.downcase.to_sym if @logger.level.eql?(Logger::Severity.const_get(name))
-      end
-      Aspera.error_unexpected_value(@logger.level){'log level'}
+      Aspera.assert(Logger::SEVERITY_LABEL.key?(@logger.level))
+      Logger::SEVERITY_LABEL[@logger.level].downcase
     end
 
     # Change underlying logger, but keep log level
@@ -158,8 +185,8 @@ module Aspera
         @logger = Logger.new($stdout, progname: @program_name, formatter: DEFAULT_FORMATTER)
       when :syslog
         require 'syslog/logger'
-        # the syslog class automatically creates methods from the severity names
-        # we just need to add the mapping (but syslog lowest is DEBUG)
+        # The syslog class automatically creates methods from the severity names.
+        # We just need to add the mapping (but syslog lowest is DEBUG)
         1.upto(Logger::TRACE_MAX).each do |level|
           Syslog::Logger.const_get(:LEVEL_MAP)[Logger.const_get("TRACE#{level}")] = Syslog::LOG_DEBUG
         end
@@ -207,7 +234,8 @@ module Aspera
     # pre-defined formatters
     FORMATTERS = {
       standard: Logger::Formatter.new,
-      default:  DEFAULT_FORMATTER
+      default:  DEFAULT_FORMATTER,
+      caller:   ->(s, _d, _p, m){"#{LVL_COLOR[s]} #{Log.caller_method}\n#{m}\n"}
     }.freeze
 
     private_constant :LVL_DECO, :LVL_COLOR, :DEFAULT_FORMATTER, :FORMATTERS

data/lib/aspera/markdown.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Aspera
+  # Formatting for Markdown
+  class Markdown
+    # Matches: **bold**, `code`, or an HTML entity (&, ©, 💩)
+    FORMATS = /(?:\*\*(?<bold>[^*]+?)\*\*)|(?:`(?<code>[^`]+)`)|&(?<entity>(?:[A-Za-z][A-Za-z0-9]{1,31}|#\d{1,7}|#x[0-9A-Fa-f]{1,6}));/m
+    HTML_BREAK = '<br/>'
+
+    class << self
+      # Generate markdown from the provided 2D table
+      def table(table)
+        # get max width of each columns
+        col_widths = table.transpose.map do |col|
+          [col.flat_map{ |c| c.to_s.delete('`').split(HTML_BREAK).map(&:size)}.max, 80].min
+        end
+        headings = table.shift
+        table.unshift(col_widths.map{ |col_width| '-' * col_width})
+        table.unshift(headings)
+        lines = table.map{ |line| "| #{line.map{ |i| i.to_s.gsub('\\', '\\\\').gsub('|', '\|')}.join(' | ')} |\n"}
+        lines[1] = lines[1].tr(' ', '-')
+        return lines.join.chomp
+      end
+
+      # Generate markdown list from the provided list
+      def list(items)
+        items.map{ |i| "- #{i}"}.join("\n")
+      end
+    end
+  end
+end

data/lib/aspera/nagios.rb

@@ -21,7 +21,7 @@ module Aspera
     end
 
     class << self
-      # process results of a analysis and display status and exit with code
+      # Process results of a analysis and display status and exit with code
       def process(data)
         Aspera.assert_type(data, Array)
         Aspera.assert(!data.empty?){'data is empty'}
@@ -54,10 +54,10 @@ module Aspera
       @data = []
     end
 
-    # compare remote time with local time
+    # Compare remote time with local time
     def check_time_offset(remote_date, component)
       # check date if specified : 2015-10-13T07:32:01Z
-      remote_time = Time.strptime(remote_date)
+      remote_time = Time.parse(remote_date)
       diff_time = (remote_time - Time.now).abs
       diff_rounded = diff_time.round(-2)
       Log.log.debug{"DATE: #{remote_date} #{remote_time} diff=#{diff_rounded}"}
@@ -76,10 +76,11 @@ module Aspera
       # TODO: check on database if latest version
     end
 
-    # translate for display
-    def result
+    # Readable status list
+    # @return [Array] of Hash
+    def status_list
       Aspera.assert(!@data.empty?){'missing result'}
-      {type: :object_list, data: @data.map{ |i| {'status' => LEVELS[i[:code]].to_s, 'component' => i[:comp], 'message' => i[:msg]}}}
+      @data.map{ |i| {'status' => LEVELS[i[:code]].to_s, 'component' => i[:comp], 'message' => i[:msg]}}
     end
   end
 end

data/lib/aspera/oauth/base.rb

@@ -13,6 +13,7 @@ module Aspera
     # OAuth 2.0 Authorization Framework: https://tools.ietf.org/html/rfc6749
     # Bearer Token Usage: https://tools.ietf.org/html/rfc6750
     class Base
+      Aspera.require_method!(:create_token)
       # @param **             Parameters for REST
       # @param client_id      [String, nil]
       # @param client_secret  [String, nil]
@@ -31,8 +32,7 @@ module Aspera
         cache_ids: nil,
         **rest_params
       )
-        Aspera.assert(respond_to?(:create_token), 'create_token method must be defined', type: InternalError)
-        # this is the OAuth API
+        # This is the OAuth API
         @api = Rest.new(**rest_params)
         @scope = nil
         @token_cache_id = nil
@@ -43,6 +43,7 @@ module Aspera
         @use_query = use_query
         @base_cache_ids = cache_ids.nil? ? [] : cache_ids.clone
         Aspera.assert_type(@base_cache_ids, Array)
+        # TODO: this shall be done in class, using cache_ids
         @base_cache_ids.push(@api.auth_params[:username]) if @api.auth_params.key?(:username)
         @base_cache_ids.compact!
         @base_cache_ids.freeze
@@ -56,31 +57,24 @@ module Aspera
         @token_cache_id = Factory.cache_id(@api.base_url, self.class, @base_cache_ids, @scope)
       end
 
-      attr_reader :scope, :api, :path_token
+      attr_reader :scope, :api, :path_token, :client_id
 
-      # helper method to create token as per RFC
+      # Helper method to create token as per RFC
+      # @return [HTTPResponse]
+      # @raise RestError if not 2XX code
       def create_token_call(creation_params)
         Log.log.debug{'Generating a new token'.bg_green}
-        payload = {content_type: Rest::MIME_WWW}
-        if @use_query
-          payload[:query] = creation_params
-        else
-          payload[:body] = creation_params
-        end
-        return @api.call(
-          operation: 'POST',
-          subpath:   @path_token,
-          headers:   {'Accept' => Rest::MIME_JSON},
-          **payload
-        )
+        return @api.create(@path_token, nil, query: creation_params, ret: :resp) if @use_query
+        return @api.create(@path_token, creation_params, content_type: Rest::MIME_WWW, ret: :resp)
       end
 
-      # @return Hash with optional general parameters
+      # @param add_secret [Boolean] Add secret in default call parameters
+      # @return [Hash] Optional general parameters
       def optional_scope_client_id(add_secret: false)
         call_params = {}
         call_params[:scope] = @scope unless @scope.nil?
         call_params[:client_id] = @client_id unless @client_id.nil?
-        call_params[:client_secret] = @client_secret if add_secret && !@client_id.nil?
+        call_params[:client_secret] = @client_secret unless !add_secret || @client_id.nil? || @client_secret.nil?
         return call_params
       end
 
@@ -106,6 +100,7 @@ module Aspera
           # `direct` agent is equipped with refresh code
           # an API was already called, but failed, we need to regenerate or refresh
           if refresh || token_info[:expired]
+            Log.log.trace1{"refresh: #{refresh} expired: #{token_info[:expired]}"}
             refresh_token = nil
             if token_data.key?('refresh_token') && !token_data['refresh_token'].eql?('not_supported')
               # save possible refresh token, before deleting the cache
@@ -115,17 +110,18 @@ module Aspera
             Factory.instance.persist_mgr.delete(@token_cache_id)
             token_data = nil
             # lets try the existing refresh token
+            # NOTE: AoC admin token has no refresh, and lives by default 1800secs
             if !refresh_token.nil?
-              Log.log.info{"refresh=[#{refresh_token}]".bg_green}
-              # NOTE: AoC admin token has no refresh, and lives by default 1800secs
-              resp = create_token_call(optional_scope_client_id.merge(grant_type: 'refresh_token', refresh_token: refresh_token))
-              if resp[:http].code.start_with?('2')
-                # save only if success
-                json_data = resp[:http].body
+              Log.log.info{"refresh token=[#{refresh_token}]".bg_green}
+              begin
+                http = create_token_call(optional_scope_client_id(add_secret: true).merge(grant_type: 'refresh_token', refresh_token: refresh_token))
+                # Save only if success
+                json_data = http.body
                 token_data = JSON.parse(json_data)
                 Factory.instance.persist_mgr.put(@token_cache_id, json_data)
-              else
-                Log.log.debug{"refresh failed: #{resp[:http].body}".bg_red}
+              rescue => e
+                # Refresh token can fail.
+                Log.log.warn{"Refresh failed: #{e}"}
               end
             end
           end
@@ -133,8 +129,9 @@ module Aspera
 
         # no cache, nor refresh: generate a token
         if token_data.nil?
-          resp = create_token
-          json_data = resp[:http].body
+          # Call the method-specific token creation
+          # which returns the result of create_token_call
+          json_data = create_token.body
           token_data = JSON.parse(json_data)
           Factory.instance.persist_mgr.put(@token_cache_id, json_data)
         end

data/lib/aspera/oauth/factory.rb

@@ -63,10 +63,10 @@ module Aspera
         @decoders = []
         # default parameters, others can be added by handlers
         @parameters = {
-          # tokens older than 30 minutes will be discarded from cache
-          token_cache_expiry_sec:     1800,
-          # tokens valid for less than this duration will be regenerated
-          token_expiration_guard_sec: 120
+          # tokens older than this duration in sec. will be discarded from cache
+          token_cache_max_age:     1800,
+          # tokens valid for less than this duration in sec. will be regenerated
+          token_refresh_threshold: 120
         }
       end
 
@@ -77,7 +77,7 @@ module Aspera
       def persist_mgr=(manager)
         @persist = manager
         # cleanup expired tokens
-        @persist.garbage_collect(PERSIST_CATEGORY_TOKEN, @parameters[:token_cache_expiry_sec])
+        @persist.garbage_collect(PERSIST_CATEGORY_TOKEN, @parameters[:token_cache_max_age])
       end
 
       def persist_mgr
@@ -108,7 +108,7 @@ module Aspera
         end
       end
 
-      # get token information from cache
+      # Get token information from cache
       # @param id [String] identifier of token
       # @return [Hash] token internal information , including Date object for `expiration_date`
       def get_token_info(id)
@@ -118,7 +118,6 @@ module Aspera
         Aspera.assert_type(token_data, Hash)
         decoded_token = decode_token(token_data[TOKEN_FIELD])
         info = {data: token_data}
-        Log.dump(:decoded_token, decoded_token)
         if decoded_token.is_a?(Hash)
           info[:decoded] = decoded_token
           # TODO: move date decoding to token decoder ?
@@ -129,9 +128,10 @@ module Aspera
           unless expiration_date.nil?
             info[:expiration] = expiration_date
             info[:ttl_sec] = expiration_date - Time.now
-            info[:expired] = info[:ttl_sec] < @parameters[:token_expiration_guard_sec]
+            info[:expired] = info[:ttl_sec] < @parameters[:token_refresh_threshold]
           end
         end
+        Log.dump(:token_info, info)
         return info
       end
 
@@ -156,7 +156,7 @@ module Aspera
       def register_token_creator(creator_class)
         Aspera.assert_type(creator_class, Class)
         id = Factory.class_to_id(creator_class)
-        Log.log.debug{"registering token creator #{id}"}
+        Log.log.debug{"registering creator for #{id}"}
         @token_type_classes[id] = creator_class
       end
 

data/lib/aspera/oauth/url_json.rb

@@ -25,7 +25,8 @@ module Aspera
           query:        @query.merge(scope: scope), # scope is here because it may change over time (node)
           content_type: Rest::MIME_JSON,
           body:         @body,
-          headers:      {'Accept' => Rest::MIME_JSON}
+          headers:      {'Accept' => Rest::MIME_JSON},
+          ret:          :resp
         )
       end
     end

data/lib/aspera/oauth/web.rb

@@ -9,7 +9,7 @@ module Aspera
     # Authentication using Web browser
     class Web < Base
       class << self
-        attr_accessor :additionnal_info
+        attr_accessor :additional_info
       end
       # @param redirect_uri    url to receive the code after auth (to be exchanged for token)
       # @param path_authorize  path to login page on web app
@@ -37,7 +37,7 @@ module Aspera
         # here, we need a human to authorize on a web page
         Log.log.info{"login_page_url=#{login_page_url}".bg_red.gray}
         # start a web server to receive request code
-        web_server = WebAuth.new(@redirect_uri, self.class.additionnal_info)
+        web_server = WebAuth.new(@redirect_uri, self.class.additional_info)
         # start browser on login page
         Environment.instance.open_uri(login_page_url)
         # wait for code in request

data/lib/aspera/preview/file_types.rb

@@ -3,7 +3,7 @@
 require 'aspera/log'
 require 'aspera/assert'
 require 'singleton'
-require 'mime/types'
+require 'marcel'
 
 module Aspera
   module Preview
@@ -61,7 +61,7 @@ module Aspera
       end
 
       # @param mimetype [String] mime type
-      # @return file type, one of enum CONVERSION_TYPES, or nil if not found
+      # @return [NilClass,Symbol] file type, one of enum CONVERSION_TYPES, or nil if not found
       def mime_to_type(mimetype)
         Aspera.assert_type(mimetype, String)
         return SUPPORTED_MIME_TYPES[mimetype] if SUPPORTED_MIME_TYPES.key?(mimetype)
@@ -72,19 +72,17 @@ module Aspera
         return
       end
 
-      # @param filepath [String] full path to file
-      # @param mimetype [String] provided by node API
+      # @param filepath [String] Full path to file
+      # @param mimetype [String] MIME typre provided by node API
       # @return file type, one of enum CONVERSION_TYPES
       # @raise [RuntimeError] if no conversion type found
       def conversion_type(filepath, mimetype)
         Log.log.debug{"conversion_type(#{filepath},mime=#{mimetype},magic=#{@use_mimemagic})"}
-        mimetype = nil if mimetype.is_a?(String) && (mimetype == 'application/octet-stream' || mimetype.empty?)
-        # Use mimemagic if available
-        mimetype ||= mime_using_mimemagic(filepath)
-        mimetype ||= mime_using_file(filepath)
-        # from extensions, using local mapping
-        mimetype ||= MIME::Types.of(File.basename(filepath)).first
-        raise "no MIME type found for #{File.basename(filepath)}" if mimetype.nil?
+        # Default type or empty means no type
+        mimetype = TYPE_NOT_FOUND if mimetype.nil? || (mimetype.is_a?(String) && mimetype.empty?)
+        mimetype = Marcel::MimeType.for(Pathname.new(filepath), name: File.basename(filepath), declared_type: mimetype)
+        mimetype = 'text/plain' if mimetype.eql?(TYPE_NOT_FOUND) && ascii_text_file?(filepath)
+        raise "no MIME type found for #{File.basename(filepath)}" if mimetype.eql?(TYPE_NOT_FOUND)
         conversion_type = mime_to_type(mimetype)
         raise "no conversion type found for #{File.basename(filepath)}" if conversion_type.nil?
         Log.log.trace1{"conversion_type(#{File.basename(filepath)}): #{conversion_type.class.name} [#{conversion_type}]"}
@@ -93,33 +91,21 @@ module Aspera
 
       private
 
-      # Use mime magic to find mime type based on file content (magic numbers)
-      # @param filepath [String] full path to file
-      # @return [String] mime type, or nil if not found
-      def mime_using_mimemagic(filepath)
-        return unless @use_mimemagic
-        # moved here, as `mimemagic` can cause installation issues
-        require 'mimemagic'
-        require 'mimemagic/version'
-        require 'mimemagic/overlay' if MimeMagic::VERSION.start_with?('0.3.')
-        # check magic number inside file (empty string if not found)
-        detected_mime = MimeMagic.by_magic(File.open(filepath)).to_s
-        # check extension only
-        if mime_to_type(detected_mime).nil?
-          Log.log.debug{"no conversion for #{detected_mime}, trying extension"}
-          detected_mime = MimeMagic.by_extension(File.extname(filepath)).to_s
-        end
-        detected_mime = nil if detected_mime.empty?
-        Log.log.debug{"mimemagic: #{detected_mime.class.name} [#{detected_mime}]"}
-        return detected_mime
-      end
+      TYPE_NOT_FOUND = 'application/octet-stream'
+      ACCEPT_CTRL_CHARS = [9, 10, 13]
 
-      # Use 'file' command to find mime type based on file content (Unix)
-      def mime_using_file(filepath)
-        return Environment.secure_capture(exec: 'file', args: ['--mime-type', '--brief', filepath]).strip
-      rescue => e
-        Log.log.error{"error using 'file' command: #{e.message}"}
-        return
+      # Returns true if the file looks like ASCII text (printable ASCII + \t, \r, \n, space).
+      # It reads only a small prefix (default: 64KB) and fails fast on the first bad byte.
+      def ascii_text_file?(path, sample_size: 64 * 1024)
+        File.open(path, 'rb') do |f|
+          sample = f.read(sample_size) || ''.b
+          sample.each_byte do |b|
+            next if b.between?(32, 126) || ACCEPT_CTRL_CHARS.include?(b)
+            # Any other control character => not ASCII text
+            return false
+          end
+          true
+        end
       end
     end
   end

data/lib/aspera/products/connect.rb

@@ -48,17 +48,18 @@ module Aspera
         end
       end
 
+      # Base URL for CDN of Connect
       def cdn_api
         Rest.new(base_url: CDN_BASE_URL)
       end
 
-      # retrieve structure from cloud (CDN) with all versions available
+      # Retrieve structure from cloud (CDN) with all versions available
       def versions
         if @connect_versions.nil?
-          javascript = cdn_api.call(operation: 'GET', subpath: VERSION_INFO_FILE)
+          http = cdn_api.read(VERSION_INFO_FILE, ret: :resp)
           # get result on one line
-          connect_versions_javascript = javascript[:http].body.gsub(/\r?\n\s*/, '')
-          Log.log.debug{"javascript=[\n#{connect_versions_javascript}\n]"}
+          connect_versions_javascript = http.body.gsub(/\r?\n\s*/, '')
+          Log.dump(:javascript, connect_versions_javascript)
           # get javascript object only
           found = connect_versions_javascript.match(/^.*? = (.*);/)
           raise Cli::Error, 'Problem when getting connect versions from internet' if found.nil?
@@ -74,10 +75,10 @@ module Aspera
         @connect_versions = nil
       end
 
-      VERSION_INFO_FILE = 'connectversions.js' # cspell: disable-line
       CDN_BASE_URL = 'https://d3gcli72yxqn2z.cloudfront.net/connect'
+      VERSION_INFO_FILE = 'connectversions.js' # cspell: disable-line
 
-      private_constant :VERSION_INFO_FILE, :CDN_BASE_URL
+      private_constant :CDN_BASE_URL, :VERSION_INFO_FILE
     end
   end
 end

data/lib/aspera/products/desktop.rb

@@ -8,6 +8,7 @@ module Aspera
     class Desktop
       APP_NAME = 'IBM Aspera for Desktop'
       APP_IDENTIFIER = 'com.ibm.software.aspera.desktop'
+      LOG_FILENAME = 'ibm-aspera-desktop.log'
       class << self
         # standard folder locations
         def locations
@@ -20,10 +21,6 @@ module Aspera
           else []
           end.map{ |i| i.merge({expected: APP_NAME})}
         end
-
-        def log_file
-          File.join(Dir.home, 'Library', 'Logs', APP_IDENTIFIER, 'ibm-aspera-desktop.log')
-        end
       end
     end
   end

data/lib/aspera/products/other.rb

@@ -54,8 +54,14 @@ module Aspera
       }]
       end
       class << self
+        # Find installed products and provide paths for it.
+        # @param scan_locations [Array] Array of Hash with keys: expected, app_root, sub_bin, ascp_path, name, version
+        # @return [Array] of products found, with filled missing fields
+        # @raise Exception if no installed product found
         def find(scan_locations)
-          scan_locations.select do |item|
+          product_names = []
+          found = scan_locations.select do |item|
+            product_names.push(item[:expected]) unless product_names.include?(item[:expected])
             # skip if not main folder
             Log.log.trace1{"Checking #{item[:app_root]}"}
             next false unless Dir.exist?(item[:app_root])
@@ -75,6 +81,8 @@ module Aspera
             end
             true # select this version
           end
+          raise "Product: #{product_names.join(', ')} not found, please install." if found.empty?
+          found
         end
       end
     end

data/lib/aspera/products/transferd.rb

@@ -30,7 +30,6 @@ module Aspera
         # @return the path to folder where SDK is installed
         def sdk_directory
           Aspera.assert(!@sdk_dir.nil?){'SDK path was not initialized'}
-          FileUtils.mkdir_p(@sdk_dir)
           @sdk_dir
         end