aspera-cli 4.24.1 → 4.25.0.pre

data/lib/aspera/sync/database.rb

@@ -8,7 +8,7 @@ else
   require 'sqlite3'
 end
 
-# A wrapper class that provides common API for Ruby and JRuby
+# A wrapper class that provides common API for sqlite in both Ruby and JRuby
 class SqLite3Wrapper
   def initialize(db_path)
     @db_path = db_path
@@ -52,6 +52,7 @@ end
 
 module Aspera
   module Sync
+    # Access `async` sqlite database
     class Database
       def initialize(db_path)
         @db = SqLite3Wrapper.new(db_path)

data/lib/aspera/sync/operations.rb

@@ -18,26 +18,28 @@ module Aspera
   module Sync
     # builds command line arg for async and execute it
     module Operations
-      # sync direction
+      # Sync direction
       DIRECTIONS = %i[push pull bidi].freeze
-      # default direction for sync
-      DEFAULT_DIRECTION = :push
+      # Default direction for sync
+      DEFAULT_DIRECTION = DIRECTIONS.first
+
+      SCP_REMOTE_REGEX = /\A(?:(?:(?<user>[^@:\s]+)@)?(?<host>[^:\s]+):)?(?<path>.+)\z/
 
       class << self
         # Set `remote_dir` in sync parameters based on transfer spec
-        # @param params [Hash] Sync parameters, old or new format
-        # @param remote_dir_key [String] key to update in above hash
-        # @param transfer_spec [Hash] transfer spec
-        def update_remote_dir(params, remote_dir_key, transfer_spec)
+        # @param sync_info      [Hash]   Sync parameters, in `conf` or `args` format.
+        # @param remote_dir_key [String] Key to update in above hash
+        # @param transfer_spec  [Hash]   Transfer spec
+        def update_remote_dir(sync_info, remote_dir_key, transfer_spec)
           if transfer_spec.dig(*%w[tags aspera node file_id])
             # in AoC, use gen4
-            params[remote_dir_key] = '/'
+            sync_info[remote_dir_key] = '/'
           elsif transfer_spec['cookie']&.start_with?('aspera.shares2')
             # TODO : something more generic, independent of Shares
             # in Shares, the actual folder on remote end is not always the same as the name of the share
             remote_key = transfer_spec['direction'].eql?('send') ? 'destination' : 'source'
             actual_remote = transfer_spec['paths']&.first&.[](remote_key)
-            params[remote_dir_key] = actual_remote if actual_remote
+            sync_info[remote_dir_key] = actual_remote if actual_remote
           end
           nil
         end
@@ -70,36 +72,36 @@ module Aspera
         end
 
         # Get symbol of sync direction, defaulting to :push
-        # @param params [Hash] Sync parameters, old or new format
+        # @param sync_info [Hash] Sync parameters, `conf` or `args` format
         # @return [Symbol] direction symbol, one of :push, :pull, :bidi
-        def direction_sym(params)
-          (params['direction'] || DEFAULT_DIRECTION).to_sym
+        def direction_sym(sync_info)
+          (sync_info['direction'] || DEFAULT_DIRECTION).to_sym
         end
 
         # Start the sync process
-        # @param params [Hash] Sync parameters, old or new format
-        # @param opt_ts [Hash] Optional transfer spec
-        # @param &block [nil, Proc] block to generate transfer spec, takes: direction (one of DIRECTIONS), local_dir, remote_dir
-        def start(params, opt_ts = nil)
-          Log.dump(:sync_params_initial, params)
-          Aspera.assert_type(params, Hash)
-          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+        # @param sync_info [Hash] Sync parameters, old or new format
+        # @param opt_ts    [Hash] Optional transfer spec
+        # @param &block    [nil, Proc] block to generate transfer spec, takes: `direction` (one of DIRECTIONS), `local_dir`, `remote_dir`
+        def start(sync_info, opt_ts = nil)
+          Log.dump(:sync_params_initial, sync_info)
+          Aspera.assert_type(sync_info, Hash)
+          Aspera.assert(PARAM_KEYS.any?{ |k| sync_info.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
           env_args = {
             args: [],
             env:  {}
           }
-          if params.key?('local')
-            # "conf" format
-            Aspera.assert_type(params['local'], Hash){'local'}
-            remote = params['remote']
+          if sync_info.key?('local')
+            # `conf` format
+            Aspera.assert_type(sync_info['local'], Hash){'local'}
+            remote = sync_info['remote']
             Aspera.assert_type(remote, Hash){'remote'}
             Aspera.assert_type(remote['path'], String){'remote path'}
             # get transfer spec if possible, and feed back to new structure
             if block_given?
-              transfer_spec = yield(direction_sym(params), params['local']['path'], remote['path'])
+              transfer_spec = yield(direction_sym(sync_info), sync_info['local']['path'], remote['path'])
               Log.dump(:auth_ts, transfer_spec)
               transfer_spec.deep_merge!(opt_ts) unless opt_ts.nil?
-              tspec_to_sync_info(transfer_spec, params, CONF_SCHEMA)
+              tspec_to_sync_info(transfer_spec, sync_info, CONF_SCHEMA)
               update_remote_dir(remote, 'path', transfer_spec)
             end
             remote['connect_mode'] ||= transfer_spec['wss_enabled'] ? 'ws' : 'ssh'
@@ -109,38 +111,38 @@ module Aspera
               remote['private_key_paths'].concat(add_certificates)
             end
             # '--exclusive-mgmt-port=12345', '--arg-err-path=-',
-            env_args[:args] = ["--conf64=#{Base64.strict_encode64(JSON.generate(params))}"]
-            Log.dump(:sync_conf, params)
+            env_args[:args] = ["--conf64=#{Base64.strict_encode64(JSON.generate(sync_info))}"]
+            Log.dump(:sync_conf, sync_info)
             agent = Agent::Direct.new
             agent.start_and_monitor_process(session: {}, name: :async, **env_args)
           else
-            # "args" format
+            # `args` format
             raise StandardError, "Only 'sessions', and optionally 'instance' keys are allowed" unless
-              params.keys.push('instance').uniq.sort.eql?(CMDLINE_PARAMS_KEYS)
-            Aspera.assert_type(params['sessions'], Array)
-            Aspera.assert_type(params['sessions'].first, Hash)
+              sync_info.keys.push('instance').uniq.sort.eql?(CMDLINE_PARAMS_KEYS)
+            Aspera.assert_type(sync_info['sessions'], Array)
+            Aspera.assert_type(sync_info['sessions'].first, Hash)
             if block_given?
-              params['sessions'].each do |session|
+              sync_info['sessions'].each do |session|
                 Aspera.assert_type(session['local_dir'], String){'local_dir'}
                 Aspera.assert_type(session['remote_dir'], String){'remote_dir'}
                 transfer_spec = yield(direction_sym(session), session['local_dir'], session['remote_dir'])
                 Log.dump(:auth_ts, transfer_spec)
                 transfer_spec.deep_merge!(opt_ts) unless opt_ts.nil?
-                tspec_to_sync_info(transfer_spec, session, SESSION_SCHEMA)
+                tspec_to_sync_info(transfer_spec, session, ARGS_SESSION_SCHEMA)
                 session['private_key_paths'] = Ascp::Installation.instance.aspera_token_ssh_key_paths(:rsa) if transfer_spec.key?('token')
                 update_remote_dir(session, 'remote_dir', transfer_spec)
               end
             end
-            if params.key?('instance')
-              Aspera.assert_type(params['instance'], Hash)
-              instance_builder = CommandLineBuilder.new(params['instance'], INSTANCE_SCHEMA, CommandLineConverter)
+            if sync_info.key?('instance')
+              Aspera.assert_type(sync_info['instance'], Hash)
+              instance_builder = CommandLineBuilder.new(sync_info['instance'], ARGS_INSTANCE_SCHEMA, CommandLineConverter)
               instance_builder.process_params
               instance_builder.add_env_args(env_args)
             end
-            params['sessions'].each do |session_params|
+            sync_info['sessions'].each do |session_params|
               Aspera.assert_type(session_params, Hash)
               Aspera.assert(session_params.key?('name')){'session must contain at least: name'}
-              session_builder = CommandLineBuilder.new(session_params, SESSION_SCHEMA, CommandLineConverter)
+              session_builder = CommandLineBuilder.new(session_params, ARGS_SESSION_SCHEMA, CommandLineConverter)
               session_builder.process_params
               session_builder.add_env_args(env_args)
             end
@@ -168,24 +170,24 @@ module Aspera
         end
 
         # Run `asyncadmin` to get status of sync session
-        # @param params [Hash] sync parameters in conf or args format
+        # @param sync_info [Hash] sync parameters in conf or args format
         # @return [Hash] parsed output of asyncadmin
-        def admin_status(params)
-          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+        def admin_status(sync_info)
+          Aspera.assert(PARAM_KEYS.any?{ |k| sync_info.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
           arguments = ['--quiet']
-          if params.key?('local')
-            # "conf" format
-            arguments.push("--name=#{params['name']}")
-            if params.key?('local_db_dir')
-              arguments.push("--local-db-dir=#{params['local_db_dir']}")
-            elsif params.dig('local', 'path')
-              arguments.push("--local-dir=#{params.dig('local', 'path')}")
+          if sync_info.key?('local')
+            # `conf` format
+            arguments.push("--name=#{sync_info['name']}")
+            if sync_info.key?('local_db_dir')
+              arguments.push("--local-db-dir=#{sync_info['local_db_dir']}")
+            elsif sync_info.dig('local', 'path')
+              arguments.push("--local-dir=#{sync_info.dig('local', 'path')}")
             else
               raise Error, 'Missing either local_db_dir or local.path'
             end
           else
-            # "args" format
-            session = params['sessions'].first
+            # `args` format
+            session = sync_info['sessions'].first
             arguments.push("--name=#{session['name']}")
             if session.key?('local_db_dir')
               arguments.push("--local-db-dir=#{session['local_db_dir']}")
@@ -199,23 +201,23 @@ module Aspera
           return parse_status(stdout)
         end
 
-        # Find the local database folder based on params
-        # @param params [Hash] sync parameters in conf or args format
-        # @return [String, nil] path to "local DB dir", i.e. folder that contains folders that contain snap.db
-        def local_db_folder(params)
-          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
-          if params.key?('local')
-            # "conf" format
-            if params.key?('local_db_dir')
-              return params['local_db_dir']
-            elsif (local_path = params.dig('local', 'path'))
+        # Find the local database folder based on sync_info
+        # @param sync_info [Hash] sync parameters in conf or args format
+        # @return [String, nil] Path to "local DB dir", i.e. folder that contains folders that contain `snap.db`
+        def local_db_folder(sync_info)
+          Aspera.assert(PARAM_KEYS.any?{ |k| sync_info.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+          if sync_info.key?('local')
+            # `conf` format
+            if sync_info.key?('local_db_dir')
+              return sync_info['local_db_dir']
+            elsif (local_path = sync_info.dig('local', 'path'))
               return local_path
             elsif exception
               raise Error, 'Missing either local_db_dir or local.path'
             end
           else
-            # "args" format
-            session = params['sessions'].first
+            # `args` format
+            session = sync_info['sessions'].first
             if session.key?('local_db_dir')
               return session['local_db_dir']
             elsif session.key?('local_dir')
@@ -227,19 +229,19 @@ module Aspera
           nil
         end
 
-        def session_name(params)
-          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
-          if params.key?('local')
-            # "conf" format
-            return params['name']
+        def session_name(sync_info)
+          Aspera.assert(PARAM_KEYS.any?{ |k| sync_info.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+          if sync_info.key?('local')
+            # `conf` format
+            return sync_info['name']
           else
-            # "args" format
-            return params['sessions'].first['name']
+            # `args` format
+            return sync_info['sessions'].first['name']
           end
         end
 
-        def session_db_file(params)
-          db_file = File.join(local_db_folder(params), PRIVATE_FOLDER, session_name(params), ASYNC_DB)
+        def session_db_file(sync_info)
+          db_file = File.join(local_db_folder(sync_info), PRIVATE_FOLDER, session_name(sync_info), ASYNC_DB)
           Aspera.assert(File.exist?(db_file)){"Database file #{db_file} does not exist"}
           db_file
         end
@@ -274,23 +276,77 @@ module Aspera
             end
           end
         end
+
+        # Search given option in JSON Schema tree
+        # @param schema [Hash]   JSON Schema tree (root or sub-tree)
+        # @param path   [Array]  Path to subtree
+        # @param option [String] Option to search
+        # @return [Array,nil] with path/schema for that option
+        def find_option(schema, path, option)
+          if %w[x-cli-option x-cli-short].any?{ |i| schema[i].eql?(option)}
+            Log.log.debug('Special') if schema['x-cli-special']
+            return [path, schema]
+          end
+          if schema['type'].eql?('object')
+            schema['properties']&.each do |name, props|
+              res = find_option(props, path + [name], option)
+              return res unless res.nil?
+            end
+          end
+          return
+        end
+
+        # Translate `async` native command line arguments to `conf` JSON
+        def args_to_conf(args)
+          result = {}
+          while args.any?
+            option = args.shift
+            if option =~ /^(--[^=]+)=(.*)$/
+              option = ::Regexp.last_match(1) # "--toto"
+              args.unshift(::Regexp.last_match(2))
+            end
+            if option.eql?('--preserve-time') || option.eql?('-t')
+              args.unshift('--preserve-creation-time') if Environment.instance.os.eql?(Environment::OS_WINDOWS)
+              option = '--preserve-modification-time'
+            end
+            if option.eql?('--remote') || option.eql?('-r')
+              value = args.first
+              if (m = SCP_REMOTE_REGEX.match(value))
+                if m[:host]
+                  args.shift
+                  args.unshift("--host=#{m[:host]}")
+                  args.unshift("--user=#{m[:user]}") if m[:user]
+                  args.unshift(m[:path])
+                end
+              end
+            end
+            path, props = find_option(CONF_SCHEMA, [], option)
+            raise "Option not found: #{option}" if path.nil?
+            last_key = path.pop
+            # navigate in the current result to insert the value
+            current = result
+            path.each do |key|
+              current[key] ||= {}
+              current = current[key]
+            end
+            current[last_key] = props['x-cli-switch'] ? true : args.shift
+          end
+          return result
+        end
       end
       # Private stuff:
       # Read JSON schema and mapping to command line options
-      INSTANCE_SCHEMA = CommandLineBuilder.read_schema(__FILE__, 'args')
-      SESSION_SCHEMA = INSTANCE_SCHEMA['properties']['sessions']['items']
-      INSTANCE_SCHEMA['properties'].delete('sessions')
-      CONF_SCHEMA = CommandLineBuilder.read_schema(__FILE__, 'conf')
-      CommandLineBuilder.adjust_properties_defaults(INSTANCE_SCHEMA['properties'])
-      CommandLineBuilder.adjust_properties_defaults(SESSION_SCHEMA['properties'])
-      CommandLineBuilder.adjust_properties_defaults(CONF_SCHEMA['properties'])
+      ARGS_INSTANCE_SCHEMA = CommandLineBuilder.read_schema(__dir__, 'args')
+      ARGS_SESSION_SCHEMA = ARGS_INSTANCE_SCHEMA['properties']['sessions']['items']
+      ARGS_INSTANCE_SCHEMA['properties'].delete('sessions')
+      CONF_SCHEMA = CommandLineBuilder.read_schema(__dir__, 'conf')
       CMDLINE_PARAMS_KEYS = %w[instance sessions].freeze
       ASYNC_ADMIN_EXECUTABLE = 'asyncadmin'
       PRIVATE_FOLDER = '.private-asp'
       ASYNC_DB = 'snap.db'
       PARAM_KEYS = %w[local sessions].freeze
 
-      private_constant :INSTANCE_SCHEMA, :SESSION_SCHEMA, :CONF_SCHEMA, :CMDLINE_PARAMS_KEYS, :ASYNC_ADMIN_EXECUTABLE, :PRIVATE_FOLDER, :ASYNC_DB, :PARAM_KEYS
+      private_constant :ARGS_INSTANCE_SCHEMA, :ARGS_SESSION_SCHEMA, :CMDLINE_PARAMS_KEYS, :ASYNC_ADMIN_EXECUTABLE, :PRIVATE_FOLDER, :ASYNC_DB, :PARAM_KEYS
     end
   end
 end

data/lib/aspera/temp_file_manager.rb

@@ -17,17 +17,29 @@ module Aspera
     private_constant :SEC_IN_DAY, :FILE_LIST_AGE_MAX_SEC
 
     attr_accessor :cleanup_on_exit
+    attr_reader :global_temp
 
     def initialize
       @created_files = []
       @cleanup_on_exit = true
+      @global_temp = Etc.systmpdir
+    end
+
+    def global_temp=(value)
+      @global_temp = case value
+      when '@env' then Dir.tmpdir
+      when '@sys' then Etc.systmpdir
+      else value
+      end
     end
 
     def delete_file(filepath)
       File.delete(filepath) if @cleanup_on_exit
+    rescue => e
+      Log.log.warn{"Problem deleting file: #{filepath}: #{e.message}"}
     end
 
-    # call this on process exit
+    # Call this on process exit
     def cleanup
       @created_files.each do |filepath|
         delete_file(filepath) if File.file?(filepath)
@@ -35,7 +47,7 @@ module Aspera
       @created_files = []
     end
 
-    # ensure that provided folder exists, or create it, generate a unique filename
+    # Ensure that provided folder exists, or create it, generate a unique filename
     # @return path to that unique file
     def new_file_path_in_folder(temp_folder, prefix: nil, suffix: nil)
       FileUtils.mkdir_p(temp_folder)
@@ -44,7 +56,7 @@ module Aspera
       new_file
     end
 
-    # same as above but in global temp folder, with user's name
+    # Same as above but in global temp folder, with user's name
     def new_file_path_global(prefix = nil, suffix: nil)
       username =
         begin
@@ -53,11 +65,11 @@ module Aspera
           'unknown_user'
         end
       prefix = [prefix, username].compact.join('-')
-      new_file_path_in_folder(Etc.systmpdir, prefix: prefix, suffix: suffix)
+      new_file_path_in_folder(@global_temp, prefix: prefix, suffix: suffix)
     end
 
+    # Garbage collect undeleted files
     def cleanup_expired(temp_folder)
-      # garbage collect undeleted files
       Dir.entries(temp_folder).each do |name|
         file_path = File.join(temp_folder, name)
         age_sec = (Time.now - File.stat(file_path).mtime).to_i

data/lib/aspera/transfer/error.rb

@@ -1,24 +1,33 @@
 # frozen_string_literal: true
 
-require 'aspera/transfer/error_info'
+require 'aspera/ascp/management'
 
 module Aspera
   module Transfer
-    # error raised if transfer fails
+    # Error raised if transfer fails
     class Error < StandardError
+      # Error code like on management port
       attr_reader :err_code
 
-      def initialize(message, err_code = nil)
-        super(message)
-        @err_code = err_code
+      # @param description [String] `Description` on management port
+      # @param code [Integer] `Description` on management port, use zero if unknown
+      def initialize(description, code: nil)
+        super(description)
+        @err_code = code.to_i
       end
 
+      # @return [Hash] Information on that error
       def info
-        r = ERROR_INFO[@err_code] || {r: false, c: 'UNKNOWN', m: 'unknown', a: 'unknown'}
+        r = Ascp::Management::ERRORS[@err_code] || Ascp::Management::ERRORS[0]
         return r.merge({i: @err_code})
       end
 
-      def retryable?; info[:r]; end
+      # Is that transfer error retryable ?
+      # @param message [String, nil] Optional actual message on management port
+      def retryable?
+        return false if @err_code.eql?(14) && message.eql?('Target address not available')
+        info[:r]
+      end
     end
   end
 end

data/lib/aspera/transfer/parameters.rb

@@ -18,11 +18,8 @@ require 'openssl'
 
 module Aspera
   module Transfer
-    # translate transfer specification to ascp parameter list
+    # Translate transfer specification to `ascp` parameter list
     class Parameters
-      # `ascp` options to provide a file list
-      FILE_LIST_OPTIONS = ['--file-list', '--file-pair-list'].freeze
-      private_constant :FILE_LIST_OPTIONS
       HTTP_FALLBACK_ACTIVATION_VALUES = ['1', 1, true, 'force'].freeze
 
       class << self
@@ -30,7 +27,6 @@ module Aspera
         def file_list_folder=(value)
           @file_list_folder = value
           return if @file_list_folder.nil?
-
           FileUtils.mkdir_p(@file_list_folder)
           TempFileManager.instance.cleanup_expired(@file_list_folder)
         end
@@ -42,14 +38,19 @@ module Aspera
           @file_list_folder ||= TempFileManager.instance.new_file_path_global('asession_filelists')
         end
 
-        # file list is provided directly with ascp arguments
+        # File list is provided directly with ascp arguments
         # @columns ascp_args [Array,NilClass] ascp arguments
         def ascp_args_file_list?(ascp_args)
           ascp_args&.any?{ |i| FILE_LIST_OPTIONS.include?(i)}
         end
       end
 
-      # @columns options [Hash] key: :wss: bool, :ascp_args: array of strings
+      # @param job_spec        [Hash]   Transfer spec
+      # @param ascp_args       [Array]  Other ascp args
+      # @param quiet           [Bool]   Remove ascp output
+      # @param trusted_certs   [Array]  Trusted certificates
+      # @param client_ssh_key  [Symbol] :rsa or :dsa
+      # @param check_ignore_cb [Proc]   Callback
       def initialize(
         job_spec,
         ascp_args:       nil,
@@ -60,17 +61,16 @@ module Aspera
         check_ignore_cb: nil
       )
         @job_spec = job_spec
+        Aspera.assert_type(@job_spec, Hash)
         @ascp_args = ascp_args.nil? ? [] : ascp_args
+        Aspera.assert_array_all(@ascp_args, String){'ascp_args'}
         @wss = wss
         @quiet = quiet
         @trusted_certs = trusted_certs.nil? ? [] : trusted_certs
-        @client_ssh_key = client_ssh_key.nil? ? :rsa : client_ssh_key.to_sym
-        @check_ignore_cb = check_ignore_cb
-        Aspera.assert_type(@job_spec, Hash)
-        Aspera.assert_type(@ascp_args, Array){'ascp_args'}
-        Aspera.assert(@ascp_args.all?(String)){'all ascp arguments must be String'}
         Aspera.assert_type(@trusted_certs, Array){'trusted_certs'}
+        @client_ssh_key = client_ssh_key.nil? ? :rsa : client_ssh_key.to_sym
         Aspera.assert_values(@client_ssh_key, Ascp::Installation::CLIENT_SSH_KEY_OPTIONS)
+        @check_ignore_cb = check_ignore_cb
         @builder = CommandLineBuilder.new(@job_spec, Spec::SCHEMA, CommandLineConverter)
       end
 
@@ -109,7 +109,7 @@ module Aspera
             Log.log.debug{"#{file_list_option}=\n#{File.read(file_list_file)}".red}
           end
         end
-        @builder.add_command_line_options(["#{file_list_option}=#{file_list_file}"]) unless file_list_option.nil?
+        @builder.add_command_line_options("#{file_list_option}=#{file_list_file}") unless file_list_option.nil?
       end
 
       # @return the list of certificates (option `-i`) to use when token/ssh or wss are used
@@ -118,7 +118,7 @@ module Aspera
         # use web socket secure for session ?
         if @builder.read_param('wss_enabled') && (@wss || !@job_spec.key?('fasp_port'))
           # by default use web socket session if available, unless removed by user
-          @builder.add_command_line_options(['--ws-connect'])
+          @builder.add_command_line_options('--ws-connect')
           # TODO: option to give order ssh,ws (legacy http is implied by ssh)
           # This will need to be cleaned up in aspera core
           @job_spec['ssh_port'] = @builder.read_param('wss_port')
@@ -148,7 +148,7 @@ module Aspera
         return certificates_to_use
       end
 
-      # translate transfer spec to env vars and command line arguments for ascp
+      # Translate transfer spec to env vars and command line arguments for `ascp`
       def ascp_args
         env_args = {
           args: [],
@@ -156,18 +156,27 @@ module Aspera
           name: :ascp
         }
 
-        # special cases
+        # Special cases
         @job_spec.delete('source_root') if @job_spec.key?('source_root') && @job_spec['source_root'].empty?
 
-        # notify multi-session was already used, anyway it was deleted by agent direct
+        # Notify multi-session was already used, anyway it was deleted by agent direct
         Aspera.assert(!@builder.read_param('multi_session'))
 
-        # add ssh or wss certificates
+        # Add ssh or wss certificates
         # (reverse, to keep order, as we unshift)
         remote_certificates&.reverse_each do |cert|
           env_args[:args].unshift('-i', cert)
         end
 
+        case (delete_source = @builder.read_param('delete_source'))
+        when true
+          DELETE_EQUIV.each{ |i| @job_spec[i] = true}
+        when false
+          DELETE_EQUIV.each{ |i| @job_spec.delete(i)}
+        when nil
+        else Aspera.error_unexpected_value(delete_source){'delete_source'}
+        end
+
         # process parameters as specified in table
         @builder.process_params
 
@@ -180,7 +189,7 @@ module Aspera
           base64_destination = true
         end
         # destination will be base64 encoded, put this before source path arguments
-        @builder.add_command_line_options(['--dest64']) if base64_destination
+        @builder.add_command_line_options('--dest64') if base64_destination
         # optional arguments, at the end to override previous ones (to allow override)
         @builder.add_command_line_options(@ascp_args)
         # get list of source files to transfer and build arg for ascp
@@ -190,7 +199,7 @@ module Aspera
         # ascp4 does not support base64 encoding of destination
         destination_folder = Base64.strict_encode64(destination_folder) if base64_destination
         # destination MUST be last command line argument to ascp
-        @builder.add_command_line_options([destination_folder])
+        @builder.add_command_line_options(destination_folder)
         @builder.add_env_args(env_args)
         env_args[:args].unshift('-q') if @quiet
         # add fallback cert and key as arguments if needed
@@ -198,11 +207,15 @@ module Aspera
           env_args[:args].unshift('-Y', Ascp::Installation.instance.path(:fallback_private_key))
           env_args[:args].unshift('-I', Ascp::Installation.instance.path(:fallback_certificate))
         end
-        # disable redis in client
-        env_args[:env]['ASPERA_TEST_REDIS_DISABLE'] = 'true'
+        # disable redis in client, only for ascp, this makes ascp4 fail
+        env_args[:env]['ASPERA_TEST_REDIS_DISABLE'] = 'true' if env_args[:name].eql?(:ascp)
         Log.log.debug{"ascp args: #{env_args}"}
         return env_args
       end
+      DELETE_EQUIV = %w[remove_after_transfer remove_empty_directories remove_empty_source_directory]
+      # `ascp` options to provide a file list
+      FILE_LIST_OPTIONS = ['--file-list', '--file-pair-list'].freeze
+      private_constant :DELETE_EQUIV, :FILE_LIST_OPTIONS
     end
   end
 end