aspera-cli 4.20.0 → 4.21.2

data/lib/aspera/api/aoc.rb

@@ -63,13 +63,14 @@ module Aspera
           return client_key, DataRepository.instance.item(client_key)
         end
 
-        # base API url depends on domain, which could be "qa.xxx"
-        def api_base_url(organization: 'api', api_domain: SAAS_DOMAIN_PROD)
-          return "https://#{organization}.#{api_domain}"
+        # base API url depends on domain, which could be "qa.xxx" or self-managed domain
+        def api_base_url(api_domain: SAAS_DOMAIN_PROD)
+          return "https://api.#{api_domain}"
         end
 
-        # split host of http://myorg.asperafiles.com in org and domain
+        # split host of URL into organization and domain
         def split_org_domain(uri)
+          Aspera.assert_type(uri, URI)
           raise "No host found in URL.Please check URL format: https://myorg.#{SAAS_DOMAIN_PROD}" if uri.host.nil?
           parts = uri.host.split('.', 2)
           Aspera.assert(parts.length == 2){"expecting a public FQDN for #{PRODUCT_NAME}"}
@@ -77,6 +78,10 @@ module Aspera
           return %i{organization domain}.zip(parts).to_h
         end
 
+        def saas_url?(url)
+          url.include?(SAAS_DOMAIN_PROD)
+        end
+
         # @param url [String] URL of AoC public link
         # @return [Hash] information about public link, or nil if not a public link
         def link_info(url)
@@ -187,6 +192,7 @@ module Aspera
           }
           # add jwt payload for global client id
           auth_params[:payload][:org] = url_info[:organization] if GLOBAL_CLIENT_APPS.include?(auth_params[:client_id])
+          auth_params[:cache_ids] = [url_info[:organization]]
         when :url_json
           auth_params[:url] = {grant_type: 'url_token'} # URL arguments
           auth_params[:json] = {url_token: url_info[:token]} # JSON body
@@ -442,13 +448,12 @@ module Aspera
         case pkg_data['metadata']
         when Array, NilClass # no action
         when Hash
-          api_meta = []
-          pkg_data['metadata'].each do |k, v|
-            api_meta.push({
+          api_meta = pkg_data['metadata'].map do |k, v|
+            {
               # 'input_type' => 'single-dropdown',
               'name'   => k,
               'values' => v.is_a?(Array) ? v : [v]
-            })
+            }
           end
           pkg_data['metadata'] = api_meta
         else Aspera.error_unexpected_value(pkg_meta.class)

data/lib/aspera/api/cos_node.rb

@@ -87,7 +87,7 @@ module Aspera
           receiver_client_ids: 'aspera_ats'
         )
         # get delegated token to be placed in rest call header and in transfer tags
-        @storage_credentials['token'][TOKEN_FIELD] = OAuth::Factory.bearer_extract(delegated_oauth.token)
+        @storage_credentials['token'][TOKEN_FIELD] = delegated_oauth.token
         @headers['X-Aspera-Storage-Credentials'] = JSON.generate(@storage_credentials)
       end
     end

data/lib/aspera/api/node.rb

@@ -16,8 +16,6 @@ module Aspera
     class Node < Aspera::Rest
       SCOPE_SEPARATOR = ':'
       SCOPE_NODE_PREFIX = 'node.'
-      # prefix for ruby code for filter (deprecated)
-      MATCH_EXEC_PREFIX = 'exec:'
       MATCH_TYPES = [String, Proc, Regexp, NilClass].freeze
       SIGNATURE_DELIMITER = '==SIGNATURE=='
       BEARER_TOKEN_VALIDITY_DEFAULT = 86400
@@ -25,7 +23,7 @@ module Aspera
       REQUIRED_APP_INFO_FIELDS = %i[api app node_info workspace_id workspace_name].freeze
       # methods of @app_info[:api]
       REQUIRED_APP_API_METHODS = %i[node_api_from add_ts_tags].freeze
-      private_constant :SCOPE_SEPARATOR, :SCOPE_NODE_PREFIX, :MATCH_EXEC_PREFIX, :MATCH_TYPES,
+      private_constant :SCOPE_SEPARATOR, :SCOPE_NODE_PREFIX, :MATCH_TYPES,
         :SIGNATURE_DELIMITER, :BEARER_TOKEN_VALIDITY_DEFAULT,
         :REQUIRED_APP_INFO_FIELDS, :REQUIRED_APP_API_METHODS
 
@@ -47,27 +45,20 @@ module Aspera
       @use_node_cache = true
 
       class << self
+        # set to false to read transfer parameters from download_setup
         attr_accessor :use_standard_ports
+        # set to false to bypass cache in redis
         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
+        # @param match_expression one of supported types
+        # @return lambda function
         def file_matcher(match_expression)
           case match_expression
           when Proc then return match_expression
           when Regexp then return ->(f){f['name'].match?(match_expression)}
           when String
-            if match_expression.start_with?(MATCH_EXEC_PREFIX)
-              code = "->(f){#{match_expression[MATCH_EXEC_PREFIX.length..-1]}}"
-              Log.log.warn{"Use of prefix #{MATCH_EXEC_PREFIX} is deprecated (4.15), instead use: @ruby:'#{code}'"}
-              return Environment.secure_eval(code, __FILE__, __LINE__)
-            end
-            return lambda{|f|File.fnmatch(match_expression, f['name'], File::FNM_DOTMATCH)}
+            return ->(f){File.fnmatch(match_expression, f['name'], File::FNM_DOTMATCH)}
           when NilClass then return ->(_){true}
           else Aspera.error_unexpected_value(match_expression.class.name, exception_class: Cli::BadArgument)
           end
@@ -158,7 +149,13 @@ module Aspera
 
       # 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]
+        headers = {'Accept' => 'application/json'}
+        headers[HEADER_X_CACHE_CONTROL] = 'no-cache' unless self.class.use_node_cache
+        return call(
+          operation: 'GET',
+          subpath:   subpath,
+          headers:   headers,
+          query:     query)[:data]
       end
 
       # update transfer spec with special additional tags
@@ -198,11 +195,11 @@ module Aspera
       # Recursively browse in a folder (with non-recursive method)
       # sub folders are processed if the processing method returns true
       # links are processed on the respective node
+      # @param method_sym [Symbol] processing method, arguments: entry, path, state
       # @param state [Object] state object sent to processing method
       # @param top_file_id [String] file id to start at (default = access key root file id)
       # @param top_file_path [String] path of top folder (default = /)
-      # @param block [Proc] processing method, arguments: entry, path, state
-      def process_folder_tree(method_sym:, state:, top_file_id:, top_file_path: '/')
+      def process_folder_tree(method_sym:, state:, top_file_id:, top_file_path: '/', query: nil)
         Aspera.assert(!top_file_path.nil?){'top_file_path not set'}
         Log.log.debug{"process_folder_tree: node=#{@app_info ? @app_info[:node_info]['id'] : 'nil'}, file id=#{top_file_id},  path=#{top_file_path}"}
         # start at top folder
@@ -215,7 +212,8 @@ module Aspera
           # get folder content
           folder_contents =
             begin
-              read("files/#{current_item[:id]}/files")
+              # TODO: use header
+              read_with_cache("files/#{current_item[:id]}/files")
             rescue StandardError => e
               Log.log.warn{"#{current_item[:path]}: #{e.class} #{e.message}"}
               []
@@ -228,21 +226,21 @@ module Aspera
               end
               next
             end
-            relative_path = File.join(current_item[:path], entry['name'])
-            Log.log.debug{"process_folder_tree: checking #{relative_path}"}
+            current_path = File.join(current_item[:path], entry['name'])
+            Log.log.debug{"process_folder_tree: checking #{current_path}"}
             # call block, continue only if method returns true
-            next unless send(method_sym, entry, relative_path, state)
+            next unless send(method_sym, entry, current_path, state)
             # entry type is file, folder or link
             case entry['type']
             when 'folder'
-              folders_to_explore.push({id: entry['id'], path: relative_path})
+              folders_to_explore.push({id: entry['id'], path: current_path})
             when 'link'
               if entry_has_link_information(entry)
                 node_id_to_node(entry['target_node_id'])&.process_folder_tree(
                   method_sym:    method_sym,
                   state:         state,
                   top_file_id:   entry['target_id'],
-                  top_file_path: relative_path)
+                  top_file_path: current_path)
               end
             end
           end
@@ -268,15 +266,21 @@ module Aspera
         return resolve_state[:result]
       end
 
-      def find_files(top_file_id, test_block)
+      def find_files(top_file_id, test_lambda)
         Log.log.debug{"find_files: file id=#{top_file_id}"}
-        find_state = {found: [], test_block: test_block}
+        find_state = {found: [], test_lambda: test_lambda}
         process_folder_tree(method_sym: :process_find_files, state: find_state, top_file_id: top_file_id)
         return find_state[:found]
       end
 
+      def list_files(top_file_id)
+        find_state = {found: []}
+        process_folder_tree(method_sym: :process_list_files, state: find_state, top_file_id: top_file_id)
+        return find_state[:found]
+      end
+
       def refreshed_transfer_token
-        return oauth.token(refresh: true)
+        return oauth.authorization(refresh: true)
       end
 
       # @return part of transfer spec with transport parameters only
@@ -296,6 +300,9 @@ module Aspera
       end
 
       # Create transfer spec for gen4
+      # @param file_id destination or source folder (id)
+      # @param direction one of Transfer::Spec::DIRECTION_SEND, Transfer::Spec::DIRECTION_RECEIVE
+      # @param ts_merge additional transfer spec to merge
       def transfer_spec_gen4(file_id, direction, ts_merge=nil)
         ak_name = nil
         ak_token = nil
@@ -303,12 +310,15 @@ module Aspera
         when :basic
           ak_name = auth_params[:username]
           Aspera.assert(auth_params[:password]){'no secret in node object'}
-          ak_token = Rest.basic_token(auth_params[:username], auth_params[:password])
+          ak_token = Rest.basic_authorization(auth_params[:username], auth_params[:password])
         when :oauth2
           ak_name = params[:headers][HEADER_X_ASPERA_ACCESS_KEY]
-          # TODO: token_generation_lambda = lambda{|do_refresh|oauth.token(refresh: do_refresh)}
+          # TODO: token_generation_lambda = lambda{|do_refresh|oauth.authorization(refresh: do_refresh)}
           # get bearer token, possibly use cache
-          ak_token = oauth.token
+          ak_token = oauth.authorization
+        when :none
+          ak_name = params[:headers][HEADER_X_ASPERA_ACCESS_KEY]
+          ak_token = params[:headers]['Authorization']
         else Aspera.error_unexpected_value(auth_params[:type])
         end
         transfer_spec = {
@@ -357,8 +367,8 @@ module Aspera
 
       private
 
+      # method called in loop for each entry for `resolve_api_fid`
       def process_api_fid(entry, path, state)
-        # this block is called recursively for each entry in folder
         # stop digging here if not in right path
         return false unless entry['name'].eql?(state[:path].first)
         # ok it matches, so we remove the match, and continue digging
@@ -401,11 +411,18 @@ module Aspera
         return true
       end
 
+      # method called in loop for each entry for `find_files`
       def process_find_files(entry, path, state)
-        state[:found].push(entry.merge({'path' => path})) if state[:test_block].call(entry)
+        state[:found].push(entry.merge({'path' => path})) if state[:test_lambda].call(entry)
         # test all files deeply
         return true
       end
+
+      # method called in loop for each entry for `list_files`
+      def process_list_files(entry, path, state)
+        state[:found].push(entry.merge({'path' => path}))
+        return false
+      end
     end
   end
 end

data/lib/aspera/ascp/installation.rb

@@ -3,11 +3,17 @@
 # cspell:ignore protobuf ckpt
 require 'aspera/environment'
 require 'aspera/data_repository'
-require 'aspera/ascp/products'
 require 'aspera/log'
 require 'aspera/rest'
+require 'aspera/uri_reader'
 require 'aspera/assert'
 require 'aspera/web_server_simple'
+require 'aspera/cli/info'
+require 'aspera/cli/version'
+require 'aspera/products/desktop'
+require 'aspera/products/connect'
+require 'aspera/products/transferd'
+require 'aspera/products/other'
 require 'English'
 require 'singleton'
 require 'xmlsimple'
@@ -20,15 +26,12 @@ module Aspera
     # 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
-    # but the user can specify ascp location by calling:
+    # 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
-      # protobuf generated files from sdk
-      EXT_RUBY_PROTOBUF = '_pb.rb'
-      RB_SDK_SUBFOLDER = 'lib'
       DEFAULT_ASPERA_CONF = <<~END_OF_CONFIG_FILE
         <?xml version='1.0' encoding='UTF-8'?>
         <CONF version="2">
@@ -44,14 +47,29 @@ module Aspera
       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
       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
+      # filename for ascp with optional extension (Windows)
+      private_constant :DEFAULT_ASPERA_CONF, :FILES, :TRANSFER_SDK_LOCATION_URL
       # options for SSH client private key
       CLIENT_SSH_KEY_OPTIONS = %i{dsa_rsa rsa per_client}.freeze
 
+      # Loads YAML from cloud with locations of SDK archives for all platforms
+      # @return location structure
+      def sdk_locations
+        location_url = @transferd_urls
+        transferd_locations = UriReader.read(location_url)
+        Log.log.debug{"Retrieving SDK locations from #{location_url}"}
+        begin
+          return YAML.load(transferd_locations)
+        rescue Psych::SyntaxError
+          raise "Error when parsing yaml data from: #{location_url}"
+        end
+      end
+
       # set ascp executable path
       def ascp_path=(v)
+        Aspera.assert_type(v, String)
+        Aspera.assert(!v.empty?) {'ascp path cannot be empty: check your config file'}
+        Aspera.assert(File.exist?(v)) {"No such file: [#{v}]"}
         @path_to_ascp = v
       end
 
@@ -59,31 +77,19 @@ module Aspera
         path(:ascp)
       end
 
-      # location of SDK files
+      # Compatibility
       def sdk_folder=(v)
-        Log.log.debug{"sdk_folder=#{v}"}
-        @sdk_dir = v
-        sdk_folder
-      end
-
-      # backward compatibility in sample program
-      alias_method :folder=, :sdk_folder=
-
-      # @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)
-        @sdk_dir
+        Products::Transferd.sdk_directory = v
       end
 
       # find ascp in named product (use value : FIRST_FOUND='FIRST' to just use first one)
-      # or select one from Products.installed_products()
+      # or select one from installed_products()
       def use_ascp_from_product(product_name)
         if product_name.eql?(FIRST_FOUND)
-          pl = Products.installed_products.first
-          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?
+          pl = installed_products.first
+          raise "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)}
+          pl = 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]
@@ -96,6 +102,8 @@ module Aspera
           m[v.to_s] =
             begin
               path(v)
+            rescue Errno::ENOENT => e
+              e.message.gsub(/.*assertion failed: /, '').gsub(/\): .*/, ')')
             rescue => e
               e.message
             end
@@ -103,7 +111,7 @@ module Aspera
       end
 
       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)
+        return Environment.write_file_restricted(File.join(Products::Transferd.sdk_directory, filename), force: force, mode: 0o644, &block)
       end
 
       # get path of one resource file of currently activated product
@@ -118,7 +126,7 @@ module Aspera
           file = @path_to_ascp.gsub('ascp', k.to_s)
         when :transferd
           file_is_optional = true
-          file = transferd_filepath
+          file = Products::Transferd.transferd_path
         when :ssh_private_dsa, :ssh_private_rsa
           # assume last 3 letters are type
           type = k.to_s[-3..-1].to_sym
@@ -128,8 +136,8 @@ module Aspera
         when :aspera_conf
           file = check_or_create_sdk_file('aspera.conf') {DEFAULT_ASPERA_CONF}
         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')
+          file_key = File.join(Products::Transferd.sdk_directory, 'aspera_fallback_cert_private_key.pem')
+          file_cert = File.join(Products::Transferd.sdk_directory, 'aspera_fallback_cert.pem')
           if !File.exist?(file_key) || !File.exist?(file_cert)
             require 'openssl'
             # create new self signed certificate for http fallback
@@ -143,7 +151,7 @@ module Aspera
         else Aspera.error_unexpected_value(k)
         end
         return nil if file_is_optional && !File.exist?(file)
-        Aspera.assert(File.exist?(file)){"no such file: #{file}"}
+        Aspera.assert(File.exist?(file), exception_class: Errno::ENOENT){"#{k} not found (#{file})"}
         return file
       end
 
@@ -231,18 +239,10 @@ module Aspera
       def ascp_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
@@ -255,6 +255,7 @@ module Aspera
         return info.first['url']
       end
 
+      # @param &block called with entry information
       def extract_archive_files(sdk_archive_path)
         raise 'missing block' unless block_given?
         case sdk_archive_path
@@ -265,7 +266,7 @@ module Aspera
           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)
+              yield(entry.name, entry.get_input_stream, nil)
             end
           end
         # Other Unixes use tar.gz
@@ -276,7 +277,7 @@ module Aspera
             Gem::Package::TarReader.new(gzip) do |tar|
               tar.each do |entry|
                 next if entry.directory?
-                yield(entry.full_name, entry)
+                yield(entry.full_name, entry, entry.symlink? ? entry.header.linkname : nil)
               end
             end
           end
@@ -285,54 +286,52 @@ module Aspera
         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
+      # Retrieves ascp binary for current system architecture from URL or file
+      # @param url      [String] URL to SDK archive, or SpecialValues::DEF
+      # @param folder   [String] Destination folder path
+      # @param backup   [Bool]   If destination folder exists, then rename
+      # @param with_exe [Bool]   If false, only retrieves files, but do not generate or restrict access
+      # @param &block   [Proc]   A lambda that receives a file path from archive and tells detination sub folder(end with /) or file, or nil to not extract
       # @return ascp version (from execution)
-      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?
+      def install_sdk(url: nil, version: nil, folder: nil, backup: true, with_exe: true, &block)
+        url = sdk_url_for_platform(version: version) if url.nil? || url.eql?('DEF')
+        folder = Products::Transferd.sdk_directory if folder.nil?
         subfolder_lambda = block
         if subfolder_lambda.nil?
+          # default files to extract directly to main folder if in selected source folders
           subfolder_lambda = ->(name) do
-            if SDK_ARCHIVE_FOLDERS.any?{|i|name.include?(i)}
-              '/'
-            elsif name.end_with?(EXT_RUBY_PROTOBUF)
-              RB_SDK_SUBFOLDER
-            end
+            Products::Transferd::RUNTIME_FOLDERS.any?{|i|name.match?(%r{^[^/]*/#{i}/})} ? '/' : nil
           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 url.start_with?(FILE_SCHEME_PREFIX)
-          sdk_archive_path = url[FILE_SCHEME_PREFIX.length..-1]
-          delete_archive = false
-        else
-          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 backup && !Dir.empty?(folder)
           Log.log.warn('Previous install exists, renaming folder.')
           File.rename(folder, "#{folder}.#{Time.now.strftime('%Y%m%d%H%M%S')}")
           # TODO: delete old archives ?
         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)
+        sdk_archive_path = UriReader.read_as_file(url)
+        extract_archive_files(sdk_archive_path) do |entry_name, entry_stream, link_target|
+          dest_folder = subfolder_lambda.call(entry_name)
+          next if dest_folder.nil?
+          dest_folder = File.join(folder, dest_folder)
+          if dest_folder.end_with?('/')
+            dest_file = File.join(dest_folder, File.basename(entry_name))
+          else
+            dest_file = dest_folder
+            dest_folder = File.dirname(dest_file)
+          end
           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)
+          if link_target.nil?
+            File.open(dest_file, 'wb') { |output_stream|IO.copy_stream(entry_stream, output_stream)}
+          else
+            File.symlink(link_target, dest_file)
           end
         end
-        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_file = Environment.exe_file('ascp')
         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|
@@ -340,16 +339,18 @@ module Aspera
           Environment.restrict_file_access(exe_path, mode: 0o755) if File.exist?(exe_path)
         end
         sdk_ascp_version = get_ascp_version(sdk_ascp_path)
-        sdk_daemon_path = transferd_filepath
-        Log.log.warn{"No #{sdk_daemon_path} in SDK archive"} unless File.exist?(sdk_daemon_path)
-        Environment.restrict_file_access(sdk_daemon_path, mode: 0o755) if File.exist?(sdk_daemon_path)
-        transferd_version = get_exe_version(sdk_daemon_path, 'version')
+        transferd_exe_path = Products::Transferd.transferd_path
+        Log.log.warn{"No #{transferd_exe_path} in SDK archive"} unless File.exist?(transferd_exe_path)
+        Environment.restrict_file_access(transferd_exe_path, mode: 0o755) if File.exist?(transferd_exe_path)
+        transferd_version = get_exe_version(transferd_exe_path, 'version')
         sdk_name = 'IBM Aspera Transfer SDK'
         sdk_version = transferd_version || sdk_ascp_version
-        File.write(File.join(folder, Products::INFO_META_FILE), "<product><name>#{sdk_name}</name><version>#{sdk_version}</version></product>")
+        File.write(File.join(folder, Products::Other::INFO_META_FILE), "<product><name>#{sdk_name}</name><version>#{sdk_version}</version></product>")
         return sdk_name, sdk_version
       end
 
+      attr_accessor :transferd_urls
+
       private
 
       # policy for product selection
@@ -358,10 +359,30 @@ module Aspera
       def initialize
         @path_to_ascp = nil
         @sdk_dir = nil
+        @found_products = nil
+        @transferd_urls = TRANSFER_SDK_LOCATION_URL
       end
 
-      def transferd_filepath
-        return File.join(sdk_folder, 'asperatransferd' + Environment.exe_extension) # cspell:disable-line
+      public
+
+      # @return the list of installed products in format of product_locations_on_current_os
+      def installed_products
+        if @found_products.nil?
+          # :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
+          scan_locations = Products::Transferd.locations.concat(
+            Products::Desktop.locations,
+            Products::Connect.locations,
+            Products::Other::LOCATION_ON_THIS_OS
+          )
+          # .each {|item| item.deep_do {|h, _k, _v, _m|h.freeze}}.freeze
+          # search installed products: with ascp
+          @found_products = Products::Other.find(scan_locations)
+        end
+        return @found_products
       end
     end
   end

data/lib/aspera/ascp/management.rb

@@ -198,18 +198,39 @@ module Aspera
       BOOLEAN_FIELDS = %w[Encryption Remote RateLock MinRateLock PolicyLock FilesEncrypt FilesDecrypt VLinkLocalEnabled VLinkRemoteEnabled
                           MoveRange Keepalive TestLogin UseProxy Precalc RTTAutocorrect].freeze
       BOOLEAN_TRUE = 'Yes'
+
+      private_constant :OPERATIONS, :PARAMETERS, :MGT_HEADER, :MGT_FRAME_SEPARATOR, :INTEGER_FIELDS, :BOOLEAN_FIELDS, :BOOLEAN_TRUE
       # cspell: enable
 
       class << self
         # translates mgt port event into (enhanced) typed event
         def enhanced_event_format(event)
           return event.keys.each_with_object({}) do |e, h|
-            new_name = e.capital_to_snake.gsub(/(usec)$/, '_\1').downcase
-            value = event[e]
-            value = value.to_i if INTEGER_FIELDS.include?(e)
-            value = value.eql?(BOOLEAN_TRUE) if BOOLEAN_FIELDS.include?(e)
-            h[new_name] = value
-          end
+                   new_name =
+                     case e
+                     when 'Elapsedusec' then 'elapsed_usec'
+                     when 'Bytescont' then 'bytes_cont'
+                     else e.capital_to_snake
+                     end
+                   h[new_name] =
+                     if INTEGER_FIELDS.include?(e) then event[e].to_i
+                     elsif BOOLEAN_FIELDS.include?(e) then event[e].eql?(BOOLEAN_TRUE)
+                     else
+                       event[e]
+                     end
+                 end
+        end
+
+        # build command to send on management port
+        # @param data [Hash] {'type'=>'START','source'=>_path_,'destination'=>_path_}
+        def command_to_stream(data)
+          # TODO: translate enhanced to capitalized ?
+          data
+            .keys
+            .map{|k|"#{k.capitalize}: #{data[k]}"}
+            .unshift(MGT_HEADER)
+            .push('', '')
+            .join("\n")
         end
       end