aspera-cli 4.22.0 → 4.24.0

data/bin/ascli

@@ -12,5 +12,6 @@ $VERBOSE = old_verbose
 require 'aspera/coverage'
 require 'aspera/environment'
 require 'aspera/cli/main'
-Aspera::Environment.fix_home
+Aspera::Cli::Main.early_debug_setup(ARGV)
+Aspera::Environment.instance.fix_home
 Aspera::Cli::Main.new(ARGV).process_command_line

data/bin/asession

@@ -21,6 +21,7 @@ SAMPLE_DEMO = '"remote_host":"demo.asperasoft.com","remote_user":"asperaweb","ss
 SAMPLE_DEMO2 = '"direction":"receive","destination_root":"./test.dir"'
 def assert_usage(assertion, error_message)
   return if assertion
+  # rubocop:disable Style/StderrPuts
   $stderr.puts('ERROR: '.red.blink + error_message) if error_message
   $stderr.puts('USAGE')
   $stderr.puts('    asession')
@@ -47,6 +48,7 @@ def assert_usage(assertion, error_message)
   $stderr.puts('EXAMPLES')
   $stderr.puts(%Q(    asession @json:'{"#{PARAM_SPEC}":{#{SAMPLE_DEMO},#{SAMPLE_DEMO2},"paths":[{"source":"/aspera-test-dir-tiny/200KB.1"}]}}'))
   $stderr.puts(%Q(    echo '{"#{PARAM_SPEC}":{"remote_host":...}}'|asession @json:@stdin))
+  # rubocop:enable Style/StderrPuts
   Process.exit(0)
 end
 parameter_source_err_msg = ' (argument), did you specify: "@json:" ?'
@@ -71,9 +73,7 @@ assert_usage(session_spec[PARAM_SPEC].is_a?(Hash), "The value must contain key #
 # additional debug capability
 Aspera::Log.instance.level = session_spec[PARAM_LOG_LEVEL] if session_spec.key?(PARAM_LOG_LEVEL)
 # possibly override temp folder
-if session_spec.key?(PARAM_TMP_FILE_LIST_FOLDER)
-  Aspera::Transfer::Parameters.file_list_folder = session_spec[PARAM_TMP_FILE_LIST_FOLDER]
-end
+Aspera::Transfer::Parameters.file_list_folder = session_spec[PARAM_TMP_FILE_LIST_FOLDER] if session_spec.key?(PARAM_TMP_FILE_LIST_FOLDER)
 session_spec[PARAM_SDK] = File.join(Dir.home, '.aspera', 'sdk') unless session_spec.key?(PARAM_SDK)
 Aspera::Products::Transferd.sdk_directory = session_spec[PARAM_SDK]
 session_spec[PARAM_AGENT] = {} unless session_spec.key?(PARAM_AGENT)
@@ -90,7 +90,7 @@ job_id = client.start_transfer(session_spec[PARAM_SPEC])
 Thread.new do
   # we assume here a single session
   session_id = client.sessions_by_job(job_id).first
-  begin # rubocop:disable Style/RedundantBegin
+  begin
     loop do
       data = JSON.parse($stdin.gets)
       client.send_command(session_id, data)

data/lib/aspera/agent/base.rb

@@ -5,6 +5,10 @@ require 'aspera/assert'
 module Aspera
   module Agent
     # Base class for transfer agents
+    # Transfer agents provide methods:
+    # - `start_transfer` : take a transfer spec and start a transfer asynchronously
+    # - `wait_for_transfers_completion` : waits for all transfer sessions to finish
+    # - `notify_progress` : called back by transfer agent to notify transfer progress
     class Base
       RUBY_EXT = '.rb'
       private_constant :RUBY_EXT

data/lib/aspera/agent/connect.rb

@@ -21,27 +21,25 @@ module Aspera
         @connect_settings = {
           'app_id' => SecureRandom.uuid
         }
-        raise 'Using connect requires a graphical environment' if !Environment.default_gui_mode.eql?(:graphical)
+        raise Error, 'Using connect requires a graphical environment' unless Environment.instance.graphical?
         method_index = 0
         begin
           connect_url = connect_api_url
           Log.log.debug{"found: #{connect_url}"}
           @connect_api = Rest.new(
             base_url: "#{connect_url}/v5/connect", # could use v6 also now
-            headers: {'Origin' => RestParameters.instance.user_agent})
+            headers: {'Origin' => RestParameters.instance.user_agent}
+          )
           connect_info = @connect_api.read('info/version')
           Log.log.info('Connect was reached') if method_index > 0
-          Log.log.debug{Log.dump(:connect_version, connect_info)}
+          Log.dump(:connect_version, connect_info)
         rescue StandardError => e # Errno::ECONNREFUSED
           Log.log.debug{"Exception: #{e}"}
           start_url = CONNECT_START_URIS[method_index]
           method_index += 1
           raise StandardError, "Unable to start connect #{method_index} times" if start_url.nil?
           Log.log.warn{"Aspera Connect is not started (#{e}). Trying to start it ##{method_index}..."}
-          if !Environment.open_uri_graphical(start_url)
-            Environment.open_uri_graphical('https://www.ibm.com/aspera/connect/')
-            raise StandardError, 'Connect is not installed'
-          end
+          Environment.instance.open_uri_graphical(start_url)
           sleep(SLEEP_SEC_BETWEEN_RETRY)
           retry
         end
@@ -57,7 +55,8 @@ module Aspera
             'title'                   => 'Select Files',
             'suggestedName'           => '',
             'allowMultipleSelection'  => true,
-            'allowedFileTypes'        => ''})
+            'allowedFileTypes'        => ''
+          })
           transfer_spec['paths'] = selection['dataTransfer']['files'].map{ |i| {'source' => i['name']}}
         end
         # if there is a token, we ask connect client to use well known ssh private keys
@@ -70,7 +69,8 @@ module Aspera
           }),
           'transfer_specs'          => [{
             'transfer_spec' => transfer_spec
-          }]}
+          }]
+        }
         # asynchronous anyway
         res = @connect_api.create('transfers/start', connect_transfer_args)
         @transfer_id = res['transfer_specs'].first['transfer_spec']['tags'][Transfer::Spec::TAG_RESERVED]['xfer_id']
@@ -83,7 +83,7 @@ module Aspera
         begin
           loop do
             tr_info = @connect_api.create("transfers/info/#{@transfer_id}", connect_activity_args)
-            Log.log.trace1{Log.dump(:tr_info, tr_info)}
+            Log.dump(:tr_info, tr_info, level: :trace1)
             if tr_info['transfer_info'].is_a?(Hash)
               transfer = tr_info['transfer_info']
               if transfer.nil?
@@ -93,7 +93,7 @@ module Aspera
               # TODO: get session id
               case transfer['status']
               when 'initiating', 'queued'
-                notify_progress(:pre_start, session_id: nil, info: transfer['status'])
+                notify_progress(:sessions_init, info: transfer['status'])
               when 'running'
                 if !started
                   notify_progress(:session_start, session_id: @transfer_id)
@@ -106,16 +106,20 @@ module Aspera
                   notify_progress(:transfer, session_id: @transfer_id, info: transfer['bytes_written'])
                 end
               when 'completed'
-                notify_progress(:end, session_id: @transfer_id)
+                notify_progress(:session_end, session_id: @transfer_id)
+                notify_progress(:end)
                 break
               when 'failed'
-                notify_progress(:end, session_id: @transfer_id)
+                notify_progress(:session_end, session_id: @transfer_id)
+                notify_progress(:end)
                 raise Transfer::Error, transfer['error_desc']
               when 'cancelled'
-                notify_progress(:end, session_id: @transfer_id)
+                notify_progress(:session_end, session_id: @transfer_id)
+                notify_progress(:end)
                 raise Transfer::Error, 'Transfer cancelled by user'
               else
-                notify_progress(:end, session_id: @transfer_id)
+                notify_progress(:session_end, session_id: @transfer_id)
+                notify_progress(:end)
                 raise Transfer::Error, "unknown status: #{transfer['status']}: #{transfer['error_desc']}"
               end
             end
@@ -137,9 +141,7 @@ module Aspera
         ['', '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
+          return File.open(uri_file, &:gets).strip if File.exist?(uri_file)
         end
         raise "no connect uri file found in #{folder}"
       end

data/lib/aspera/agent/desktop.rb

@@ -5,6 +5,7 @@ require 'aspera/rest'
 require 'aspera/environment'
 require 'aspera/json_rpc'
 require 'aspera/products/desktop'
+require 'aspera/transfer/spec'
 require 'securerandom'
 
 module Aspera
@@ -21,24 +22,21 @@ module Aspera
         @application_id = SecureRandom.uuid
         @transfer_id = nil
         super
-        raise 'Using client requires a graphical environment' if !Environment.default_gui_mode.eql?(:graphical)
+        raise Error, 'Using client requires a graphical environment' unless Environment.instance.graphical?
         method_index = 0
         begin
           # curl 'http://127.0.0.1:33024/' -X POST -H 'content-type: application/json' --data-raw '{"jsonrpc":"2.0","params":[],"id":999999,"method":"rpc.discover"}'
           # https://playground.open-rpc.org/?schemaUrl=http://127.0.0.1:33024
           @client_app_api = Aspera::JsonRpcClient.new(Aspera::Rest.new(base_url: aspera_client_api_url))
           client_info = @client_app_api.get_info
-          Log.log.debug{Log.dump(:client_version, client_info)}
+          Log.dump(:client_version, client_info)
           Log.log.info('Client was reached') if method_index > 0
         rescue Errno::ECONNREFUSED => e
           start_url = START_URIS[method_index]
           method_index += 1
           raise StandardError, "Unable to start #{Products::Desktop::APP_NAME} #{method_index} times" if start_url.nil?
           Log.log.warn{"#{Products::Desktop::APP_NAME} is not started (#{e}). Trying to start it ##{method_index}..."}
-          if !Environment.open_uri_graphical(start_url)
-            Environment.open_uri_graphical('https://www.ibm.com/aspera/connect/')
-            raise StandardError, "#{Products::Desktop::APP_NAME} is not installed"
-          end
+          Environment.instance.open_uri_graphical(start_url)
           sleep(SLEEP_SEC_BETWEEN_RETRY)
           retry
         end
@@ -46,6 +44,7 @@ module Aspera
 
       # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
+        Transfer::Spec.fix_transferd_resume_policy(transfer_spec)
         @request_id = SecureRandom.uuid
         # if there is a token, we ask the client app to use well known ssh private keys
         # instead of asking password
@@ -62,7 +61,7 @@ module Aspera
             transfer = @client_app_api.get_transfer(app_id: @application_id, transfer_id: @transfer_id)
             case transfer['status']
             when 'initiating', 'queued'
-              notify_progress(:pre_start, session_id: nil, info: transfer['status'])
+              notify_progress(:sessions_init, info: transfer['status'])
             when 'running'
               if !started
                 notify_progress(:session_start, session_id: @transfer_id)
@@ -75,16 +74,20 @@ module Aspera
                 notify_progress(:transfer, session_id: @transfer_id, info: transfer['bytes_written'])
               end
             when 'completed'
-              notify_progress(:end, session_id: @transfer_id)
+              notify_progress(:session_end, session_id: @transfer_id)
+              notify_progress(:end)
               break
             when 'failed'
-              notify_progress(:end, session_id: @transfer_id)
+              notify_progress(:session_end, session_id: @transfer_id)
+              notify_progress(:end)
               raise Transfer::Error, transfer['error_desc']
             when 'cancelled'
-              notify_progress(:end, session_id: @transfer_id)
+              notify_progress(:session_end, session_id: @transfer_id)
+              notify_progress(:end)
               raise Transfer::Error, 'Transfer cancelled by user'
             else
-              notify_progress(:end, session_id: @transfer_id)
+              notify_progress(:session_end, session_id: @transfer_id)
+              notify_progress(:end)
               raise Transfer::Error, "unknown status: #{transfer['status']}: #{transfer['error_desc']}"
             end
             sleep(1)

data/lib/aspera/agent/direct.rb

@@ -66,7 +66,7 @@ module Aspera
         @spawn_timeout_sec = spawn_timeout_sec
         @spawn_delay_sec = spawn_delay_sec
         # default is true on Windows, false on other OSes
-        @multi_incr_udp = multi_incr_udp.nil? ? Environment.os.eql?(Environment::OS_WINDOWS) : multi_incr_udp
+        @multi_incr_udp = multi_incr_udp.nil? ? Environment.instance.os.eql?(Environment::OS_WINDOWS) : multi_incr_udp
         @monitor = monitor
         @management_cb = management_cb
         @resume_policy = Resumer.new(resume.nil? ? {} : resume.symbolize_keys)
@@ -96,7 +96,7 @@ module Aspera
           # TODO: useful ? node only ? seems to be a timeout for retry in node
           transfer_spec['tags'][Transfer::Spec::TAG_RESERVED]['xfer_retry'] ||= 3600
         end
-        Log.log.debug{Log.dump('ts', transfer_spec)}
+        Log.dump(:ts, transfer_spec)
         # Compute this before using transfer spec because it potentially modifies the transfer spec
         # (even if the var is not used in single session)
         multi_session_info = nil
@@ -171,6 +171,7 @@ module Aspera
           session[:thread].join
           result.push(session[:error] || :success)
         end
+        notify_progress(:end)
         Log.log.debug('all transfers joined')
         # since all are finished and we return the result, clear statuses
         @sessions.clear
@@ -225,21 +226,24 @@ module Aspera
       # This is the low level method to start the transfer process.
       # Typically started in a thread.
       # Start process with management port.
-      # @param session this session information, keys :io and :token_regenerator
-      # @param env  [Hash]   environment variables (comes from ascp_args)
-      # @param name [Symbol] name of executable: :ascp, :ascp4 or :async (comes from ascp_args)
-      # @param args [Array]  command line arguments (comes from ascp_args)
+      # @param session [Hash]   This session information, keys :io and :token_regenerator
+      # @param name    [Symbol] Name of executable: :ascp, :ascp4 or :async (comes from ascp_args)
+      # @param env     [Hash]   Environment variables (comes from ascp_args)
+      # @param args    [Array]  Command line arguments (comes from ascp_args)
       # @return [nil] when process has exited
       # @throw FaspError on error
       def start_and_monitor_process(
         session:,
-        env:,
         name:,
+        env:,
         args:
       )
         Aspera.assert_type(session, Hash)
-        notify_progress(:pre_start, session_id: nil, info: 'starting')
+        notify_progress(:sessions_init, info: 'starting')
         begin
+          capture_stderr = false
+          stderr_r, stderr_w = nil
+          spawn_args = {}
           command_pid = nil
           command_arguments = []
           if @monitor
@@ -258,13 +262,17 @@ module Aspera
             end
           end
           command_arguments.concat(args)
-          # capture process stderr
-          stderr_r, stderr_w = IO.pipe
+          if capture_stderr
+            # capture process stderr
+            stderr_r, stderr_w = IO.pipe
+            spawn_args[err] = stderr_w
+          end
           # get location of command executable (ascp, async)
           command_path = Ascp::Installation.instance.path(name)
-          command_pid = Environment.secure_spawn(env: env, exec: command_path, args: command_arguments, err: stderr_w)
-          stderr_w.close
-          notify_progress(:pre_start, session_id: nil, info: "waiting for #{name} to start")
+          command_pid = Environment.secure_spawn(env: env, exec: command_path, args: command_arguments, **spawn_args)
+          # close here, but still used in other process (pipe)
+          stderr_w&.close
+          notify_progress(:sessions_init, info: "waiting for #{name} to start")
           # "ensure" block will wait for process
           return unless @monitor
           # TODO: timeout does not work when Process.spawn is used... until process exits, then it works
@@ -272,7 +280,7 @@ module Aspera
           Log.log.debug{"before select, timeout: #{@spawn_timeout_sec}"}
           readable, _, _ = IO.select([mgt_server_socket], nil, nil, @spawn_timeout_sec)
           Log.log.debug('after select, before accept')
-          Aspera.assert(readable, exception_class: Transfer::Error){'timeout waiting mgt port connect (select not readable)'}
+          Aspera.assert(readable, type: Transfer::Error){'timeout waiting mgt port connect (select not readable)'}
           # There is a connection to accept
           client_socket, _client_addrinfo = mgt_server_socket.accept
           Log.log.debug('after accept')
@@ -288,12 +296,11 @@ module Aspera
             event = processor.process_line(line.chomp)
             next unless event
             # event is ready
-            Log.log.trace1{Log.dump(:management_port, event)}
+            Log.dump(:management_port, event, level: :trace1)
             # store session identifier
             session[:id] = event['SessionId'] if event['Type'].eql?('INIT')
             @management_cb&.call(event)
             process_progress(event)
-            Log.log.error(event['Description'].to_s) if event['Type'].eql?('FILEERROR') # cspell:disable-line
           end
           Log.log.debug('management io closed')
           # check that last status was received before process exit
@@ -311,9 +318,7 @@ module Aspera
               env['ASPERA_SCP_TOKEN'] = session[:token_regenerator].refreshed_transfer_token
             end
             raise Transfer::Error.new(last_event['Description'], last_event['Code'].to_i)
-          else
-            Log.log.error{"unexpected last event type: #{last_event['Type']}"}
-            # raise Transfer::Error, "unexpected last event type: #{last_event['Type']}, #{last_event['Description']}"
+          else Aspera.error_unexpected_value(last_event['Type'], :error){'last event type'}
           end
         rescue SystemCallError => e
           # Process.spawn failed, or socket error
@@ -325,14 +330,20 @@ module Aspera
           session.delete(:io)
           # if command was successfully started, check its status
           unless command_pid.nil?
-            Process.kill(:INT, command_pid) if @monitor
+            Process.kill(:INT, command_pid) if @monitor && !Environment.instance.os.eql?(Environment::OS_WINDOWS)
             # collect process exit status or wait for termination
             _, status = Process.wait2(command_pid)
-            # process stderr of ascp
-            stderr_r.each_line do |line|
-              Log.log.error(line.chomp)
+            if stderr_r
+              # process stderr of ascp
+              stderr_flag = false
+              stderr_r.each_line do |line|
+                Log.log.error{"BEGIN stderr #{name}"} unless stderr_flag
+                Log.log.error{line.chomp}
+                stderr_flag = true
+              end
+              Log.log.error{"END stderr #{name}"} if stderr_flag
+              stderr_r.close
             end
-            stderr_r.close
             # status is nil if an exception occurred before starting command
             if !status&.success?
               message = "#{name} failed (#{status})"
@@ -370,17 +381,14 @@ module Aspera
           notify_progress(:transfer, session_id: session_id, info: @pre_calc_last_size)
         when 'DONE', 'ERROR' # end of session
           total_size = event['TransferBytes'].to_i + event['StartByte'].to_i
-          if !@pre_calc_sent && !total_size.zero?
-            notify_progress(:session_size, session_id: session_id, info: total_size)
-          end
-          if @pre_calc_last_size != total_size
-            notify_progress(:transfer, session_id: session_id, info: total_size)
-          end
-          notify_progress(:end, session_id: session_id)
+          notify_progress(:session_size, session_id: session_id, info: total_size) if !@pre_calc_sent && !total_size.zero?
+          notify_progress(:transfer, session_id: session_id, info: total_size) if @pre_calc_last_size != total_size
+          notify_progress(:session_end, session_id: session_id)
           # cspell:disable
         when 'SESSION'
         when 'ARGSTOP'
         when 'FILEERROR'
+          Log.log.error{"#{event['Type']} #{event['Description']}"}
         when 'STOP'
           # cspell:enable
           # stop event when one file is completed

data/lib/aspera/agent/httpgw.rb

@@ -32,10 +32,10 @@ module Aspera
       # HTTP download only supports file list
       # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
-        raise 'GW URL must be set' if @gw_api.nil?
+        Aspera.assert(!@gw_api.nil?){'GW URL must be set'}
         Aspera.assert_type(transfer_spec['paths'], Array){'paths'}
         Aspera.assert_type(transfer_spec['token'], String){'only token based transfer is supported in GW'}
-        Log.log.debug{Log.dump(:user_spec, transfer_spec)}
+        Log.dump(:user_spec, transfer_spec)
         transfer_spec['authentication'] ||= 'token'
         case transfer_spec['direction']
         when Transfer::Spec::DIRECTION_SEND

data/lib/aspera/agent/node.rb

@@ -29,7 +29,7 @@ module Aspera
         # root id is required for access key
         @root_id = root_id
         rest_params = {base_url: url}
-        if OAuth::Factory.bearer?(password)
+        if OAuth::Factory.bearer_auth?(password)
           Aspera.assert(!@root_id.nil?){'root_id not allowed for access key'}
           rest_params[:headers] = Api::Node.bearer_headers(password, access_key: username)
         else
@@ -57,14 +57,10 @@ module Aspera
         end
         # add mandatory retry parameter for node api
         ts_tags = transfer_spec['tags']
-        if ts_tags.is_a?(Hash) && ts_tags[Transfer::Spec::TAG_RESERVED].is_a?(Hash)
-          ts_tags[Transfer::Spec::TAG_RESERVED]['xfer_retry'] ||= 150
-        end
+        ts_tags[Transfer::Spec::TAG_RESERVED]['xfer_retry'] ||= 150 if ts_tags.is_a?(Hash) && ts_tags[Transfer::Spec::TAG_RESERVED].is_a?(Hash)
         # Optimization in case of sending to the same node
         # TODO: probably remove this, as /etc/hosts shall be used for that
-        if !transfer_spec['wss_enabled'] && transfer_spec['remote_host'].eql?(URI.parse(node_api_.base_url).host)
-          transfer_spec['remote_host'] = '127.0.0.1'
-        end
+        transfer_spec['remote_host'] = '127.0.0.1' if !transfer_spec['wss_enabled'] && transfer_spec['remote_host'].eql?(URI.parse(node_api_.base_url).host)
         resp = node_api_.create('ops/transfers', transfer_spec)
         @transfer_id = resp['id']
         Log.log.debug{"tr_id=#{@transfer_id}"}
@@ -82,7 +78,7 @@ module Aspera
           transfer_data = node_api_.read("ops/transfers/#{@transfer_id}") || {'status' => 'unknown'} rescue {'status' => 'waiting(api error)'}
           case transfer_data['status']
           when 'waiting', 'partially_completed', 'unknown', 'waiting(read error)'
-            notify_progress(:pre_start, session_id: nil, info: transfer_data['status'])
+            notify_progress(:sessions_init, info: transfer_data['status'])
           when 'running'
             if !session_started
               notify_progress(:session_start, session_id: @transfer_id)
@@ -90,7 +86,7 @@ module Aspera
             end
             message = transfer_data['status']
             message = "#{message} (#{transfer_data['error_desc']})" if !transfer_data['error_desc']&.empty?
-            notify_progress(:pre_start, session_id: nil, info: message)
+            notify_progress(:sessions_init, info: message)
             if bytes_expected.nil? &&
                 transfer_data['precalc'].is_a?(Hash) &&
                 transfer_data['precalc']['status'].eql?('ready')
@@ -100,10 +96,12 @@ module Aspera
             notify_progress(:transfer, session_id: @transfer_id, info: transfer_data['bytes_transferred'])
           when 'completed'
             notify_progress(:transfer, session_id: @transfer_id, info: bytes_expected) if bytes_expected
-            notify_progress(:end, session_id: @transfer_id)
+            notify_progress(:session_end, session_id: @transfer_id)
+            notify_progress(:end)
             break
           when 'failed'
-            notify_progress(:end, session_id: @transfer_id)
+            notify_progress(:session_end, session_id: @transfer_id)
+            notify_progress(:end)
             # Bug in HSTS ? transfer is marked failed, but there is no reason
             break if transfer_data['error_code'].eql?(0) && transfer_data['error_desc'].empty?
             raise Transfer::Error, "status: #{transfer_data['status']}. code: #{transfer_data['error_code']}. description: #{transfer_data['error_desc']}"

data/lib/aspera/agent/transferd.rb

@@ -4,6 +4,7 @@ require 'aspera/environment'
 require 'aspera/agent/base'
 require 'aspera/products/transferd'
 require 'aspera/temp_file_manager'
+require 'aspera/transfer/spec'
 require 'json'
 require 'uri'
 require 'transferd_services_pb'
@@ -34,11 +35,11 @@ module Aspera
         @transfer_id = nil
         @stop = stop
         is_local_auto_port = url.eql?(AUTO_LOCAL_TCP_PORT)
-        raise 'Cannot set options `stop` or `start` to false with port zero' if is_local_auto_port && (!@stop || !start)
+        raise Error, 'Cannot set options `stop` or `start` to false with port zero' if is_local_auto_port && (!@stop || !start)
         # keep PID for optional shutdown
         @daemon_pid = nil
         daemon_endpoint = url
-        Log.log.debug{Log.dump(:daemon_endpoint, daemon_endpoint)}
+        Log.dump(:daemon_endpoint, daemon_endpoint)
         # retry loop
         begin
           # no address: local bind
@@ -82,7 +83,8 @@ module Aspera
             exec: Ascp::Installation.instance.path(:transferd),
             args: ['--config', conf_file],
             out: log_stdout,
-            err: log_stderr)
+            err: log_stderr
+          )
           begin
             # wait for process to initialize, max 2 seconds
             Timeout.timeout(2.0) do
@@ -105,15 +107,18 @@ module Aspera
 
       # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
+        Transfer::Spec.fix_transferd_resume_policy(transfer_spec)
         # create a transfer request
         transfer_request = ::Transferd::Api::TransferRequest.new(
           transferType: ::Transferd::Api::TransferType::FILE_REGULAR, # transfer type (file/stream)
           config: ::Transferd::Api::TransferConfig.new, # transfer configuration
-          transferSpec: transfer_spec.to_json) # transfer definition
+          transferSpec: transfer_spec.to_json
+        ) # transfer definition
         # send start transfer request to the transfer manager daemon
-        start_transfer_response = @transfer_client.start_transfer(transfer_request)
-        Log.log.debug{"start transfer response #{start_transfer_response}"}
-        @transfer_id = start_transfer_response.transferId
+        start_response = @transfer_client.start_transfer(transfer_request)
+        raise Transfer::Error, start_response.error.description if start_response.status.eql?(:FAILED)
+        Log.log.debug{"start transfer response #{start_response}"}
+        @transfer_id = start_response.transferId
         Log.log.debug{"transfer started with id #{@transfer_id}"}
       end
 
@@ -123,7 +128,7 @@ module Aspera
         bytes_expected = nil
         # monitor transfer status
         @transfer_client.monitor_transfers(::Transferd::Api::RegistrationRequest.new(transferId: [@transfer_id])) do |response|
-          Log.log.debug{Log.dump(:response, response.to_h)}
+          Log.dump(:response, response.to_h)
           # Log.log.debug{"#{response.sessionInfo.preTransferBytes} #{response.transferInfo.bytesTransferred}"}
           case response.status
           when :RUNNING
@@ -139,13 +144,15 @@ module Aspera
             notify_progress(:transfer, session_id: @transfer_id, info: response.transferInfo.bytesTransferred)
           when :COMPLETED
             notify_progress(:transfer, session_id: @transfer_id, info: bytes_expected) if bytes_expected
-            notify_progress(:end, session_id: @transfer_id)
+            notify_progress(:session_end, session_id: @transfer_id)
+            notify_progress(:end)
             break
           when :FAILED, :CANCELED
-            notify_progress(:end, session_id: @transfer_id)
+            notify_progress(:session_end, session_id: @transfer_id)
+            notify_progress(:end)
             raise Transfer::Error, JSON.parse(response.message)['Description']
           when :QUEUED, :UNKNOWN_STATUS, :PAUSED, :ORPHANED
-            notify_progress(:pre_start, session_id: nil, info: response.status.to_s.downcase)
+            notify_progress(:sessions_init, info: response.status.to_s.downcase)
           else
             Log.log.error{"unknown status#{response.status}"}
           end