aspera-cli 4.15.0 → 4.16.0

data/lib/aspera/fasp/agent_direct.rb

@@ -8,8 +8,8 @@ require 'aspera/fasp/resume_policy'
 require 'aspera/fasp/transfer_spec'
 require 'aspera/fasp/management'
 require 'aspera/log'
+require 'aspera/assert'
 require 'socket'
-require 'timeout'
 require 'securerandom'
 require 'shellwords'
 require 'English'
@@ -20,8 +20,8 @@ module Aspera
     class AgentDirect < Aspera::Fasp::AgentBase
       # options for initialize (same as values in option transfer_info)
       DEFAULT_OPTIONS = {
-        spawn_timeout_sec: 3,
-        spawn_delay_sec:   2,
+        spawn_timeout_sec: 2,
+        spawn_delay_sec:   2, # optional delay to start between sessions
         wss:               true, # true: if both SSH and wss in ts: prefer wss
         multi_incr_udp:    true,
         resume:            {},
@@ -30,17 +30,20 @@ module Aspera
         quiet:             true, # by default no native ascp progress bar
         trusted_certs:     [] # list of files with trusted certificates (stores)
       }.freeze
+      LISTEN_ADDRESS = '127.0.0.1'
+      LISTEN_AVAILABLE_PORT = 0 # 0 means any available port
       # spellchecker: enable
-      private_constant :DEFAULT_OPTIONS
+      private_constant :DEFAULT_OPTIONS, :LISTEN_ADDRESS
 
-      # start ascp transfer (non blocking), single or multi-session
-      # job information added to @jobs
+      # method of Aspera::Fasp::AgentBase
+      # start ascp transfer(s) (non blocking), single or multi-session
+      # session information added to @sessions
       # @param transfer_spec [Hash] aspera transfer specification
+      # @param token_regenerator [Object] object with method refreshed_transfer_token
       def start_transfer(transfer_spec, token_regenerator: nil)
-        the_job_id = SecureRandom.uuid
         # clone transfer spec because we modify it (first level keys)
         transfer_spec = transfer_spec.clone
-        # if there is aspera tags
+        # if there are aspera tags
         if transfer_spec['tags'].is_a?(Hash) && transfer_spec['tags'][Fasp::TransferSpec::TAG_RESERVED].is_a?(Hash)
           # TODO: what is this for ? only on local ascp ?
           # NOTE: important: transfer id must be unique: generate random id
@@ -48,11 +51,10 @@ module Aspera
           # all sessions in a multi-session transfer must have the same xfer_id (see admin manual)
           transfer_spec['tags'][Fasp::TransferSpec::TAG_RESERVED]['xfer_id'] ||= SecureRandom.uuid
           Log.log.debug{"xfer id=#{transfer_spec['xfer_id']}"}
-          # TODO: useful ? node only ?
+          # TODO: useful ? node only ? seems to be a timeout for retry in node
           transfer_spec['tags'][Fasp::TransferSpec::TAG_RESERVED]['xfer_retry'] ||= 3600
         end
         Log.log.debug{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
@@ -77,30 +79,24 @@ module Aspera
           end
         end
 
-        # compute known arguments and environment variables
-        env_args = Parameters.new(transfer_spec, @options).ascp_args
-
-        # transfer job can be multi session
-        xfer_job = {
-          id:       the_job_id,
-          sessions: [] # all sessions as below
-        }
-
         # generic session information
         session = {
+          id:                nil, # SessionId from INIT message in mgt port
+          job_id:            SecureRandom.uuid, # job id (regroup sessions)
+          ts:                transfer_spec,     # transfer spec
           thread:            nil,               # Thread object monitoring management port, not nil when pushed to :sessions
           error:             nil,               # exception if failed
           io:                nil,               # management port server socket
-          id:                nil,               # SessionId from INIT message in mgt port
           token_regenerator: token_regenerator, # regenerate bearer token with oauth
-          env_args:          env_args           # env vars and args to ascp (from transfer spec)
+          # env vars and args to ascp (from transfer spec)
+          env_args:          Parameters.new(transfer_spec, @options).ascp_args
         }
 
         if multi_session_info.nil?
           Log.log.debug('Starting single session thread')
           # single session for transfer : simple
           session[:thread] = Thread.new(session) {|s|transfer_thread_entry(s)}
-          xfer_job[:sessions].push(session)
+          @sessions.push(session)
         else
           Log.log.debug('Starting multi session threads')
           1.upto(multi_session_info[:count]) do |i|
@@ -108,22 +104,19 @@ module Aspera
             sleep(@options[:spawn_delay_sec]) unless i.eql?(1)
             # do deep copy (each thread has its own copy because it is modified here below and in thread)
             this_session = session.clone
+            this_session[:ts] = this_session[:ts].clone
             this_session[:env_args] = this_session[:env_args].clone
             this_session[:env_args][:args] = this_session[:env_args][:args].clone
+            # set multi session part
             this_session[:env_args][:args].unshift("-C#{i}:#{multi_session_info[:count]}")
             # option: increment (default as per ascp manual) or not (cluster on other side ?)
             this_session[:env_args][:args].unshift('-O', (multi_session_info[:udp_base] + i - 1).to_s) if @options[:multi_incr_udp]
+            # finally start the thread
             this_session[:thread] = Thread.new(this_session) {|s|transfer_thread_entry(s)}
-            xfer_job[:sessions].push(this_session)
+            @sessions.push(this_session)
           end
         end
-        Log.log.debug('started session thread(s)')
-
-        # add job to list of jobs
-        @jobs[the_job_id] = xfer_job
-        Log.log.debug{"jobs: #{@jobs.keys.count}"}
-
-        return the_job_id
+        return session[:job_id]
       end # start_transfer
 
       # wait for completion of all jobs started
@@ -132,16 +125,14 @@ module Aspera
         Log.log.debug('wait_for_transfers_completion')
         # set to non-nil to exit loop
         result = []
-        @jobs.each do |_id, job|
-          job[:sessions].each do |session|
-            Log.log.debug{"join #{session[:thread]}"}
-            session[:thread].join
-            result.push(session[:error] || :success)
-          end
+        @sessions.each do |session|
+          Log.log.debug{"join #{session[:thread]}"}
+          session[:thread].join
+          result.push(session[:error] || :success)
         end
         Log.log.debug('all transfers joined')
         # since all are finished and we return the result, clear statuses
-        @jobs.clear
+        @sessions.clear
         return result
       end
 
@@ -198,27 +189,26 @@ module Aspera
       # start ascp with management port.
       # raises FaspError on error
       # if there is a thread info: set and broadcast session id
+      # runs in separate thread
       # @param env_args a hash containing :args :env :ascp_version
       # @param session this session information
       # could be private method
       def start_transfer_with_args_env(env_args, session)
-        raise 'env_args must be Hash' unless env_args.is_a?(Hash)
-        raise 'session must be Hash' unless session.is_a?(Hash)
+        assert_type(env_args, Hash)
+        assert_type(session, Hash)
+        Log.log.debug{"env_args=#{env_args.inspect}"}
+        notify_progress(session_id: nil, type: :pre_start, info: 'starting')
         begin
-          Log.log.debug{"env_args=#{env_args.inspect}"}
-          # get location of ascp executable
-          ascp_path = @mutex.synchronize do
-            Fasp::Installation.instance.path(env_args[:ascp_version])
-          end
-          # (optional) check it exists
-          raise Fasp::Error, "no such file: #{ascp_path}" unless File.exist?(ascp_path)
-          notify_progress(session_id: nil, type: :pre_start, info: 'starting ascp')
+          # we use Socket directly, instead of TCPServer, s it gives access to lower level options
+          mgt_server_socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
           # open an available (0) local TCP port as ascp management
-          mgt_sock = TCPServer.new('127.0.0.1', 0)
-          # clone arguments as we eed to modify with mgt port
-          ascp_arguments = env_args[:args].clone
-          # add management port on the selected local port
-          ascp_arguments.unshift('-M', mgt_sock.addr[1].to_s)
+          # Socket.pack_sockaddr_in(LISTEN_AVAILABLE_PORT, LISTEN_ADDRESS)
+          mgt_server_socket.bind(Addrinfo.tcp(LISTEN_ADDRESS, LISTEN_AVAILABLE_PORT))
+          # clone arguments and add mgt port
+          ascp_arguments = ['-M', mgt_server_socket.local_address.ip_port.to_s].concat(env_args[:args])
+          # mgt_server_socket.addr[1]
+          # get location of ascp executable
+          ascp_path = Fasp::Installation.instance.path(env_args[:ascp_version])
           # display ascp command line
           Log.log.debug do
             [
@@ -229,20 +219,23 @@ module Aspera
             ].flatten.join(' ')
           end
           # start ascp in separate process
-          ascp_pid = Process.spawn(env_args[:env], [ascp_path, ascp_path], *ascp_arguments)
-          # in parent, wait for connection to socket max 3 seconds
-          Log.log.debug{"before accept for pid (#{ascp_pid})"}
-          # init management socket
-          ascp_mgt_io = nil
+          ascp_pid = Process.spawn(env_args[:env], [ascp_path, ascp_path], *ascp_arguments, close_others: true)
+          Log.log.debug{"spawned pid #{ascp_pid}"}
           notify_progress(session_id: nil, type: :pre_start, info: 'waiting for ascp')
-          Timeout.timeout(@options[:spawn_timeout_sec]) do
-            ascp_mgt_io = mgt_sock.accept
-            # management messages include file names which may be utf8
-            # by default socket is US-ASCII
-            # TODO: use same value as Encoding.default_external
-            ascp_mgt_io.set_encoding(Encoding::UTF_8)
-          end
-          Log.log.debug{"after accept (#{ascp_mgt_io})"}
+          mgt_server_socket.listen(1)
+          # TODO: timeout does not work when Process.spawn is used... until process exits, then it works
+          Log.log.debug{"before select, timeout: #{@options[:spawn_timeout_sec]}"}
+          readable, _, _ = IO.select([mgt_server_socket], nil, nil, @options[:spawn_timeout_sec])
+          Log.log.debug('after select, before accept')
+          assert(readable, exception_class: Fasp::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')
+          ascp_mgt_io = client_socket.to_io
+          # management messages include file names which may be utf8
+          # by default socket is US-ASCII
+          # TODO: use same value as Encoding.default_external
+          ascp_mgt_io.set_encoding(Encoding::UTF_8)
           session[:io] = ascp_mgt_io
           processor = Management.new
           # read management port, until socket is closed (gets returns nil)
@@ -250,11 +243,12 @@ module Aspera
             event = processor.process_line(line.chomp)
             next unless event
             # event is ready
-            Log.log.debug{Log.dump(:management_port, event)}
+            Log.log.trace1{Log.dump(:management_port, event)}
             # Log.log.trace1{"event: #{JSON.generate(Management.enhanced_event_format(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')
           last_event = processor.last_event
           # check that last status was received before process exit
           if last_event.is_a?(Hash)
@@ -264,7 +258,7 @@ module Aspera
                   session[:token_regenerator].respond_to?(:refreshed_transfer_token)
                 # regenerate token here, expired, or error on it
                 # Note: in multi-session, each session will have a different one.
-                Log.log.warn('Regenerating bearer token')
+                Log.log.warn('Regenerating token for transfer')
                 env_args[:env]['ASPERA_SCP_TOKEN'] = session[:token_regenerator].refreshed_transfer_token
               end
               raise Fasp::Error.new(last_event['Description'], last_event['Code'].to_i)
@@ -277,11 +271,10 @@ module Aspera
         rescue SystemCallError => e
           # Process.spawn
           raise Fasp::Error, e.message
-        rescue Timeout::Error
-          raise Fasp::Error, 'timeout waiting mgt port connect'
         rescue Interrupt
           raise Fasp::Error, 'transfer interrupted by user'
         ensure
+          mgt_server_socket.close
           # if ascp was successfully started
           unless ascp_pid.nil?
             # "wait" for process to avoid zombie
@@ -290,27 +283,37 @@ module Aspera
             ascp_pid = nil
             session.delete(:io)
             if !status.success?
-              message = "ascp failed with code #{status.exitstatus}"
-              # raise error only if there was not already an exception
+              message = "ascp failed: #{status}"
+              # raise error only if there was not already an exception (ERROR_INFO)
               raise Fasp::Error, message unless $ERROR_INFO
-              # else just debug, as main exception is already here
-              Log.log.debug(message)
+              # else display this message also, as main exception is already here
+              Log.log.error(message)
             end
           end
         end # begin-ensure
       end # start_transfer_with_args_env
 
-      # send command of management port to ascp session
+      # @return [Array] list of sessions for a job
+      def sessions_by_job(job_id)
+        @sessions.select{|s| s[:job_id].eql?(job_id)}
+      end
+
+      # @return [Hash] session information
+      def session_by_id(id)
+        matches = @sessions.select{|s| s[:id].eql?(id)}
+        raise 'no such session' if matches.empty?
+        raise 'more than one session' if matches.length > 1
+        return matches.first
+      end
+
+      # send command of management port to ascp session (used in `asession)
       # @param job_id identified transfer process
       # @param session_index index of session (for multi session)
       # @param data command on mgt port, examples:
       # {'type'=>'START','source'=>_path_,'destination'=>_path_}
       # {'type'=>'DONE'}
-      def send_command(job_id, session_index, data)
-        job = @jobs[job_id]
-        raise 'no such job' if job.nil?
-        session = job[:sessions][session_index]
-        raise 'no such session' if session.nil?
+      def send_command(job_id, data)
+        session = session_by_id(job_id)
         Log.log.debug{"command: #{data}"}
         # build command
         command = data
@@ -321,20 +324,21 @@ module Aspera
           .join("\n")
         session[:io].puts(command)
       end
+      attr_reader :sessions
 
       private
 
       # @param options : keys(symbol): see DEFAULT_OPTIONS
       def initialize(options={})
         super(options)
-        # all transfer jobs, key = SecureRandom.uuid, protected by mutex, cond var on change
-        @jobs = {}
-        # mutex protects global data accessed by threads
-        @mutex = Mutex.new
         # set default options and override if specified
         @options = AgentBase.options(default: DEFAULT_OPTIONS, options: options)
-        @resume_policy = ResumePolicy.new(@options[:resume].symbolize_keys)
         Log.log.debug{Log.dump(:agent_options, @options)}
+        @resume_policy = ResumePolicy.new(@options[:resume].symbolize_keys)
+        # all transfer jobs, key = SecureRandom.uuid, protected by mutex, cond var on change
+        @sessions = []
+        # mutex protects global data accessed by threads
+        @mutex = Mutex.new
       end
 
       # transfer thread entry

data/lib/aspera/fasp/agent_httpgw.rb

@@ -4,6 +4,7 @@ require 'aspera/fasp/agent_base'
 require 'aspera/fasp/transfer_spec'
 require 'aspera/fasp/faux_file'
 require 'aspera/log'
+require 'aspera/assert'
 require 'aspera/rest'
 require 'securerandom'
 require 'websocket'
@@ -185,7 +186,7 @@ module Aspera
         @ws_io.write(@ws_handshake.to_s)
         sleep(0.1)
         @ws_handshake << @ws_io.readuntil("\r\n\r\n")
-        raise 'Error in websocket handshake' unless @ws_handshake.finished?
+        assert(@ws_handshake.finished?){'Error in websocket handshake'}
         Log.log.debug{"#{LOG_WS_SEND}handshake success"}
         # start read thread after handshake
         @ws_read_thread = Thread.new {process_read_thread}
@@ -311,8 +312,8 @@ module Aspera
       # HTTP download only supports file list
       def start_transfer(transfer_spec, token_regenerator: nil)
         raise 'GW URL must be set' if @gw_api.nil?
-        raise 'paths: must be Array' unless transfer_spec['paths'].is_a?(Array)
-        raise 'only token based transfer is supported in GW' unless transfer_spec['token'].is_a?(String)
+        assert_type(transfer_spec['paths'], Array){'paths'}
+        assert_type(transfer_spec['token'], String){'only token based transfer is supported in GW'}
         Log.log.debug{Log.dump(:user_spec, transfer_spec)}
         transfer_spec['authentication'] ||= 'token'
         case transfer_spec['direction']

data/lib/aspera/fasp/agent_node.rb

@@ -5,6 +5,7 @@ require 'aspera/fasp/agent_base'
 require 'aspera/fasp/transfer_spec'
 require 'aspera/node'
 require 'aspera/log'
+require 'aspera/assert'
 require 'aspera/oauth'
 
 module Aspera
@@ -22,7 +23,7 @@ module Aspera
       # attr_writer :options
 
       def initialize(opts)
-        raise 'node specification must be Hash' unless opts.is_a?(Hash)
+        assert_type(opts, Hash){'node agent options'}
         super(opts)
         options = AgentBase.options(default: DEFAULT_OPTIONS, options: opts)
         # root id is required for access key
@@ -67,7 +68,7 @@ module Aspera
           case transfer_spec['direction']
           when Fasp::TransferSpec::DIRECTION_SEND then transfer_spec['source_root_id'] = @root_id
           when Fasp::TransferSpec::DIRECTION_RECEIVE then transfer_spec['destination_root_id'] = @root_id
-          else raise "unexpected direction in ts: #{transfer_spec['direction']}"
+          else error_unexpected_value(transfer_spec['direction'])
           end
         end
         # manage special additional parameter

data/lib/aspera/fasp/agent_trsdk.rb

@@ -2,46 +2,84 @@
 
 require 'aspera/fasp/agent_base'
 require 'aspera/fasp/installation'
+require 'aspera/temp_file_manager'
+require 'aspera/log'
+require 'aspera/assert'
 require 'json'
 require 'uri'
 
 module Aspera
   module Fasp
     class AgentTrsdk < Aspera::Fasp::AgentBase
+      # see https://github.com/grpc/grpc/blob/master/doc/naming.md
+      # https://grpc.io/docs/guides/custom-name-resolution/
+      LOCAL_SOCKET_ADDR = '127.0.0.1'
+      PORT_SEP = ':'
+      # port zero means select a random available high port
+      AUTO_LOCAL_TCP_PORT = "#{PORT_SEP}0"
       DEFAULT_OPTIONS = {
-        url:      'grpc://127.0.0.1:0',
-        external: false,
-        keep:     false
+        url:      AUTO_LOCAL_TCP_PORT,
+        external: false,         # expect that an external daemon is already running
+        keep:     false          # do not shutdown daemon on exit
       }.freeze
       private_constant :DEFAULT_OPTIONS
 
+      class << self
+        # Well, the port number is only in log file
+        def daemon_port_from_log(log_file)
+          result = nil
+          # if port is zero, a dynamic port was created, get it
+          File.open(log_file, 'r') do |file|
+            file.each_line do |line|
+              # Well, it's tricky to depend on log
+              if (m = line.match(/Info: API Server: Listening on ([^:]+):(\d+) /))
+                result = m[2].to_i
+                # no "break" , need to read last matching log line
+              end
+            end
+          end
+          raise 'Port not found in daemon logs' if result.nil?
+          Log.log.debug{"Got port #{result} from log"}
+          return result
+        end
+      end
+
       # options come from transfer_info
       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')
+        is_local_auto_port = @options[:url].eql?(AUTO_LOCAL_TCP_PORT)
+        raise 'Cannot use options `keep` or `external` with port zero' if is_local_auto_port && (@options[:keep] || @options[:external])
         Log.log.debug{Log.dump(:agent_options, @options)}
-        # load and create SDK stub
+        # load SDK stub class on demand, as it's an optional gem
         $LOAD_PATH.unshift(Installation.instance.sdk_ruby_folder)
         require 'transfer_services_pb'
-        # it stays
+        # keep PID for optional shutdown
         @daemon_pid = nil
+        daemon_endpoint = @options[:url]
+        Log.log.debug{Log.dump(:daemon_endpoint, daemon_endpoint)}
+        # retry loop
         begin
-          @transfer_client = Transfersdk::TransferService::Stub.new("#{daemon_uri.host}:#{daemon_uri.port}", :this_channel_is_insecure)
+          # no address: local bind
+          daemon_endpoint = "#{LOCAL_SOCKET_ADDR}#{daemon_endpoint}" if daemon_endpoint.match?(/^#{PORT_SEP}[0-9]+$/o)
+          # Create stub (without credentials)
+          @transfer_client = Transfersdk::TransferService::Stub.new(daemon_endpoint, :this_channel_is_insecure)
+          # Initiate actual connection
           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]
+          Log.log.debug{"Daemon info: #{get_info_response}"}
+          Log.log.warn{'Attached to existing daemon'} unless @daemon_pid || @options[:external] || @options[:keep]
           at_exit{shutdown}
-        rescue GRPC::Unavailable
-          raise if @options[:external]
-          raise "daemon started with PID #{@daemon_pid}, but connection failed to #{daemon_uri}}" unless @daemon_pid.nil?
+        rescue GRPC::Unavailable => e
+          # if transferd is external: do not start it, or other error
+          raise if @options[:external] || !e.message.include?('failed to connect')
+          # we already tried to start a daemon, but it failed
+          assert(@daemon_pid.nil?){"Daemon started with PID #{@daemon_pid}, but connection failed to #{daemon_endpoint}}"}
           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
-          generated_config_file_path = File.join(bin_folder, 'sdk.conf')
-          log_base = File.join(bin_folder, 'transferd')
+          sdk_folder = File.realpath(File.join(Installation.instance.sdk_ruby_folder, '..'))
+          # transferd only supports local ip and port
+          daemon_uri = URI.parse("ipv4://#{daemon_endpoint}")
+          assert(daemon_uri.scheme.eql?('ipv4')){"Invalid scheme daemon URI #{daemon_endpoint}"}
           # create a config file for daemon
           config = {
             address:      daemon_uri.host,
@@ -49,35 +87,35 @@ module Aspera
             fasp_runtime: {
               use_embedded: false,
               user_defined: {
-                bin: bin_folder,
-                etc: bin_folder
+                bin: sdk_folder,
+                etc: sdk_folder
               }
             }
           }
-          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")
+          # config file and logs are created in same folder
+          transferd_base_tmp = TempFileManager.instance.new_file_path_global('transferd')
+          Log.log.debug{"transferd base tmp #{transferd_base_tmp}"}
+          conf_file = "#{transferd_base_tmp}.conf"
+          log_stdout = "#{transferd_base_tmp}.out"
+          log_stderr = "#{transferd_base_tmp}.err"
+          File.write(conf_file, config.to_json)
+          @daemon_pid = Process.spawn(Installation.instance.path(:transferd), '--config', conf_file, out: log_stdout, err: log_stderr)
           begin
-            # wait for process to initialize
+            # wait for process to initialize, max 2 seconds
             Timeout.timeout(2.0) do
+              # this returns if process dies (within 2 seconds)
               _, status = Process.wait2(@daemon_pid)
-              raise "transfer daemon exited with status #{status.exitstatus}. Check files: #{log_base}.out #{log_base}.err"
+              raise "Transfer daemon exited with status #{status.exitstatus}. Check files: #{log_stdout} and #{log_stderr}"
             end
           rescue Timeout::Error
             nil
           end
-          Log.log.debug{"daemon started with pid #{@daemon_pid}"}
+          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
+          at_exit {shutdown}
+          # update port for next connection attempt (if auto high port was requested)
+          daemon_endpoint = "#{LOCAL_SOCKET_ADDR}#{PORT_SEP}#{self.class.daemon_port_from_log(log_stdout)}" if is_local_auto_port
+          # local daemon started, try again
           retry
         end
       end
@@ -133,8 +171,12 @@ module Aspera
       end
 
       def shutdown
-        if !@options[:keep] && !@daemon_pid.nil?
-          Log.log.debug("stopping daemon #{@daemon_pid}")
+        stop_daemon unless @options[:keep]
+      end
+
+      def stop_daemon
+        if !@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}")