aspera-cli 4.21.1 → 4.22.0

data/lib/aspera/agent/direct.rb

@@ -16,15 +16,68 @@ require 'English'
 
 module Aspera
   module Agent
-    # executes a local "ascp", connects mgt port, equivalent of "Fasp Manager"
+    # executes a local "ascp", create mgt port
     class Direct < Base
+      # ascp started locally, so listen local
       LISTEN_LOCAL_ADDRESS = '127.0.0.1'
-      # 0 means: select an available port
+      # 0 means: use any available port
       SELECT_AVAILABLE_PORT = 0
-      # spellchecker: enable
       private_constant :LISTEN_LOCAL_ADDRESS, :SELECT_AVAILABLE_PORT
 
-      # method of Base
+      # options for initialize (same as values in option transfer_info)
+      # @param ascp_args         [Array]   additional arguments to ascp
+      # @param wss               [Boolean] true: if both SSH and wss in ts: prefer wss
+      # @param quiet             [Boolean] by default no native ascp progress bar
+      # @param monitor           [Boolean] set to false to eliminate management port
+      # @param trusted_certs     [Array,NilClass] list of files with trusted certificates (stores)
+      # @param client_ssh_key    [String]  client ssh key option (from CLIENT_SSH_KEY_OPTIONS)
+      # @param check_ignore_cb   [Proc]    callback with host,port
+      # @param spawn_timeout_sec [Integer] timeout for ascp spawn
+      # @param spawn_delay_sec   [Integer] optional delay to start between sessions
+      # @param multi_incr_udp    [Boolean,NilClass] true: increment udp port for each session
+      # @param resume            [Hash,NilClass] resume policy
+      # @param management_cb     [Proc]    callback for management events
+      # @param base_options      [Hash]    other options for base class
+      def initialize(
+        ascp_args:         nil,
+        wss:               true,
+        quiet:             true,
+        trusted_certs:     nil,
+        client_ssh_key:    nil,
+        check_ignore_cb:   nil,
+        spawn_timeout_sec: 2,
+        spawn_delay_sec:   2,
+        multi_incr_udp:    nil,
+        resume:            nil,
+        monitor:           true,
+        management_cb:     nil,
+        **base_options
+      )
+        super(**base_options)
+        # special transfer parameters
+        @tr_opts = {
+          ascp_args:       ascp_args,
+          wss:             wss,
+          quiet:           quiet,
+          trusted_certs:   trusted_certs,
+          client_ssh_key:  client_ssh_key,
+          check_ignore_cb: check_ignore_cb
+        }
+        @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
+        @monitor = monitor
+        @management_cb = management_cb
+        @resume_policy = Resumer.new(resume.nil? ? {} : 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
+        @pre_calc_sent = false
+        @pre_calc_last_size = nil
+      end
+
       # start ascp transfer(s) (non blocking), single or multi-session
       # session information added to @sessions
       # @param transfer_spec [Hash] aspera transfer specification
@@ -48,11 +101,10 @@ module Aspera
         # (even if the var is not used in single session)
         multi_session_info = nil
         if transfer_spec.key?('multi_session')
+          # Managed by multi-session, so delete from transfer spec
           multi_session_info = {
-            count: transfer_spec['multi_session'].to_i
+            count: transfer_spec.delete('multi_session').to_i
           }
-          # Managed by multi-session, so delete from transfer spec
-          transfer_spec.delete('multi_session')
           if multi_session_info[:count].negative?
             Log.log.error{"multi_session(#{transfer_spec['multi_session']}) shall be integer >= 0"}
             multi_session_info = nil
@@ -77,14 +129,14 @@ module Aspera
           error:             nil,               # exception if failed
           io:                nil,               # management port server socket
           token_regenerator: token_regenerator, # regenerate bearer token with oauth
-          # env vars and args to ascp (from transfer spec)
+          # env vars and args for ascp (from transfer spec)
           env_args:          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')
@@ -101,7 +153,7 @@ module Aspera
             # 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
             # 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
@@ -132,9 +184,44 @@ module Aspera
 
       # @return [Array] list of sessions for a job
       def sessions_by_job(job_id)
-        @sessions.select{|session| session[:job_id].eql?(job_id)}
+        @sessions.select{ |session| session[:job_id].eql?(job_id)}
       end
 
+      # send command to management port of command (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, data)
+        session = @sessions.find{ |session| session[:job_id].eql?(job_id)}
+        Log.log.debug{"command: #{data}"}
+        session[:io].puts(Ascp::Management.command_to_stream(data))
+      end
+
+      private
+
+      # transfer thread entry
+      # @param session information
+      def transfer_thread_entry(session)
+        begin
+          # set name for logging
+          Thread.current[:name] = 'transfer'
+          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])
+          end
+          Log.log.debug('transfer ok'.bg_green)
+        rescue StandardError => e
+          session[:error] = e
+          Log.log.error{"Transfer thread error: #{e.class}:\n#{e.message}:\n#{e.backtrace.join("\n")}".red} if Log.instance.level.eql?(:debug)
+        end
+        Log.log.debug{"EXIT (#{Thread.current[:name]})"}
+      end
+
+      public
+
       # This is the low level method to start the transfer process.
       # Typically started in a thread.
       # Start process with management port.
@@ -154,24 +241,32 @@ module Aspera
         notify_progress(:pre_start, session_id: nil, info: 'starting')
         begin
           command_pid = nil
-          # we use Socket directly, instead of TCPServer, as it gives access to lower level options
-          socket_class = defined?(JRUBY_VERSION) ? ServerSocket : Socket
-          mgt_server_socket = socket_class.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-          # open any available (0) local TCP port for use as management port
-          mgt_server_socket.bind(Addrinfo.tcp(LISTEN_LOCAL_ADDRESS, SELECT_AVAILABLE_PORT))
-          # 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)
-            ["--exclusive-mgmt-port=#{mgt_server_socket.local_address.ip_port}"]
-          else
-            ['-M', mgt_server_socket.local_address.ip_port.to_s]
+          command_arguments = []
+          if @monitor
+            # we use Socket directly, instead of TCPServer, as it gives access to lower level options
+            socket_class = defined?(JRUBY_VERSION) ? ServerSocket : Socket
+            mgt_server_socket = socket_class.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+            # open any available (0) local TCP port for use as management port
+            mgt_server_socket.bind(Addrinfo.tcp(LISTEN_LOCAL_ADDRESS, SELECT_AVAILABLE_PORT))
+            # 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)
+              ["--exclusive-mgmt-port=#{mgt_server_socket.local_address.ip_port}"]
+            else
+              ['-M', mgt_server_socket.local_address.ip_port.to_s]
+            end
           end
           command_arguments.concat(args)
+          # capture process stderr
+          stderr_r, stderr_w = IO.pipe
           # 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)
+          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")
+          # "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}"}
@@ -182,9 +277,9 @@ module Aspera
           client_socket, _client_addrinfo = mgt_server_socket.accept
           Log.log.debug('after accept')
           management_port_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
+          # management messages include file names which may be UTF-8
+          # TODO: use same value as Encoding.default_external ?
           management_port_io.set_encoding(Encoding::UTF_8)
           session[:io] = management_port_io
           processor = Ascp::Management.new
@@ -194,7 +289,7 @@ module Aspera
             next unless event
             # event is ready
             Log.log.trace1{Log.dump(:management_port, event)}
-            # store latest event by type
+            # store session identifier
             session[:id] = event['SessionId'] if event['Type'].eql?('INIT')
             @management_cb&.call(event)
             process_progress(event)
@@ -203,8 +298,10 @@ module Aspera
           Log.log.debug('management io closed')
           # check that last status was received before process exit
           last_event = processor.last_event
-          raise Transfer::Error, "internal: no management event (#{last_event.class})" unless last_event.is_a?(Hash)
+          raise Transfer::Error, "No management event (#{last_event.class})" unless last_event.is_a?(Hash)
           case last_event['Type']
+          when 'DONE'
+            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)
@@ -214,10 +311,9 @@ 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)
-          when 'DONE'
-            nil
           else
-            raise Transfer::Error, "unexpected last event type: #{last_event['Type']}, #{last_event['Description']}"
+            Log.log.error{"unexpected last event type: #{last_event['Type']}"}
+            # raise Transfer::Error, "unexpected last event type: #{last_event['Type']}, #{last_event['Description']}"
           end
         rescue SystemCallError => e
           # Process.spawn failed, or socket error
@@ -225,17 +321,21 @@ module Aspera
         rescue Interrupt
           raise Transfer::Error, 'transfer interrupted by user'
         ensure
-          mgt_server_socket.close
+          mgt_server_socket&.close
+          session.delete(:io)
           # if command was successfully started, check its status
           unless command_pid.nil?
-            # "wait" for process to avoid zombie
-            Process.wait(command_pid)
-            status = $CHILD_STATUS
-            # command_pid = nil
-            session.delete(:io)
+            Process.kill(:INT, command_pid) if @monitor
+            # 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)
+            end
+            stderr_r.close
             # status is nil if an exception occurred before starting command
             if !status&.success?
-              message = status.nil? ? "#{name} not started" : "#{name} failed (#{status})"
+              message = "#{name} 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
@@ -246,10 +346,10 @@ module Aspera
         nil
       end
 
-      attr_reader :sessions
-
       private
 
+      attr_reader :sessions
+
       # notify progress to callback
       # @param event management port event
       # @param session sessin object
@@ -285,88 +385,8 @@ module Aspera
           # cspell:enable
           # stop event when one file is completed
         else
-          Log.log.debug{"unknown event type #{event['Type']}"}
-        end
-      end
-
-      # send command to management port of command (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, data)
-        session = @sessions.find{|session| session[:job_id].eql?(job_id)}
-        Log.log.debug{"command: #{data}"}
-        session[:io].puts(Ascp::Management.command_to_stream(data))
-      end
-
-      # options for initialize (same as values in option transfer_info)
-      # @param ascp_args [Array] additional arguments to ascp
-      # @param wss [Boolean] true: if both SSH and wss in ts: prefer wss
-      # @param quiet [Boolean] by default no native ascp progress bar
-      # @param trusted_certs [Array,NilClass] list of files with trusted certificates (stores)
-      # @param client_ssh_key [String] client ssh key option (from CLIENT_SSH_KEY_OPTIONS)
-      # @param check_ignore_cb [Proc] callback with host,port
-      # @param spawn_timeout_sec [Integer] timeout for ascp spawn
-      # @param spawn_delay_sec [Integer] optional delay to start between sessions
-      # @param multi_incr_udp [Boolean,NilClass] true: increment udp port for each session
-      # @param resume [Hash,NilClass] resume policy
-      # @param management_cb [Proc] callback for management events
-      # @param base_options [Hash] other options for base class
-      def initialize(
-        ascp_args:         nil,
-        wss:               true,
-        quiet:             true,
-        trusted_certs:     nil,
-        client_ssh_key:    nil,
-        check_ignore_cb:   nil,
-        spawn_timeout_sec: 2,
-        spawn_delay_sec:   2,
-        multi_incr_udp:    nil,
-        resume:            nil,
-        management_cb:     nil,
-        **base_options
-      )
-        super(**base_options)
-        # special transfer parameters
-        @tr_opts = {
-          ascp_args:       ascp_args,
-          wss:             wss,
-          quiet:           quiet,
-          trusted_certs:   trusted_certs,
-          client_ssh_key:  client_ssh_key,
-          check_ignore_cb: check_ignore_cb
-        }
-        @spawn_timeout_sec = spawn_timeout_sec
-        @spawn_delay_sec = spawn_delay_sec
-        # default is true on windows, false on other platforms
-        @multi_incr_udp = multi_incr_udp.nil? ? Environment.os.eql?(Environment::OS_WINDOWS) : multi_incr_udp
-        @management_cb = management_cb
-        @resume_policy = Resumer.new(resume.nil? ? {} : 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
-      # @param session information
-      def transfer_thread_entry(session)
-        begin
-          # set name for logging
-          Thread.current[:name] = 'transfer'
-          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])
-          end
-          Log.log.debug('transfer ok'.bg_green)
-        rescue StandardError => e
-          session[:error] = e
-          Log.log.error{"Transfer thread error: #{e.class}:\n#{e.message}:\n#{e.backtrace.join("\n")}".red} if Log.instance.level.eql?(:debug)
+          Log.log.debug{"Unknown event type for progress: #{event['Type']}"}
         end
-        Log.log.debug{"EXIT (#{Thread.current[:name]})"}
       end
     end
   end

data/lib/aspera/agent/httpgw.rb

@@ -9,9 +9,28 @@ require 'aspera/assert'
 module Aspera
   module Agent
     class Httpgw < Base
-      # start FASP transfer based on transfer spec (hash table)
-      # note that it is asynchronous
+      def initialize(
+        url:,
+        api_version: Api::Httpgw::API_V2,
+        upload_chunk_size: 64_000,
+        synchronous:       false,
+        **base_options
+      )
+        super(**base_options)
+        @gw_api = Api::Httpgw.new(
+          # remove /v1 from end of user-provided GW url: we need the base url only
+          url:               url,
+          api_version:       api_version,
+          upload_chunk_size: upload_chunk_size,
+          synchronous:       synchronous,
+          notify_cb:         ->(*pa, **ka){notify_progress(*pa, **ka)}
+        )
+      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
+      # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
         raise 'GW URL must be set' if @gw_api.nil?
         Aspera.assert_type(transfer_spec['paths'], Array){'paths'}
@@ -27,35 +46,12 @@ module Aspera
         end
       end
 
-      # wait for completion of all jobs started
+      # 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]
       end
-
-      # TODO: is that useful?
-      # def url=(api_url); end
-
-      private
-
-      def initialize(
-        url:,
-        api_version: Api::Httpgw::API_V2,
-        upload_chunk_size: 64_000,
-        synchronous:       false,
-        **base_options
-      )
-        super(**base_options)
-        @gw_api = Api::Httpgw.new(
-          # remove /v1 from end of user-provided GW url: we need the base url only
-          url:               url,
-          api_version:       api_version,
-          upload_chunk_size: upload_chunk_size,
-          synchronous:       synchronous,
-          notify_cb:         ->(*pa, **ka) { notify_progress(*pa, **ka) }
-        )
-      end
     end
   end
 end

data/lib/aspera/agent/node.rb

@@ -13,10 +13,10 @@ 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
-      # @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
-      # @param root_id [String] root file id if the node is an access key
+      # @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
+      # @param root_id      [String] root file id if the node is an access key
       # @param base_options [Hash] options for base class
       def initialize(
         url:,
@@ -28,7 +28,7 @@ module Aspera
         super(**base_options)
         # root id is required for access key
         @root_id = root_id
-        rest_params = { base_url: url}
+        rest_params = {base_url: url}
         if OAuth::Factory.bearer?(password)
           Aspera.assert(!@root_id.nil?){'root_id not allowed for access key'}
           rest_params[:headers] = Api::Node.bearer_headers(password, access_key: username)
@@ -44,13 +44,8 @@ module Aspera
         @transfer_id = nil
       end
 
-      # used internally to ensure node api is set before using.
-      def node_api_
-        Aspera.assert(!@node_api.nil?){'Before using this object, set the node_api attribute to a Aspera::Rest object'}
-        return @node_api
-      end
-
       # generic method
+      # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
         # add root id if access key
         if !@root_id.nil?
@@ -119,6 +114,14 @@ module Aspera
         # TODO: get status of sessions
         return []
       end
+
+      private
+
+      # used internally to ensure node api is set before using.
+      def node_api_
+        Aspera.assert(!@node_api.nil?){'Before using this object, set the node_api attribute to a Aspera::Rest object'}
+        return @node_api
+      end
     end
   end
 end

data/lib/aspera/agent/transferd.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'aspera/environment'
 require 'aspera/agent/base'
 require 'aspera/products/transferd'
 require 'aspera/temp_file_manager'
@@ -17,20 +18,23 @@ module Aspera
       # port zero means select a random available high port
       AUTO_LOCAL_TCP_PORT = "#{PORT_SEP}0"
 
-      # @param url [String] URL of the transfer manager daemon
-      # @param external [Boolean] if true, expect that an external daemon is already running
-      # @param keep [Boolean] if true, do not shutdown daemon on exit
-      # @param base_options [Hash] base options
+      private_constant :LOCAL_SOCKET_ADDR, :PORT_SEP, :AUTO_LOCAL_TCP_PORT
+
+      # @param url   [String] URL of the transfer manager daemon
+      # @param start [Bool]   if false, expect that an external daemon is already running
+      # @param stop  [Bool]   if false, do not shutdown daemon on exit
+      # @param base  [Hash]   base class options
       def initialize(
-        url: AUTO_LOCAL_TCP_PORT,
-        external: false,
-        keep:     false,
-        **base_options
+        url:   AUTO_LOCAL_TCP_PORT,
+        start: true,
+        stop:  true,
+        **base
       )
-        super(**base_options)
-        @keep = keep
+        super(**base)
+        @transfer_id = nil
+        @stop = stop
         is_local_auto_port = url.eql?(AUTO_LOCAL_TCP_PORT)
-        raise 'Cannot use options `keep` or `external` with port zero' if is_local_auto_port && (@keep || external)
+        raise '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
@@ -44,14 +48,14 @@ module Aspera
           # Initiate actual connection
           get_info_response = @transfer_client.get_info(::Transferd::Api::InstanceInfoRequest.new)
           Log.log.debug{"Daemon info: #{get_info_response}"}
-          Log.log.warn{'Attached to existing daemon'} unless @daemon_pid || external || @keep
+          Log.log.warn('Attached to existing daemon') unless @daemon_pid || !start || !@stop
           at_exit{shutdown}
         rescue GRPC::Unavailable => e
           # if transferd is external: do not start it, or other error
-          raise if external || !e.message.include?('failed to connect')
+          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}}"}
-          Log.log.warn('no daemon present, starting daemon...') if external
+          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}"}
@@ -74,7 +78,11 @@ module Aspera
           log_stdout = "#{transferd_base_tmp}.out"
           log_stderr = "#{transferd_base_tmp}.err"
           File.write(conf_file, config.to_json)
-          @daemon_pid = Process.spawn(Ascp::Installation.instance.path(:transferd), '--config', conf_file, out: log_stdout, err: log_stderr)
+          @daemon_pid = Environment.secure_spawn(
+            exec: Ascp::Installation.instance.path(:transferd),
+            args: ['--config', conf_file],
+            out: log_stdout,
+            err: log_stderr)
           begin
             # wait for process to initialize, max 2 seconds
             Timeout.timeout(2.0) do
@@ -86,8 +94,8 @@ module Aspera
             nil
           end
           Log.log.debug{"Daemon started with pid #{@daemon_pid}"}
-          Process.detach(@daemon_pid) if @keep
-          at_exit {shutdown}
+          Process.detach(@daemon_pid) unless @stop
+          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
@@ -95,6 +103,7 @@ module Aspera
         end
       end
 
+      # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
         # create a transfer request
         transfer_request = ::Transferd::Api::TransferRequest.new(
@@ -146,13 +155,15 @@ module Aspera
       end
 
       def shutdown
-        stop_daemon unless @keep
+        stop_daemon if @stop
       end
 
+      private
+
       def stop_daemon
         if !@daemon_pid.nil?
           Log.log.debug("Stopping daemon #{@daemon_pid}")
-          Process.kill('INT', @daemon_pid)
+          Process.kill(:INT, @daemon_pid)
           _, status = Process.wait2(@daemon_pid)
           Log.log.debug("daemon stopped #{status}")
           @daemon_pid = nil

data/lib/aspera/api/alee.rb

@@ -7,7 +7,7 @@ module Aspera
       def initialize(entitlement_id, customer_id, api_domain: AoC::SAAS_DOMAIN_PROD, version: 'v1')
         super(
           base_url: "https://api.#{api_domain}/metering/#{version}",
-          headers:  {'X-Aspera-Entitlement-Authorization' => Rest.basic_token(entitlement_id, customer_id)}
+          headers:  {'X-Aspera-Entitlement-Authorization' => Rest.basic_authorization(entitlement_id, customer_id)}
         )
       end
     end

data/lib/aspera/api/aoc.rb

@@ -22,7 +22,7 @@ module Aspera
       MAX_AOC_URL_REDIRECT = 10
       CLIENT_ID_PREFIX = 'aspera.'
       # Well-known AoC global client apps
-      GLOBAL_CLIENT_APPS = DataRepository::ELEMENTS.select{|i|i.to_s.start_with?(CLIENT_ID_PREFIX)}.freeze
+      GLOBAL_CLIENT_APPS = DataRepository::ELEMENTS.select{ |i| i.to_s.start_with?(CLIENT_ID_PREFIX)}.freeze
       # cookie prefix so that console can decode identity
       COOKIE_PREFIX_CONSOLE_AOC = 'aspera.aoc'
       # path in URL of public links
@@ -237,7 +237,7 @@ module Aspera
             Log.log.debug{"ignoring error: #{e}"}
             {}
           end
-        USER_INFO_FIELDS_MIN.each{|f|@cache_user_info[f] = nil if @cache_user_info[f].nil?}
+        USER_INFO_FIELDS_MIN.each{ |f| @cache_user_info[f] = nil if @cache_user_info[f].nil?}
         return @cache_user_info
       end
 
@@ -283,7 +283,7 @@ module Aspera
           if ws_info.nil?
             {
               id:   nil,
-              name: 'Shared folders'
+              name: "Shared #{application}"
             }
           else
             {
@@ -386,10 +386,10 @@ module Aspera
           Aspera.assert(field.key?('name')){'metadata field must have name'}
           Aspera.assert(field.key?('values')){'metadata field must have values'}
           Aspera.assert_type(field['values'], Array){'metadata field values'}
-          Aspera.assert(!meta_schema.none?{|i|i['name'].eql?(field['name'])}){"unknown metadata field: #{field['name']}"}
+          Aspera.assert(!meta_schema.none?{ |i| i['name'].eql?(field['name'])}){"unknown metadata field: #{field['name']}"}
         end
         meta_schema.each do |field|
-          provided = pkg_meta.select{|i|i['name'].eql?(field['name'])}
+          provided = pkg_meta.select{ |i| i['name'].eql?(field['name'])}
           raise "only one field with name #{field['name']} allowed" if provided.count > 1
           raise "missing mandatory field: #{field['name']}" if field['required'] && provided.empty?
         end
@@ -519,7 +519,7 @@ module Aspera
         # Console cookie
         ################
         # we are sure that fields are not nil
-        cookie_elements = [app_info[:app], current_user_info['name'] || 'public link', current_user_info['email'] || 'none'].map{|e|Base64.strict_encode64(e)}
+        cookie_elements = [app_info[:app], current_user_info['name'] || 'public link', current_user_info['email'] || 'none'].map{ |e| Base64.strict_encode64(e)}
         cookie_elements.unshift(COOKIE_PREFIX_CONSOLE_AOC)
         transfer_spec['cookie'] = cookie_elements.join(':')
         # Application tags