aspera-cli 4.14.0 → 4.15.0

data/lib/aspera/fasp/agent_trsdk.rb

@@ -1,49 +1,51 @@
 # frozen_string_literal: true
 
-# cspell:words Transfersdk
-
 require 'aspera/fasp/agent_base'
 require 'aspera/fasp/installation'
 require 'json'
+require 'uri'
 
 module Aspera
   module Fasp
     class AgentTrsdk < Aspera::Fasp::AgentBase
       DEFAULT_OPTIONS = {
-        address: '127.0.0.1',
-        port:    55_002
+        url:      'grpc://127.0.0.1:0',
+        external: false,
+        keep:     false
       }.freeze
       private_constant :DEFAULT_OPTIONS
 
       # options come from transfer_info
-      def initialize(user_opts)
-        raise "expecting Hash (or nil), but have #{user_opts.class}" unless user_opts.nil? || user_opts.is_a?(Hash)
-        # set default options and override if specified
-        options = DEFAULT_OPTIONS.dup
-        user_opts&.each do |k, v|
-          raise "Unknown local agent parameter: #{k}, expect one of #{DEFAULT_OPTIONS.keys.map(&:to_s).join(',')}" unless DEFAULT_OPTIONS.key?(k)
-          options[k] = v
-        end
-        Log.log.debug{"options= #{options}"}
-        super()
+      def initialize(user_opts={})
+        super(user_opts)
+        @options = AgentBase.options(default: DEFAULT_OPTIONS, options: user_opts)
+        daemon_uri = URI.parse(@options[:url])
+        raise Fasp::Error, "invalid url #{@options[:url]}" unless daemon_uri.scheme.eql?('grpc')
+        Log.log.debug{Log.dump(:agent_options, @options)}
         # load and create SDK stub
         $LOAD_PATH.unshift(Installation.instance.sdk_ruby_folder)
         require 'transfer_services_pb'
-        @transfer_client = Transfersdk::TransferService::Stub.new("#{options[:address]}:#{options[:port]}", :this_channel_is_insecure)
+        # it stays
+        @daemon_pid = nil
         begin
+          @transfer_client = Transfersdk::TransferService::Stub.new("#{daemon_uri.host}:#{daemon_uri.port}", :this_channel_is_insecure)
           get_info_response = @transfer_client.get_info(Transfersdk::InstanceInfoRequest.new)
           Log.log.debug{"daemon info: #{get_info_response}"}
+          Log.log.warn{'attached to existing daemon'} unless @options[:external] || @options[:keep]
+          at_exit{shutdown}
         rescue GRPC::Unavailable
-          Log.log.warn('no daemon present, starting daemon...')
+          raise if @options[:external]
+          raise "daemon started with PID #{@daemon_pid}, but connection failed to #{daemon_uri}}" unless @daemon_pid.nil?
+          Log.log.warn('no daemon present, starting daemon...') if @options[:external]
           # location of daemon binary
           bin_folder = File.realpath(File.join(Installation.instance.sdk_ruby_folder, '..'))
           # config file and logs are created in same folder
-          conf_file = File.join(bin_folder, 'sdk.conf')
+          generated_config_file_path = File.join(bin_folder, 'sdk.conf')
           log_base = File.join(bin_folder, 'transferd')
           # create a config file for daemon
           config = {
-            address:      options[:address],
-            port:         options[:port],
+            address:      daemon_uri.host,
+            port:         daemon_uri.port,
             fasp_runtime: {
               use_embedded: false,
               user_defined: {
@@ -52,10 +54,30 @@ module Aspera
               }
             }
           }
-          File.write(conf_file, config.to_json)
-          trd_pid = Process.spawn(Installation.instance.path(:transferd), '--config', conf_file, out: "#{log_base}.out", err: "#{log_base}.err")
-          Process.detach(trd_pid)
-          sleep(2.0)
+          File.write(generated_config_file_path, config.to_json)
+          @daemon_pid = Process.spawn(Installation.instance.path(:transferd), '--config', generated_config_file_path, out: "#{log_base}.out", err: "#{log_base}.err")
+          begin
+            # wait for process to initialize
+            Timeout.timeout(2.0) do
+              _, status = Process.wait2(@daemon_pid)
+              raise "transfer daemon exited with status #{status.exitstatus}. Check files: #{log_base}.out #{log_base}.err"
+            end
+          rescue Timeout::Error
+            nil
+          end
+          Log.log.debug{"daemon started with pid #{@daemon_pid}"}
+          Process.detach(@daemon_pid) if @options[:keep]
+          if daemon_uri.port.eql?(0)
+            # if port is zero, a dynamic port was created, get it
+            File.open("#{log_base}.out", 'r') do |file|
+              file.each_line do |line|
+                if (m = line.match(/Info: API Server: Listening on ([^:]+):(\d+) /))
+                  daemon_uri.port = m[2].to_i
+                  # no "break" , need to keep last one
+                end
+              end
+            end
+          end
           retry
         end
       end
@@ -74,25 +96,34 @@ module Aspera
       end
 
       def wait_for_transfers_completion
-        started = false
+        # set to true when we know the total size of the transfer
+        session_started = false
+        bytes_expected = nil
         # monitor transfer status
         @transfer_client.monitor_transfers(Transfersdk::RegistrationRequest.new(transferId: [@transfer_id])) do |response|
-          Log.dump(:response, response.to_h)
+          Log.log.debug{Log.dump(:response, response.to_h)}
           # Log.log.debug{"#{response.sessionInfo.preTransferBytes} #{response.transferInfo.bytesTransferred}"}
           case response.status
           when :RUNNING
-            if !started && !response.sessionInfo.preTransferBytes.eql?(0)
-              notify_begin(@transfer_id, response.sessionInfo.preTransferBytes)
-              started = true
-            elsif started
-              notify_progress(@transfer_id, response.transferInfo.bytesTransferred)
+            if !session_started
+              notify_progress(session_id: @transfer_id, type: :session_start)
+              session_started = true
+            end
+            if bytes_expected.nil? &&
+                !response.sessionInfo.preTransferBytes.eql?(0)
+              bytes_expected = response.sessionInfo.preTransferBytes
+              notify_progress(type: :session_size, session_id: @transfer_id, info: bytes_expected)
             end
-          when :FAILED, :COMPLETED, :CANCELED
-            notify_end(@transfer_id)
-            raise Fasp::Error, JSON.parse(response.message)['Description'] unless :COMPLETED.eql?(response.status)
+            notify_progress(type: :transfer, session_id: @transfer_id, info: response.transferInfo.bytesTransferred)
+          when :COMPLETED
+            notify_progress(type: :transfer, session_id: @transfer_id, info: bytes_expected) if bytes_expected
+            notify_progress(type: :end, session_id: @transfer_id)
             break
+          when :FAILED, :CANCELED
+            notify_progress(type: :end, session_id: @transfer_id)
+            raise Fasp::Error, JSON.parse(response.message)['Description']
           when :QUEUED, :UNKNOWN_STATUS, :PAUSED, :ORPHANED
-            # ignore
+            notify_progress(session_id: nil, type: :pre_start, info: response.status.to_s.downcase)
           else
             Log.log.error{"unknown status#{response.status}"}
           end
@@ -100,6 +131,16 @@ module Aspera
         # TODO: return status
         return []
       end
+
+      def shutdown
+        if !@options[:keep] && !@daemon_pid.nil?
+          Log.log.debug("stopping daemon #{@daemon_pid}")
+          Process.kill('INT', @daemon_pid)
+          _, status = Process.wait2(@daemon_pid)
+          Log.log.debug("daemon stopped #{status}")
+          @daemon_pid = nil
+        end
+      end
     end
   end
 end

data/lib/aspera/fasp/error_info.rb

@@ -5,11 +5,11 @@
 module Aspera
   module Fasp
     # from https://www.google.com/search?q=FASP+error+codes
-    # Note that the fact that an error is retryable is not internally defined by protocol, it's client-side responsibility
+    # Note that the fact that an error is retry-able is not internally defined by protocol, it's client-side responsibility
     # rubocop:disable Layout/MultilineHashKeyLineBreaks
     # rubocop:disable Layout/FirstHashElementLineBreak
     ERROR_INFO = {
-      # id   retryable      mnemo                       message                                              additional info
+      # id   retry-able     mnemo                       message                                              additional info
       1  => { r: false, c: 'FASP_PROTO',                  m: 'Generic fasp(tm) protocol error',                a: 'fasp(tm) error'},
       2  => { r: false, c: 'ASCP',                        m: 'Generic SCP error',                              a: 'ASCP error'},
       3  => { r: false, c: 'AMBIGUOUS_TARGET',            m: 'Target incorrectly specified',                   a: 'Ambiguous target'},

data/lib/aspera/fasp/faux_file.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Aspera
+  module Fasp
+    # generates a pseudo file stream
+    class FauxFile
+      # marker for faux file
+      PREFIX = 'faux:///'
+      # size suffix
+      SUFFIX = %w[k m g t p e]
+      class << self
+        def open(name)
+          return nil unless name.start_with?(PREFIX)
+          parts = name[PREFIX.length..-1].split('?')
+          raise 'Format: #{PREFIX}<file path>?<size>' unless parts.length.eql?(2)
+          raise "Format: <integer>[#{SUFFIX.join(',')}]" unless (m = parts[1].downcase.match(/^(\d+)([#{SUFFIX.join('')}])$/))
+          size = m[1].to_i
+          suffix = m[2]
+          SUFFIX.each do |s|
+            size *= 1024
+            break if s.eql?(suffix)
+          end
+          return FauxFile.new(parts[0], size)
+        end
+      end
+      attr_reader :path, :size
+
+      def initialize(path, size)
+        @path = path
+        @size = size
+        @offset = 0
+        # we cache large chunks, anyway most of them will be the same size
+        @chunk_by_size = {}
+      end
+
+      def read(chunk_size)
+        return nil if eof?
+        bytes_to_read = [chunk_size, @size - @offset].min
+        @offset += bytes_to_read
+        @chunk_by_size[bytes_to_read] = "\x00" * bytes_to_read unless @chunk_by_size.key?(bytes_to_read)
+        return @chunk_by_size[bytes_to_read]
+      end
+
+      def close
+      end
+
+      def eof?
+        return @offset >= @size
+      end
+    end
+  end
+end

data/lib/aspera/fasp/installation.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
-require 'English'
-require 'singleton'
-require 'aspera/log'
+# cspell:ignore protobuf ckpt
 require 'aspera/environment'
 require 'aspera/data_repository'
+require 'aspera/fasp/products'
+require 'aspera/log'
+require 'aspera/web_server_simple'
+require 'English'
+require 'singleton'
 require 'xmlsimple'
 require 'zlib'
 require 'base64'
@@ -13,24 +16,18 @@ require 'openssl'
 
 module Aspera
   module Fasp
-    # Singleton that tells where to find ascp and other local resources (keys..) , using the "path(symb)" method.
+    # Singleton that tells where to find ascp and other local resources (keys..) , using the "path(:name)" method.
     # It is used by object : AgentDirect to find necessary resources
-    # By default it takes the first Aspera product found specified in product_locations
+    # By default it takes the first Aspera product found
     # but the user can specify ascp location by calling:
     # Installation.instance.use_ascp_from_product(product_name)
     # or
     # Installation.instance.ascp_path=""
     class Installation
       include Singleton
-      # known product names
-      PRODUCT_CONNECT = 'Aspera Connect'
-      PRODUCT_CLI_V1 = 'Aspera CLI'
-      PRODUCT_DRIVE = 'Aspera Drive'
-      PRODUCT_ENTSRV = 'Enterprise Server'
       # protobuf generated files from sdk
       EXT_RUBY_PROTOBUF = '_pb.rb'
       RB_SDK_FOLDER = 'lib'
-      ONE_YEAR_SECONDS = 365 * 24 * 60 * 60
       DEFAULT_ASPERA_CONF = <<~END_OF_CONFIG_FILE
         <?xml version='1.0' encoding='UTF-8'?>
         <CONF version="2">
@@ -42,9 +39,9 @@ module Aspera
         </default>
         </CONF>
       END_OF_CONFIG_FILE
-      DUMMY_CERT_INFO = '/C=US/ST=California/L=Emeryville/O=Aspera Inc./OU=Corporate/CN=Aspera Inc./emailAddress=info@asperasoft.com'
-      private_constant :PRODUCT_CONNECT, :PRODUCT_CLI_V1, :PRODUCT_DRIVE, :PRODUCT_ENTSRV, :EXT_RUBY_PROTOBUF, :RB_SDK_FOLDER,
-        :ONE_YEAR_SECONDS, :DEFAULT_ASPERA_CONF, :DUMMY_CERT_INFO
+      # all ascp files (in SDK)
+      FILES = %i[ascp ascp4 transferd ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].freeze
+      private_constant :EXT_RUBY_PROTOBUF, :RB_SDK_FOLDER, :DEFAULT_ASPERA_CONF, :FILES
       # set ascp executable path
       def ascp_path=(v)
         @path_to_ascp = v
@@ -56,7 +53,7 @@ module Aspera
 
       def sdk_ruby_folder
         ruby_pb_folder = File.join(sdk_folder, RB_SDK_FOLDER)
-        FileUtils.mkdir_p(ruby_pb_folder) unless Dir.exist?(ruby_pb_folder)
+        FileUtils.mkdir_p(ruby_pb_folder)
         return ruby_pb_folder
       end
 
@@ -73,61 +70,36 @@ module Aspera
       # @return the path to folder where SDK is installed
       def sdk_folder
         raise 'SDK path was ot initialized' if @sdk_dir.nil?
-        FileUtils.mkdir_p(@sdk_dir) unless Dir.exist?(@sdk_dir)
+        FileUtils.mkdir_p(@sdk_dir)
         @sdk_dir
       end
 
       # find ascp in named product (use value : FIRST_FOUND='FIRST' to just use first one)
-      # or select one from installed_products()
+      # or select one from Products.installed_products()
       def use_ascp_from_product(product_name)
         if product_name.eql?(FIRST_FOUND)
-          pl = installed_products.first
+          pl = Products.installed_products.first
           raise "no FASP installation found\nPlease check manual on how to install FASP." if pl.nil?
         else
-          pl = installed_products.find{|i|i[:name].eql?(product_name)}
+          pl = Products.installed_products.find{|i|i[:name].eql?(product_name)}
           raise "no such product installed: #{product_name}" if pl.nil?
         end
         self.ascp_path = pl[:ascp_path]
         Log.log.debug{"ascp_path=#{@path_to_ascp}"}
       end
 
-      # @return the list of installed products in format of product_locations
-      def installed_products
-        if @found_products.nil?
-          scan_locations = product_locations.clone
-          # add SDK as first search path
-          scan_locations.unshift({
-            expected: 'SDK',
-            app_root: sdk_folder,
-            sub_bin:  ''
-          })
-          # search installed products: with ascp
-          @found_products = scan_locations.select! do |item|
-            # skip if not main folder
-            next false unless Dir.exist?(item[:app_root])
-            Log.log.debug{"Found #{item[:app_root]}"}
-            sub_bin = item[:sub_bin] || BIN_SUBFOLDER
-            item[:ascp_path] = File.join(item[:app_root], sub_bin, ascp_filename)
-            # skip if no ascp
-            next false unless File.exist?(item[:ascp_path])
-            # read info from product info file if present
-            product_info_file = "#{item[:app_root]}/#{PRODUCT_INFO}"
-            if File.exist?(product_info_file)
-              res_s = XmlSimple.xml_in(File.read(product_info_file), {'ForceArray' => false})
-              item[:name] = res_s['name']
-              item[:version] = res_s['version']
-            else
-              item[:name] = item[:expected]
+      # @return [Hash] with key = file name (String), and value = path to file
+      def file_paths
+        return FILES.each_with_object({}) do |v, m|
+          m[v.to_s] =
+            begin
+              path(v)
+            rescue => e
+              e.message
             end
-            true # select this version
-          end
         end
-        return @found_products
       end
 
-      # all ascp files (in SDK)
-      FILES = %i[ascp ascp4 ssh_bypass_dsa_privkey ssh_bypass_rsa_privkey aspera_license aspera_conf fallback_certificate fallback_cert_privkey].freeze
-
       def check_or_create_sdk_file(filename, force: false, &block)
         return Environment.write_file_restricted(File.join(sdk_folder, filename), force: force, mode: 0o644, &block)
       end
@@ -143,31 +115,28 @@ module Aspera
           file = file.gsub('ascp', 'ascp4') if k.eql?(:ascp4)
         when :transferd
           file = transferd_filepath
-        when :ssh_bypass_dsa_privkey
-          file = check_or_create_sdk_file('aspera_bypass_dsa.pem') {get_key('dsa', 1)}
-        when :ssh_bypass_rsa_privkey
-          file = check_or_create_sdk_file('aspera_bypass_rsa.pem') {get_key('rsa', 2)}
+        when :ssh_private_dsa, :ssh_private_rsa
+          # assume last 3 letters are type
+          type = k.to_s[-3..-1]
+          file = check_or_create_sdk_file("aspera_bypass_#{type}.pem") do
+            # generate PEM from DER
+            OpenSSL::PKey.const_get(type.upcase).new(DataRepository.instance.data(type.eql?('dsa') ? 1 : 2)).to_pem
+          end
         when :aspera_license
           file = check_or_create_sdk_file('aspera-license') do
             Zlib::Inflate.inflate(DataRepository.instance.data(6))
           end
         when :aspera_conf
           file = check_or_create_sdk_file('aspera.conf') {DEFAULT_ASPERA_CONF}
-        when :fallback_certificate, :fallback_cert_privkey
+        when :fallback_certificate, :fallback_private_key
           file_key = File.join(sdk_folder, 'aspera_fallback_cert_private_key.pem')
           file_cert = File.join(sdk_folder, 'aspera_fallback_cert.pem')
           if !File.exist?(file_key) || !File.exist?(file_cert)
             require 'openssl'
             # create new self signed certificate for http fallback
-            private_key = OpenSSL::PKey::RSA.new(1024)
             cert = OpenSSL::X509::Certificate.new
-            cert.subject = cert.issuer = OpenSSL::X509::Name.parse(DUMMY_CERT_INFO)
-            cert.not_before = Time.now
-            cert.not_after = Time.now + ONE_YEAR_SECONDS
-            cert.public_key = private_key.public_key
-            cert.serial = 0x0
-            cert.version = 2
-            cert.sign(private_key, OpenSSL::Digest.new('SHA1'))
+            private_key = OpenSSL::PKey::RSA.new(4096)
+            WebServerSimple.fill_self_signed_cert(cert, private_key)
             check_or_create_sdk_file('aspera_fallback_cert_private_key.pem', force: true) {private_key.to_pem}
             check_or_create_sdk_file('aspera_fallback_cert.pem', force: true) {cert.to_pem}
           end
@@ -179,33 +148,13 @@ module Aspera
         return file
       end
 
-      # @return the file path of local connect where API's URI can be read
-      def connect_uri
-        connect = get_product_folders(PRODUCT_CONNECT)
-        folder = File.join(connect[:run_root], VAR_RUN_SUBFOLDER)
-        ['', 's'].each do |ext|
-          uri_file = File.join(folder, "http#{ext}.uri")
-          Log.log.debug{"checking connect port file: #{uri_file}"}
-          if File.exist?(uri_file)
-            return File.open(uri_file, &:gets).strip
-          end
-        end
-        raise "no connect uri file found in #{folder}"
-      end
-
-      # @ return path to configuration file of aspera CLI
-      def cli_conf_file
-        connect = get_product_folders(PRODUCT_CLI_V1)
-        return File.join(connect[:app_root], BIN_SUBFOLDER, '.aspera_cli_conf')
-      end
-
       # default bypass key phrase
-      def bypass_pass
+      def ssh_cert_uuid
         return format('%08x-%04x-%04x-%04x-%04x%08x', *DataRepository.instance.data(3).unpack('NnnnnN'))
       end
 
-      def bypass_keys
-        return %i[ssh_bypass_dsa_privkey ssh_bypass_rsa_privkey].map{|i|Installation.instance.path(i)}
+      def aspera_token_ssh_key_paths
+        return %i[ssh_private_dsa ssh_private_rsa].map{|i|Installation.instance.path(i)}
       end
 
       # use in plugin `config`
@@ -267,123 +216,33 @@ module Aspera
         # ensure license file are generated so that ascp invocation for version works
         path(:aspera_license)
         path(:aspera_conf)
-        ascp_path = File.join(sdk_folder, ascp_filename)
-        raise "No #{ascp_filename} found in SDK archive" unless File.exist?(ascp_path)
+        ascp_file = Products.ascp_filename
+        ascp_path = File.join(sdk_folder, ascp_file)
+        raise "No #{ascp_file} found in SDK archive" unless File.exist?(ascp_path)
         Environment.restrict_file_access(ascp_path, mode: 0o755)
         Environment.restrict_file_access(ascp_path.gsub('ascp', 'ascp4'), mode: 0o755)
-        ascp_version = get_ascp_version(File.join(sdk_folder, ascp_filename))
+        ascp_version = get_ascp_version(ascp_path)
         trd_path = transferd_filepath
         Log.log.warn{"No #{trd_path} in SDK archive"} unless File.exist?(trd_path)
         Environment.restrict_file_access(trd_path, mode: 0o755) if File.exist?(trd_path)
         transferd_version = get_exe_version(trd_path, 'version')
         sdk_version = transferd_version || ascp_version
-        File.write(File.join(sdk_folder, PRODUCT_INFO), "<product><name>IBM Aspera SDK</name><version>#{sdk_version}</version></product>")
+        File.write(File.join(sdk_folder, Products::INFO_META_FILE), "<product><name>IBM Aspera SDK</name><version>#{sdk_version}</version></product>")
         return sdk_version
       end
 
       private
 
-      BIN_SUBFOLDER = 'bin'
-      ETC_SUBFOLDER = 'etc'
-      VAR_RUN_SUBFOLDER = File.join('var', 'run')
-      # product information manifest: XML (part of aspera product)
-      PRODUCT_INFO = 'product-info.mf'
       # policy for product selection
       FIRST_FOUND = 'FIRST'
 
-      private_constant :BIN_SUBFOLDER, :ETC_SUBFOLDER, :VAR_RUN_SUBFOLDER, :PRODUCT_INFO
-
       def initialize
         @path_to_ascp = nil
         @sdk_dir = nil
-        @found_products = nil
-      end
-
-      # @return folder paths for specified applications
-      # @param name Connect or CLI
-      def get_product_folders(name)
-        found = installed_products.select{|i|i[:expected].eql?(name) || i[:name].eql?(name)}
-        raise "Product: #{name} not found, please install." if found.empty?
-        return found.first
-      end
-
-      # filename for ascp with optional extension (Windows)
-      def ascp_filename
-        return 'ascp' + Environment.exe_extension
       end
 
       def transferd_filepath
-        return File.join(sdk_folder, 'asperatransferd' + Environment.exe_extension)
-      end
-
-      # @return product folders depending on OS fields
-      # :expected  M app name is taken from the manifest if present, else defaults to this value
-      # :app_root  M main folder for the application
-      # :log_root  O location of log files (Linux uses syslog)
-      # :run_root  O only for Connect Client, location of http port file
-      # :sub_bin   O subfolder with executables, default : bin
-      def product_locations
-        case Aspera::Environment.os
-        when Aspera::Environment::OS_WINDOWS; return [{
-          expected: PRODUCT_CONNECT,
-          app_root: File.join(ENV['LOCALAPPDATA'], 'Programs', 'Aspera', 'Aspera Connect'),
-          log_root: File.join(ENV['LOCALAPPDATA'], 'Aspera', 'Aspera Connect', 'var', 'log'),
-          run_root: File.join(ENV['LOCALAPPDATA'], 'Aspera', 'Aspera Connect')
-        }, {
-          expected: PRODUCT_CLI_V1,
-          app_root: File.join('C:', 'Program Files', 'Aspera', 'cli'),
-          log_root: File.join('C:', 'Program Files', 'Aspera', 'cli', 'var', 'log')
-        }, {
-          expected: PRODUCT_ENTSRV,
-          app_root: File.join('C:', 'Program Files', 'Aspera', 'Enterprise Server'),
-          log_root: File.join('C:', 'Program Files', 'Aspera', 'Enterprise Server', 'var', 'log')
-        }]
-        when Aspera::Environment::OS_X; return [{
-          expected: PRODUCT_CONNECT,
-          app_root: File.join(Dir.home, 'Applications', '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: PRODUCT_CONNECT,
-          app_root: File.join('', 'Applications', '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: PRODUCT_CLI_V1,
-          app_root: File.join(Dir.home, 'Applications', 'Aspera CLI'),
-          log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera')
-        }, {
-          expected: PRODUCT_ENTSRV,
-          app_root: File.join('', 'Library', 'Aspera'),
-          log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera')
-        }, {
-          expected: PRODUCT_DRIVE,
-          app_root: File.join('', 'Applications', 'Aspera Drive.app'),
-          log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera_Drive'),
-          sub_bin:  File.join('Contents', 'Resources')
-        }]
-        else; return [{ # other: Linux and Unix family
-          expected: PRODUCT_CONNECT,
-          app_root: File.join(Dir.home, '.aspera', 'connect'),
-          run_root: File.join(Dir.home, '.aspera', 'connect')
-        }, {
-          expected: PRODUCT_CLI_V1,
-          app_root: File.join(Dir.home, '.aspera', 'cli')
-        }, {
-          expected: PRODUCT_ENTSRV,
-          app_root: File.join('', 'opt', 'aspera')
-        }]
-        end
-      end
-
-      # @return a standard bypass key
-      # @param type rsa or dsa
-      # @param id in repository 1 for dsa, 2 for rsa
-      def get_key(type, id)
-        # generate PEM from DER
-        OpenSSL::PKey.const_get(type.upcase).new(DataRepository.instance.data(id)).to_pem
+        return File.join(sdk_folder, 'asperatransferd' + Environment.exe_extension) # cspell:disable-line
       end
     end # Installation
   end