aspera-cli 4.26.2 → 4.27.1

data/lib/aspera/agent/direct.rb

@@ -3,6 +3,7 @@
 require 'aspera/agent/base'
 require 'aspera/ascp/installation'
 require 'aspera/ascp/management'
+require 'aspera/exec_spec'
 require 'aspera/transfer/parameters'
 require 'aspera/transfer/error'
 require 'aspera/transfer/spec'
@@ -18,18 +19,43 @@ module Aspera
   module Agent
     # Execute a local `ascp` and use its management port to monitor progress
     class Direct < Base
+      class << self
+        # Re-query the status of a direct transfer that was started in-process.
+        # Only works if the same Ruby process is still alive (e.g. MCP mode).
+        # agent_params must contain '_agent_ref' pointing to the live Direct instance.
+        # @param transfer_id  [String] job_id returned by start_transfer / last_job_id
+        # @param agent_params [Hash]   connection parameters; '_agent_ref' is the live agent
+        # @return [Hash] status hash with at least 'status' key
+        def transfer_status(transfer_id, agent_params)
+          agent = agent_params['_agent_ref']
+          return {'status' => 'unknown', 'note' => 'direct agent not available (different process?)'} if agent.nil?
+          sessions = agent.sessions_by_job(transfer_id)
+          return {'status' => 'unknown', 'note' => "no sessions found for job #{transfer_id}"} if sessions.empty?
+          errors  = sessions.filter_map { |s| s[:error] }
+          running = sessions.any? { |s| s[:thread]&.alive? }
+          if errors.any?
+            {'status' => 'failed', 'error' => errors.first.message}
+          elsif running
+            {'status' => 'running'}
+          else
+            {'status' => 'completed'}
+          end
+        end
+      end
+
       # `ascp` started locally, so listen local
       LISTEN_LOCAL_ADDRESS = '127.0.0.1'
       # 0 means: use any available port
       SELECT_AVAILABLE_PORT = 0
       private_constant :LISTEN_LOCAL_ADDRESS, :SELECT_AVAILABLE_PORT
 
-      # Options: same as values in option `transfer_info`
+      # Options: same as values in option `transfer`
       # (Args) : Options that influence `ascp` arguments.
       #
       # @param ascp_args         [Array]   (Args) Optional Additional arguments to ascp
       # @param wss               [Boolean] (Args) `true`: if both SSH and wss in ts: prefer wss
       # @param quiet             [Boolean] (Args) By default no native `ascp` progress bar
+      # @param file_list         [Boolean] (Args) true: provide file list in a file, else on command line.
       # @param client_ssh_key    [String]  (Args) Client SSH key option (from CLIENT_SSH_KEY_OPTIONS)
       # @param trusted_certs     [Array<String>] (Args) (WSS) Optional list of files with trusted certificates (stores)
       # @param check_ignore_cb   [Proc]    (Args) (WSS) Callback with host,port to check if WSS connection shall ignore certificate validity
@@ -44,6 +70,7 @@ module Aspera
         ascp_args:         nil,
         wss:               true,
         quiet:             true,
+        file_list:         true,
         client_ssh_key:    nil,
         trusted_certs:     nil,
         check_ignore_cb:   nil,
@@ -61,6 +88,7 @@ module Aspera
           ascp_args:       ascp_args,
           wss:             wss,
           quiet:           quiet,
+          file_list:       file_list,
           trusted_certs:   trusted_certs,
           client_ssh_key:  client_ssh_key,
           check_ignore_cb: check_ignore_cb
@@ -71,7 +99,7 @@ module Aspera
         @multi_incr_udp = multi_incr_udp.nil? ? Environment.instance.os.eql?(Environment::OS_WINDOWS) : multi_incr_udp
         @monitor = monitor
         @management_cb = management_cb
-        Aspera.assert_type(resume, Hash){'resume'}
+        Aspera.assert_type(resume, Hash) { 'resume' }
         @resume_policy = Transfer::Resumer.new(**resume.symbolize_keys)
         # all transfer jobs, key = SecureRandom.uuid, protected by mutex, cond var on change
         @sessions = []
@@ -97,7 +125,7 @@ module Aspera
           # using a non unique id results in discard of tags in AoC, and a package is never finalized
           # all sessions in a multi-session transfer must have the same xfer_id (see admin manual)
           transfer_spec['tags'][Transfer::Spec::TAG_RESERVED]['xfer_id'] ||= SecureRandom.uuid
-          Log.log.debug{"xfer id=#{transfer_spec['xfer_id']}"}
+          Log.log.debug { "xfer id=#{transfer_spec['xfer_id']}" }
           # TODO: useful ? node only ? seems to be a timeout for retry in node
           transfer_spec['tags'][Transfer::Spec::TAG_RESERVED]['xfer_retry'] ||= 3600
         end
@@ -111,7 +139,7 @@ module Aspera
             count: transfer_spec.delete('multi_session').to_i
           }
           if multi_session_info[:count].negative?
-            Log.log.error{"multi_session(#{transfer_spec['multi_session']}) shall be integer >= 0"}
+            Log.log.error { "multi_session(#{transfer_spec['multi_session']}) shall be integer >= 0" }
             multi_session_info = nil
           elsif multi_session_info[:count].eql?(0)
             Log.log.debug('multi_session count is zero: no multi session')
@@ -135,13 +163,13 @@ module Aspera
           io:                nil,               # management port server socket
           token_regenerator: token_regenerator, # regenerate bearer token with oauth
           # env vars and args for ascp (from transfer spec)
-          env_args:          Transfer::Parameters.new(transfer_spec, **@tr_opts).ascp_args
+          exec_spec:         Transfer::Parameters.new(transfer_spec, **@tr_opts).ascp_args
         }
 
         if multi_session_info.nil?
           Log.log.debug('Starting single session thread')
           # single session for transfer : simple
-          session[:thread] = Thread.new{transfer_thread_entry(session)}
+          session[:thread] = Thread.new { transfer_thread_entry(session) }
           @sessions.push(session)
         else
           Log.log.debug('Starting multi session threads')
@@ -151,28 +179,32 @@ module Aspera
             # 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
-            env_args = this_session[:env_args] = this_session[:env_args].clone
-            args = env_args[:args] = env_args[:args].clone
+            exec_spec = this_session[:exec_spec] = this_session[:exec_spec].deep_clone
             # set multi session part
-            args.unshift("-C#{i}:#{multi_session_info[:count]}")
+            exec_spec.args.unshift("-C#{i}:#{multi_session_info[:count]}")
             # option: increment (default as per ascp manual) or not (cluster on other side ?)
-            args.unshift('-O', (multi_session_info[:udp_base] + i - 1).to_s) if @multi_incr_udp
+            exec_spec.args.unshift('-O', (multi_session_info[:udp_base] + i - 1).to_s) if @multi_incr_udp
             # finally start the thread
-            this_session[:thread] = Thread.new{transfer_thread_entry(this_session)}
+            this_session[:thread] = Thread.new { transfer_thread_entry(this_session) }
             @sessions.push(this_session)
           end
         end
         return session[:job_id]
       end
 
+      # @return [String, nil] job_id of the last submitted transfer
+      def last_job_id
+        @sessions.last&.dig(:job_id)
+      end
+
       # wait for completion of all jobs started
-      # @return list of :success or error message
+      # @return [Array] list of :success or error message
       def wait_for_transfers_completion
         Log.log.debug('wait_for_transfers_completion')
         # set to non-nil to exit loop
         result = []
         @sessions.each do |session|
-          Log.log.debug{"join #{session[:thread]}"}
+          Log.log.debug { "join #{session[:thread]}" }
           session[:thread].join
           result.push(session[:error] || :success)
         end
@@ -191,7 +223,7 @@ module Aspera
       # @param id [String] Transfer session identifier
       # @return [Array] list of sessions for a job
       def sessions_by_job(id)
-        @sessions.select{ |session| session[:job_id].eql?(id)}
+        @sessions.select { |session| session[:job_id].eql?(id) }
       end
 
       # Send command to management port of command (used in `asession).
@@ -216,22 +248,22 @@ module Aspera
       private
 
       # transfer thread entry
-      # @param session information
+      # @param session [Hash] transfer session information
       def transfer_thread_entry(session)
         begin
           # set name for logging
           Thread.current[:name] = 'transfer'
-          Log.log.debug{"ENTER (#{Thread.current[:name]})"}
+          Log.log.debug { "ENTER (#{Thread.current[:name]})" }
           # start transfer with selected resumer policy
           @resume_policy.execute_with_resume do
-            start_and_monitor_process(session: session, **session[:env_args])
+            start_and_monitor_process(session: session, exec_spec: session[:exec_spec])
           end
           Log.log.debug('transfer ok'.bg_green)
         rescue => e
           session[:error] = e
           raise if Log.log.debug? || !e.is_a?(Transfer::Error)
         end
-        Log.log.debug{"EXIT (#{Thread.current[:name]})"}
+        Log.log.debug { "EXIT (#{Thread.current[:name]})" }
       end
 
       public
@@ -239,18 +271,17 @@ 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 [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)
+      # @param session  [Hash]            This session information, keys :io and :token_regenerator
+      # @param exec_spec [ExecSpec] Executable, environment variables and arguments (comes from ascp_args)
       # @return [nil] when process has exited
-      # @raise FaspError on error
+      # @raise [Transfer::FaspError] on error
       def start_and_monitor_process(
         session:,
-        name:,
-        env:,
-        args:
+        exec_spec:
       )
+        exec = exec_spec.exec
+        env  = exec_spec.env
+        args = exec_spec.args
         Aspera.assert_type(session, Hash)
         notify_progress(:sessions_init, info: 'starting')
         # Do not use `capture_stderr`
@@ -259,7 +290,7 @@ module Aspera
         spawn_args = {}
         command_pid = nil
         # Get location of command executable (ascp, async)
-        command_path = Ascp::Installation.instance.path(name)
+        command_path = Ascp::Installation.instance.path(exec)
         command_arguments = [command_path]
         begin
           if @monitor
@@ -271,7 +302,7 @@ module Aspera
             # make port ready to accept connections, before starting ascp
             mgt_server_socket.listen(1)
             # build arguments and add mgt port
-            command_arguments = if name.eql?(:async)
+            command_arguments = if exec.eql?(:async)
               [command_path, "--exclusive-mgmt-port=#{mgt_server_socket.local_address.ip_port}"]
             else
               [command_path, '-M', mgt_server_socket.local_address.ip_port.to_s]
@@ -286,12 +317,12 @@ module Aspera
           command_pid = Environment.secure_execute(*command_arguments, mode: :background, env: env, **spawn_args)
           # close here, but still used in other process (pipe)
           stderr_w&.close
-          notify_progress(:sessions_init, info: "waiting for #{name} to start")
+          notify_progress(:sessions_init, info: "waiting for #{exec} 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
           # So we use select to detect that anything happens on the socket (connection)
-          Log.log.debug{"before select, timeout: #{@spawn_timeout_sec}"}
+          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, 'timeout waiting mgt port connect (select not readable)', type: Transfer::Error)
@@ -320,17 +351,17 @@ module Aspera
               commands = JSON.parse(File.read(@command_file))
               send_command(commands)
             rescue => e
-              Log.log.error{e.to_s}
+              Log.log.error { e.to_s }
             end
             File.delete(@command_file)
           end
           Log.log.debug('management io closed')
           # check that last status was received before process exit
           last_event = processor.last_event
-          raise Transfer::Error, "No management event (#{last_event.class})" unless last_event.is_a?(Hash)
+          Aspera.assert_type(last_event, Hash, type: Transfer::Error) { 'management event' }
           case last_event['Type']
           when 'DONE'
-            Log.log.trace1{'Graceful shutdown, DONE message received'}
+            Log.log.trace1 { 'Graceful shutdown, DONE message received' }
           when 'ERROR'
             if /bearer token/i.match?(last_event['Description']) &&
                 session[:token_regenerator].respond_to?(:refreshed_transfer_token)
@@ -340,7 +371,7 @@ module Aspera
               env['ASPERA_SCP_TOKEN'] = session[:token_regenerator].refreshed_transfer_token
             end
             raise Transfer::Error.new(last_event['Description'], code: last_event['Code'].to_i)
-          else Aspera.error_unexpected_value(last_event['Type'], :error){'last event type'}
+          else Aspera.error_unexpected_value(last_event['Type'], :error) { 'last event type' }
           end
         rescue SystemCallError => e
           # Process.spawn failed, or socket error
@@ -359,16 +390,16 @@ module Aspera
               # 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}
+                Log.log.error { "BEGIN stderr #{exec}" } unless stderr_flag
+                Log.log.error { line.chomp }
                 stderr_flag = true
               end
-              Log.log.error{"END stderr #{name}"} if stderr_flag
+              Log.log.error { "END stderr #{exec}" } if stderr_flag
               stderr_r.close
             end
             # status is nil if an exception occurred before starting command
             if !status&.success?
-              message = "#{name} failed (#{status})"
+              message = "#{exec} failed (#{status})"
               # raise error only if there was not already an exception (`$ERROR_INFO`)
               raise Transfer::Error, message unless $ERROR_INFO
               # else display this message also, as main exception is already here
@@ -410,12 +441,12 @@ module Aspera
         when 'SESSION'
         when 'ARGSTOP'
         when 'FILEERROR'
-          Log.log.error{"#{event['Type']} #{event['Description']}"}
+          Log.log.error { "#{event['Type']} #{event['Description']}" }
         when 'STOP'
           # cspell:enable
           # stop event when one file is completed
         else
-          Log.log.debug{"Unknown event type for progress: #{event['Type']}"}
+          Log.log.debug { "Unknown event type for progress: #{event['Type']}" }
         end
       end
     end

data/lib/aspera/agent/factory.rb

@@ -24,9 +24,9 @@ module Aspera
       # Available agents: :long : Capitalized name string, :short : single character symbol
       ALL =
         Dir.children(File.dirname(File.expand_path(__FILE__)))
-          .select{ |file| file.end_with?(Environment::RB_EXT)}
-          .map{ |file| File.basename(file, Environment::RB_EXT).to_sym}
-          .reject{ |item| IGNORED_ITEMS.include?(item)}.to_h do |agent_sym|
+          .select { |file| file.end_with?(Environment::RB_EXT) }
+          .map { |file| File.basename(file, Environment::RB_EXT).to_sym }
+          .reject { |item| IGNORED_ITEMS.include?(item) }.to_h do |agent_sym|
           [agent_sym, {
             long:  agent_sym.to_s.capitalize,
             short: agent_sym.eql?(:direct) ? :a : agent_sym.to_s[0].to_sym

data/lib/aspera/agent/httpgw.rb

@@ -5,10 +5,32 @@ require 'aspera/transfer/spec'
 require 'aspera/api/httpgw'
 require 'aspera/log'
 require 'aspera/assert'
+require 'securerandom'
 
 module Aspera
   module Agent
     class Httpgw < Base
+      class << self
+        # Re-query the status of an httpgw transfer that was started in-process.
+        # Only works if the same Ruby process is still alive (e.g. MCP mode).
+        # agent_params must contain '_agent_ref' pointing to the live Httpgw instance.
+        # @param transfer_id  [String] job_id returned by last_job_id
+        # @param agent_params [Hash]   '_agent_ref' is the live agent instance
+        # @return [Hash] status hash with at least 'status' key
+        def transfer_status(transfer_id, agent_params)
+          agent = agent_params['_agent_ref']
+          return {'status' => 'unknown', 'note' => 'httpgw agent not available (different process?)'} if agent.nil?
+          return {'status' => 'unknown', 'note' => 'no transfer started'} if agent.instance_variable_get(:@transfer_thread).nil?
+          if agent.instance_variable_get(:@transfer_thread).alive?
+            {'status' => 'running'}
+          elsif (err = agent.instance_variable_get(:@transfer_error))
+            {'status' => 'failed', 'error' => err.message}
+          else
+            {'status' => 'completed'}
+          end
+        end
+      end
+
       def initialize(
         url:,
         api_version: Api::Httpgw::API_V2,
@@ -23,34 +45,53 @@ module Aspera
           api_version:       api_version,
           upload_chunk_size: upload_chunk_size,
           synchronous:       synchronous,
-          notify_cb:         ->(*pa, **ka){notify_progress(*pa, **ka)}
+          notify_cb:         ->(*pa, **ka) { notify_progress(*pa, **ka) }
         )
+        @last_job_id = nil
+        @transfer_thread = nil
+        @transfer_error  = nil
       end
 
-      # Start FASP transfer based on transfer spec (hash table)
-      # note that this should be asynchronous, but it is not
-      # HTTP download only supports file list
+      # Start FASP transfer based on transfer spec (hash table).
+      # Non-blocking: the actual upload/download runs in a dedicated thread.
+      # HTTP download only supports file list.
       # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: 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'}
+        Aspera.assert_type(transfer_spec['paths'], Array) { 'paths' }
+        Aspera.assert_type(transfer_spec['token'], String) { 'only token based transfer is supported in GW' }
         Log.dump(:user_spec, transfer_spec)
         transfer_spec['authentication'] ||= 'token'
+        @last_job_id     = SecureRandom.uuid
+        @transfer_error  = nil
+        @transfer_thread = Thread.new { run_transfer(transfer_spec) }
+        @last_job_id
+      end
+
+      # Wait for the transfer thread to complete.
+      # @return [Array] list of :success or error
+      def wait_for_transfers_completion
+        @transfer_thread&.join
+        return [@transfer_error || :success]
+      end
+
+      # @return [String, nil] job_id of the last submitted transfer
+      attr_reader :last_job_id
+
+      private
+
+      # Execute the actual transfer (runs inside the transfer thread).
+      def run_transfer(transfer_spec)
         case transfer_spec['direction']
         when Transfer::Spec::DIRECTION_SEND
           @gw_api.upload(transfer_spec)
         when Transfer::Spec::DIRECTION_RECEIVE
           @gw_api.download(transfer_spec)
-        else Aspera.error_unexpected_value(transfer_spec['direction']){'direction'}
+        else Aspera.error_unexpected_value(transfer_spec['direction']) { 'direction' }
         end
-      end
-
-      # Wait for completion of all jobs started
-      # @return list of :success or error message
-      def wait_for_transfers_completion
-        # well ... transfer was done in "start"
-        return [:success]
+      rescue => e
+        @transfer_error = e
+        Log.log.error { "httpgw transfer thread error: #{e}" }
       end
     end
   end

data/lib/aspera/agent/node.rb

@@ -13,6 +13,38 @@ module Aspera
     # this singleton class is used by the CLI to provide a common interface to start a transfer
     # before using it, the use must set the `node_api` member.
     class Node < Base
+      class << self
+        # Re-query a previously started transfer via the Node REST API.
+        # agent_params must contain 'url', 'username', 'password' (and optionally 'root_id').
+        # @return [Hash] normalized status hash
+        def transfer_status(transfer_id, agent_params)
+          rest_params = {base_url: agent_params['url']}
+          if OAuth::Factory.bearer_auth?(agent_params['password'])
+            rest_params[:headers] = Api::Node.bearer_headers(agent_params['password'], access_key: agent_params['username'])
+          else
+            rest_params[:auth] = {type: :basic, username: agent_params['username'], password: agent_params['password']}
+          end
+          node_api = Rest.new(**rest_params)
+          data = node_api.read("ops/transfers/#{transfer_id}") || {'status' => 'unknown'}
+          normalize_status(data)
+        end
+
+        # Normalize a node API transfer hash into the standard async-transfer fields.
+        def normalize_status(data)
+          result = {'bytes_transferred' => data['bytes_transferred'].to_i}
+          case data['status']
+          when 'completed'
+            result['status'] = 'completed'
+            result['ended_at'] = Time.now.utc.iso8601
+          when 'failed'
+            result.merge!('status' => 'failed', 'ended_at' => Time.now.utc.iso8601, 'error' => data['error_desc'].to_s)
+          else
+            result['status'] = 'running'
+          end
+          result
+        end
+      end
+
       # @param url          [String] the base url of the node api
       # @param username     [String] the username to use for the node api
       # @param password     [String] the password to use for the node api
@@ -63,7 +95,7 @@ module Aspera
         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}"}
+        Log.log.debug { "tr_id=#{@transfer_id}" }
         return @transfer_id
       end
 
@@ -105,7 +137,7 @@ module Aspera
             # 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']}"
-          else Aspera.error_unexpected_value(transfer_data['status']){"transfer_data -> #{transfer_data}"}
+          else Aspera.error_unexpected_value(transfer_data['status']) { "transfer_data -> #{transfer_data}" }
           end
           sleep(1.0)
         end

data/lib/aspera/agent/transferd.rb

@@ -21,6 +21,37 @@ module Aspera
 
       private_constant :LOCAL_SOCKET_ADDR, :PORT_SEP, :AUTO_LOCAL_TCP_PORT
 
+      class << self
+        # Re-query a previously started transfer from a running transferd daemon.
+        # agent_params must contain 'url' (the daemon endpoint, e.g. "127.0.0.1:12345").
+        # @return [Hash] normalized status hash
+        def transfer_status(transfer_id, agent_params)
+          client = ::Transferd::Api::TransferService::Stub.new(agent_params['url'], :this_channel_is_insecure)
+          result = {'bytes_transferred' => 0}
+          client.monitor_transfers(::Transferd::Api::RegistrationRequest.new(transferId: [transfer_id])) do |response|
+            result = case response.status
+            when :COMPLETED
+              {
+                'status' => 'completed', 'ended_at' => Time.now.utc.iso8601,
+                        'bytes_transferred' => response.transferInfo.bytesTransferred
+              }
+            when :FAILED, :CANCELED
+              {
+                'status' => response.status == :FAILED ? 'failed' : 'cancelled',
+                        'ended_at' => Time.now.utc.iso8601, 'bytes_transferred' => 0,
+                        'error' => JSON.parse(response.message.to_s)['Description']
+              }
+            else
+              {'status' => 'running', 'bytes_transferred' => response.transferInfo.bytesTransferred}
+            end
+            break
+          end
+          result
+        rescue StandardError => e
+          {'status' => 'running', 'bytes_transferred' => 0, 'error' => e.message}
+        end
+      end
+
       # @param url   [String]  URL of the transfer manager daemon
       # @param start [Boolean] If `false`, expect that an external daemon is already running
       # @param stop  [Boolean] If `false`, do not shutdown daemon on exit
@@ -35,9 +66,10 @@ module Aspera
         @transfer_id = nil
         @stop = stop
         is_local_auto_port = url.eql?(AUTO_LOCAL_TCP_PORT)
-        raise Error, 'Cannot set options `stop` or `start` to false with port zero' if is_local_auto_port && (!@stop || !start)
+        Aspera.assert(!(is_local_auto_port && (!@stop || !start)), type: Error) { 'Cannot set options `stop` or `start` to false with port zero' }
         # keep PID for optional shutdown
         @daemon_pid = nil
+        @daemon_endpoint = nil
         daemon_endpoint = url
         Log.dump(:daemon_endpoint, daemon_endpoint)
         # retry loop
@@ -48,18 +80,19 @@ module Aspera
           @transfer_client = ::Transferd::Api::TransferService::Stub.new(daemon_endpoint, :this_channel_is_insecure)
           # Initiate actual connection
           get_info_response = @transfer_client.get_info(::Transferd::Api::InstanceInfoRequest.new)
-          Log.log.debug{"Daemon info: #{get_info_response}"}
+          @daemon_endpoint = daemon_endpoint
+          Log.log.debug { "Daemon info: #{get_info_response}" }
           Log.log.warn('Attached to existing daemon') unless @daemon_pid || !start || !@stop
-          at_exit{shutdown}
+          at_exit { shutdown }
         rescue GRPC::Unavailable => e
           # if transferd is external: do not start it, or other error
           raise if !start || !e.message.include?('failed to connect')
           # we already tried to start a daemon, but it failed
-          Aspera.assert(@daemon_pid.nil?){"Daemon started with PID #{@daemon_pid}, but connection failed to #{daemon_endpoint}}"}
+          Aspera.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 !start
           # transferd only supports local ip and port
           daemon_uri = URI.parse("ipv4://#{daemon_endpoint}")
-          Aspera.assert(daemon_uri.scheme.eql?('ipv4')){"Invalid scheme daemon URI #{daemon_endpoint}"}
+          Aspera.assert(daemon_uri.scheme.eql?('ipv4')) { "Invalid scheme daemon URI #{daemon_endpoint}" }
           # create a config file for daemon
           config = {
             address:      daemon_uri.host,
@@ -74,7 +107,7 @@ module Aspera
           }
           # 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}"}
+          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"
@@ -95,9 +128,9 @@ module Aspera
           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) unless @stop
-          at_exit{shutdown}
+          at_exit { shutdown }
           # update port for next connection attempt (if auto high port was requested)
           daemon_endpoint = "#{LOCAL_SOCKET_ADDR}#{PORT_SEP}#{Products::Transferd.daemon_port_from_log(log_stdout)}" if is_local_auto_port
           # local daemon started, try again
@@ -105,6 +138,9 @@ module Aspera
         end
       end
 
+      # Actual endpoint the daemon is listening on (resolved after connect, e.g. when port 0 was used)
+      attr_reader :daemon_endpoint
+
       # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
         Transfer::Spec.fix_transferd_resume_policy(transfer_spec)
@@ -116,10 +152,10 @@ module Aspera
         ) # transfer definition
         # send start transfer request to the transfer manager daemon
         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}"}
+        Aspera.assert(!start_response.status.eql?(:FAILED), type: Transfer::Error) { start_response.error.description }
+        Log.log.debug { "start transfer response #{start_response}" }
         @transfer_id = start_response.transferId
-        Log.log.debug{"transfer started with id #{@transfer_id}"}
+        Log.log.debug { "transfer started with id #{@transfer_id}" }
       end
 
       def wait_for_transfers_completion
@@ -154,7 +190,7 @@ module Aspera
           when :QUEUED, :UNKNOWN_STATUS, :PAUSED, :ORPHANED
             notify_progress(:sessions_init, info: response.status.to_s.downcase)
           else
-            Log.log.error{"unknown status#{response.status}"}
+            Log.log.error { "unknown status#{response.status}" }
           end
         end
         # TODO: return status

data/lib/aspera/api/alee.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'aspera/api/aoc.rb'
+require 'aspera/api/aoc'
 module Aspera
   module Api
     # Aspera License Entitlement Engine API client