aspera-cli 4.27.2 → 4.27.4

data/lib/aspera/cli/transfer_actions.rb

@@ -15,7 +15,8 @@ module Aspera
     #
     # Architecture:
     #   - remote-daemon agents (desktop, node, connect, transferd): transfer_id + agent_params
-    #     are persisted in AsyncTransferStore; status is re-queried via Agent::Xxx.transfer_status
+    #     are persisted in AsyncTransferStore (without secrets, taken from current options);
+    #     status is re-queried via Agent::Xxx.transfer_status
     #   - direct agent: transfers live in Ruby threads - store is the agent's @sessions;
     #     status is not persistable across process restarts (returns an informational message)
     module TransferActions
@@ -25,10 +26,12 @@ module Aspera
         store = async_transfer_store
         entry = store.read(job_id)
         Aspera.assert(!entry.nil?, type: Cli::BadArgument) { "Unknown job_id: #{job_id}" }
+        # Secrets are not persisted: take them from current transfer options (e.g. `--transfer`), for the same agent type
+        agent_params = current_agent_params(entry['agent_type']).merge(entry['agent_params'] || {})
         # Inject the in-process agent reference (direct/httpgw) if still alive in this process.
         ref = store.agent_ref(job_id)
-        entry['agent_params']['_agent_ref'] = ref if ref
-        live = query_live_status(entry)
+        agent_params['_agent_ref'] = ref if ref
+        live = query_live_status(entry.merge('agent_params' => agent_params))
         if live
           entry.merge!(live)
           store.write(job_id, entry)
@@ -36,12 +39,6 @@ module Aspera
         Result::SingleObject.new(entry)
       end
 
-      # List all persisted async transfer entries.
-      def action_transfer_list(**)
-        rows = async_transfer_store.list
-        Result::ObjectList.new(rows, fields: %w[job_id agent_type status started_at ended_at bytes_transferred transfer_id])
-      end
-
       TERMINAL_STATUSES = %w[completed failed cancelled].freeze
       private_constant :TERMINAL_STATUSES
 
@@ -59,6 +56,14 @@ module Aspera
 
       private
 
+      # @param agent_type [String] agent of the async transfer
+      # @return [Hash] agent parameters from current transfer options (e.g. `--transfer`), if for the same agent type
+      def current_agent_params(agent_type)
+        current = context.transfer.transfer_options
+        return {} unless (current['agent'] || 'direct').to_s.eql?(agent_type)
+        current.except('agent', 'asynchronous')
+      end
+
       # Lazy accessor - requires context.persistency (available in all Base sub-classes).
       # Delegate to the TransferAgent's store so that the in-memory agent-ref
       # registry is shared between the two components in the same process.

data/lib/aspera/cli/transfer_agent.rb

@@ -32,18 +32,24 @@ module Aspera
         <%=ts.to_yaml%>
       END_OF_TEMPLATE
       CP4I_REMOTE_HOST_LB = 'N/A'
+      # Transfer spec parameters overridden by option `ts`
+      TS_DEFAULTS = {
+        'create_dir'    => true,
+        'resume_policy' => 'sparse_csum'
+      }.freeze
       private_constant :FILE_LIST_FROM_TRANSFER_SPEC,
         :FILE_LIST_OPTIONS,
-        :DEFAULT_TRANSFER_NOTIFY_TEMPLATE
+        :DEFAULT_TRANSFER_NOTIFY_TEMPLATE,
+        :TS_DEFAULTS
 
       extend OptionDeclarator
 
-      option :ts,            description: 'Override transfer spec values', schema: Schema::Registry::TRANSFER_SPEC
+      option :ts,            description: 'Override transfer spec values', schema: Schema::Registry::TRANSFER_SPEC, on_set: :user_transfer_spec=
       option :to_folder,     description: 'Destination folder for transferred files'
       option :sources,       description: "How list of transferred files is provided (#{FILE_LIST_OPTIONS.join(',')})",               default: FILE_LIST_FROM_ARGS
       option :src_type,      description: 'Type of file list',                                                                        allowed: %i[list pair], default: :list
-      option :transfer,      description: 'Transfer agent type, or agent parameters with optional agent key',                         allowed: [Hash, String], schema: Schema::Registry::TRANSFER_AGENT_OPTIONS
-      option :transfer_info, description: 'Parameters for transfer agent',                                                            deprecation: 'use --transfer instead', schema: Schema::Registry::TRANSFER_AGENT_OPTIONS
+      option :transfer,      description: 'Transfer agent type, or agent parameters with optional agent key',                         allowed: [Hash, String], shorthand: 'agent', schema: Schema::Registry::TRANSFER_AGENT_OPTIONS
+      option :transfer_info, description: 'Parameters for transfer agent',                                                            deprecation: {last: '4.26.2', message: 'use --transfer instead'}, schema: Schema::Registry::TRANSFER_AGENT_OPTIONS
 
       # @param context [Context] Application context
       def initialize(context)
@@ -51,22 +57,15 @@ module Aspera
         Aspera.assert_type(context.options, Parser) { 'context.options' }
         @context = context
         # Command line can override transfer spec
-        @user_transfer_spec = {
-          'create_dir'    => true,
-          'resume_policy' => 'sparse_csum'
-        }
-        # options for transfer agent (agent type + agent-specific parameters)
-        @transfer_options = {}
+        @user_transfer_spec = TS_DEFAULTS.dup
         # the currently selected transfer agent
         @agent = nil
         # source/destination pair, like "paths" of transfer spec
         @transfer_paths = nil
         # HTTPGW URL provided by webapp
         @httpgw_url_lambda = nil
-        self.class.declare_options(@context.options)
-        @context.options.set_handler(:ts,            object: self, method: :user_transfer_spec)
-        @context.options.set_handler(:transfer,      object: self, method: :option_transfer)
-        @context.options.set_handler(:transfer_info, object: self, method: :transfer_options)
+        # Instance variables used by `on_set` callbacks are set above
+        self.class.declare_options(@context.options, target: self)
         @context.options.parse_options!
         @notification_cb = nil
         if !@context.options.get_option(:notify_to).nil?
@@ -80,22 +79,17 @@ module Aspera
         end
       end
 
-      attr_accessor :user_transfer_spec, :transfer_options
+      attr_reader :user_transfer_spec
 
-      # Composite option handler for :transfer
-      # String value: shorthand for agent type, stored as {'agent' => value}
-      # Hash value:   merged into @transfer_options (may include 'agent' key)
-      def option_transfer(_option_sym, operation, value = nil)
-        Aspera.assert_values(operation, %i[set get])
-        case operation
-        when :set
-          value = {'agent' => value} if value.is_a?(String)
-          Aspera.assert_type(value, Hash)
-          @transfer_options = @transfer_options.deep_merge(value)
-        when :get
-          return @transfer_options
-        end
-        nil
+      # `on_set` callback of option `ts`: values override defaults
+      # @param value [Hash] transfer spec parameters
+      def user_transfer_spec=(value)
+        @user_transfer_spec = TS_DEFAULTS.merge(value)
+      end
+
+      # @return [Hash] agent type (key `agent`) and agent parameters, from options `transfer` and deprecated `transfer_info`
+      def transfer_options
+        @context.options.get_option(:transfer_info).deep_merge(@context.options.get_option(:transfer))
       end
 
       def agent_instance=(instance)
@@ -106,10 +100,10 @@ module Aspera
       def agent_instance
         return @agent unless @agent.nil?
         # agent type: from composite option 'agent' key, default :direct
-        raw_type = @transfer_options['agent'] || :direct
+        raw_type = transfer_options['agent'] || :direct
         agent_type = Parser.get_from_list(raw_type.to_s, 'transfer agent', Agent::Factory::ALL.keys)
         # set keys as symbols, strip internal keys not forwarded to the agent constructor
-        agent_options = @transfer_options.except('agent', 'asynchronous').symbolize_keys
+        agent_options = transfer_options.except('agent', 'asynchronous').symbolize_keys
         agent_options[:progress] = @context.progress_bar
         agent_options[:config_dir] = @context.main_folder
         # special cases
@@ -121,8 +115,10 @@ module Aspera
             agent_options.merge!(@context.presets.by_name(param_set_name).symbolize_keys)
           end
         when :direct
-          # by default do not display ascp native progress bar
+          # By default, no native `ascp` progress bar
           agent_options[:quiet] = true unless agent_options.key?(:quiet)
+          # Native `ascp` progress bar requested: no other progress bar, unless option `progress_bar` is set
+          agent_options[:progress] = nil if !agent_options[:quiet] && @context.options.option_def(:progress_bar).source.eql?(:default)
           agent_options[:check_ignore_cb] = ->(host, port) { @context.http_config.ignore_cert?(host, port) }
           # JRuby
           agent_options[:trusted_certs] = @context.http_config.trusted_cert_locations unless agent_options.key?(:trusted_certs)
@@ -210,8 +206,8 @@ module Aspera
           when FILE_LIST_FROM_TRANSFER_SPEC
             Log.log.debug('assume list provided in transfer spec')
             special_case_direct_with_list =
-              (@transfer_options['agent'] || :direct).to_sym.eql?(:direct) &&
-              Transfer::Parameters.ascp_args_file_list?(@transfer_options['ascp_args'])
+              (transfer_options['agent'] || :direct).to_sym.eql?(:direct) &&
+              Transfer::Parameters.ascp_args_file_list?(transfer_options['ascp_args'])
             Aspera.assert(!@transfer_paths.nil? || special_case_direct_with_list, type: Cli::BadArgument) { 'transfer spec on command line must have sources' }
             # can be nil
             @transfer_paths
@@ -227,7 +223,7 @@ module Aspera
 
       # Start a transfer and wait for completion, plugins shall use this method
       # @param transfer_spec [Hash] transfer specification
-      # @param rest_token    [Rest, nil] if oauth token regeneration supported
+      # @param rest_token    [Rest::Client, nil] if oauth token regeneration supported
       def start(transfer_spec, rest_token: nil)
         # check parameters
         Aspera.assert_type(transfer_spec, Hash) { 'transfer_spec' }
@@ -264,13 +260,13 @@ module Aspera
         # create transfer agent
         agent_instance.start_transfer(transfer_spec, token_regenerator: rest_token)
         # --- async mode ---
-        if @transfer_options['asynchronous']
-          agent_type = (@transfer_options['agent'] || 'direct').to_s
+        if transfer_options['asynchronous']
+          agent_type = (transfer_options['agent'] || 'direct').to_s
           # In-process agents (direct, httpgw) expose last_job_id directly.
           # Remote-daemon agents do not override last_job_id (returns nil): generate a UUID.
           job_id = agent_instance.last_job_id || SecureRandom.uuid
           # Base agent_params from transfer options (strip internal keys)
-          agent_params = @transfer_options.except('agent', 'asynchronous')
+          agent_params = transfer_options.except('agent', 'asynchronous')
           # For daemon agents: capture any runtime-resolved connection detail
           case agent_type
           when 'desktop'

data/lib/aspera/cli/transfer_progress.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'monitor'
+require 'aspera/environment'
 require 'aspera/log'
 require 'aspera/assert'
 require 'ruby-progressbar'
@@ -7,95 +9,328 @@ require 'ruby-progressbar'
 module Aspera
   module Cli
     # Progress bar for transfers.
-    # Supports multi-session.
+    # Supports multi-session: events may come from several threads.
     # Note that we can have this case:
-    # 2 sessions (-C x:2), but one session fails and restarts...
+    # 2 sessions (-C x:2), but one session fails and restarts (resume): it restarts with the same session id.
+    # Errors are logged, never raised: the progress bar shall not fail a transfer.
     class TransferProgress
-      def initialize
-        @progress_bar = nil
-        # Key is session id
-        @sessions = {}
-        @completed = false
-        @title = nil
+      # Rate is computed on this sliding window
+      RATE_WINDOW_SEC = 5.0
+      # Rate is not displayed on a shorter period
+      RATE_MIN_SEC = 1.0
+      # Decimal units, like `ascp`
+      KILO = 1000
+      BITS_PER_MEGABIT = KILO * KILO
+      BYTE_UNITS = %w[B KB MB GB TB PB].freeze
+      private_constant :RATE_WINDOW_SEC, :RATE_MIN_SEC, :KILO, :BITS_PER_MEGABIT, :BYTE_UNITS
+
+      class << self
+        # @param bytes [Integer] Size in bytes
+        # @return [String] Size with decimal unit, e.g. `12.3 MB`
+        def format_bytes(bytes)
+          value = bytes.to_f
+          index = 0
+          while value >= KILO && index < BYTE_UNITS.length - 1
+            value /= KILO
+            index += 1
+          end
+          return "#{bytes} B" if index.zero?
+          format('%.1f %s', value, BYTE_UNITS[index])
+        end
+
+        # @param bytes_per_second [Float, nil] Rate, `nil` if unknown
+        # @return [String] Rate in megabits per second (decimal, like `ascp`)
+        def format_rate(bytes_per_second)
+          return '-- Mbps' if bytes_per_second.nil?
+          mbps = bytes_per_second * Environment::BITS_PER_BYTE / BITS_PER_MEGABIT
+          mbps < 10 ? format('%.2f Mbps', mbps) : format('%.0f Mbps', mbps)
+        end
+
+        # @param seconds [Numeric, nil] Duration, `nil` if unknown
+        # @return [String] Duration as `hh:mm:ss`
+        def format_duration(seconds)
+          return '--:--:--' if seconds.nil?
+          seconds = seconds.round
+          format('%02d:%02d:%02d', seconds / 3600, (seconds / 60) % 60, seconds % 60)
+        end
+      end
+
+      # @param output [IO] Where the progress bar is displayed: not on `$stdout`, which may be redirected for command output
+      def initialize(output: $stderr)
+        @output = output
+        # Re-entrant, see `suspend`
+        @mutex = Monitor.new
+        reset_state
       end
 
       # Reset progress bar, to re-use it.
       def reset
-        send(:initialize)
+        @mutex.synchronize { reset_state }
       end
 
-      # Called by user of progress bar with a status on a transfer session
-      # @param session_id [String] the unique identifier of a transfer session
-      # @param type [Symbol] one of: sessions_init, session_start, session_size, transfer, session_end and end
-      # @param info [Object, nil] optional specific additional info for the given event type
+      # Called by user of progress bar with a status on a transfer session.
+      # Event types:
+      # - `sessions_init` : `info` is a status message, displayed until a session starts
+      # - `session_start` : a session starts, or restarts (same `session_id`)
+      # - `session_size`  : `info` is the total size of the session
+      # - `transfer`      : `info` is the number of bytes transferred by the session
+      # - `skip`          : `info` is the number of bytes of the session already at destination (not transferred)
+      # - `session_end`   : a session ends
+      # - `end`           : all sessions are finished, `info` is `false` if the transfer failed
+      # @param type       [Symbol]      Event type
+      # @param session_id [String, nil] Unique identifier of a transfer session, same when the session is restarted
+      # @param info       [Object, nil] Optional specific additional info for the given event type
       def event(type, session_id: nil, info: nil)
         Log.log.trace1 { "progress: #{type} #{session_id} #{info}" }
-        return if @completed
-        if @progress_bar.nil?
-          @progress_bar = ProgressBar.create(
-            format:      '%t %a %B %p%% %r Mbps %E',
-            rate_scale:  lambda { |rate| rate / Environment::BYTES_PER_MEBIBIT },
-            title:       '',
-            total:       nil
-          )
+        @mutex.synchronize { process_event(type, session_id, info) }
+      rescue StandardError => e
+        Log.log.warn { "Progress bar: #{e.class}: #{e.message}" } unless @error_logged
+        @error_logged = true
+      end
+
+      # Execute the block with the progress bar cleared, and then display it again.
+      # Used to write log lines on the terminal.
+      # Does not wait if the progress bar is being updated by another thread (no deadlock with a logger lock).
+      def suspend
+        return yield unless @mutex.try_enter
+        begin
+          return yield if @progress_bar.nil? || !@output.tty?
+          @progress_bar.clear
+          @output.flush
+          begin
+            yield
+          ensure
+            @progress_bar.refresh(force: true)
+          end
+        ensure
+          @mutex.exit
         end
-        progress_provided = false
+      end
+
+      private
+
+      def reset_state
+        @progress_bar = nil
+        # Key is session id
+        @sessions = {}
+        # Status displayed before session start
+        @title = nil
+        # Format currently set on the progress bar
+        @format = nil
+        # [Integer] Bytes actually transferred, by all sessions, including previous runs of restarted sessions
+        @transferred = 0
+        # [Array<Array(Float, Integer)>] (time, transferred bytes) on the rate window
+        @samples = []
+        # [Array(Float, Integer), nil] First sample (data starts to flow, not session start), for average rate
+        @start = nil
+        @error_logged = false
+      end
+
+      # @param type       [Symbol]      Event type
+      # @param session_id [String, nil] Session identifier
+      # @param info       [Object, nil] Event information
+      def process_event(type, session_id, info)
         case type
         when :sessions_init
           # Give opportunity to show progress of initialization with multiple status
           Aspera.assert(session_id.nil?, 'session_id must be nil for :sessions_init event')
           Aspera.assert_type(info, String)
-          # Initialization of progress bar
           @title = info
         when :session_start
-          Aspera.assert_type(session_id, String)
           Aspera.assert(info.nil?, 'info must be nil for :session_start event')
-          Aspera.assert(!@sessions[session_id]) { "Session #{session_id} already started" }
-          @sessions[session_id] = {
-            job_size: 0, # Total size of transfer (pre-calc)
-            current:  0,
-            running:  true
-          }
+          start_session(session_id)
           # Remove last pre-start message if any
           @title = nil
         when :session_size
-          Aspera.assert_type(session_id, String)
-          Aspera.assert(!info.nil?, 'info must not be nil for :session_size event')
-          Aspera.assert_type(@sessions[session_id], Hash)
-          @sessions[session_id][:job_size] = info.to_i
-          sessions_total = total(:job_size)
-          @progress_bar.total = sessions_total unless sessions_total.eql?(@progress_bar.total) || sessions_total < @progress_bar.progress
+          session(session_id)[:size] = info.to_i unless info.nil?
         when :transfer
-          Aspera.assert_type(session_id, String)
-          Aspera.assert_type(@sessions[session_id], Hash)
-          if !@progress_bar.total.nil? && !info.nil?
-            progress_provided = true
-            @sessions[session_id][:current] = info.to_i
-            sessions_current = total(:current)
-            @progress_bar.progress = sessions_current unless @progress_bar.progress.eql?(sessions_current) || sessions_current > total(:job_size)
+          unless info.nil?
+            current_session = session(session_id)
+            transferred = info.to_i
+            @transferred += transferred - current_session[:transferred] if transferred > current_session[:transferred]
+            current_session[:transferred] = transferred
+            add_sample
           end
+        when :skip
+          session(session_id)[:skipped] = info.to_i unless info.nil?
         when :session_end
-          Aspera.assert_type(session_id, String)
           Aspera.assert(info.nil?, 'info must be nil for :session_end event')
           # A session may be too short and finish before it has been started
-          @sessions[session_id][:running] = false if @sessions[session_id].is_a?(Hash)
+          @sessions[session_id][:running] = false if @sessions.key?(session_id)
         when :end
           Aspera.assert(session_id.nil?, 'session_id must be nil for :end event')
-          Aspera.assert(info.nil?, 'info must be nil for :end event')
-          @progress_bar.finish
+          Aspera.assert_values(info, [nil, true, false]) { ':end event info' }
+          begin
+            finish(success: !info.eql?(false))
+          ensure
+            reset_state
+          end
+          return
         else Aspera.error_unexpected_value(type) { 'event type' }
         end
-        new_title = @sessions.length < 2 ? @title.to_s : "[#{@sessions.count { |_i, d| d[:running] }}] #{@title}"
-        @progress_bar&.title = new_title unless @progress_bar&.title.eql?(new_title)
-        @progress_bar&.increment if !progress_provided && @progress_bar.progress.nil?
-      rescue ProgressBar::InvalidProgressError => e
-        Log.log.error { "Progress error: #{e}" }
+        display
       end
 
-      private
+      # @param session_id [String] Session identifier
+      # @return [Hash] Session information, created if not already started
+      def session(session_id)
+        Aspera.assert_type(session_id, String)
+        @sessions[session_id] ||= {
+          size:        nil, # Total size of session, `nil` if unknown
+          transferred: 0,   # Bytes transferred
+          skipped:     0,   # Bytes already at destination
+          floor:       0,   # Progress reached before restart of session
+          running:     true
+        }
+      end
+
+      # Start a session, or restart it: a restarted session notifies again its progress from zero
+      # @param session_id [String] Session identifier
+      def start_session(session_id)
+        restarted = @sessions.key?(session_id)
+        current_session = session(session_id)
+        if restarted
+          current_session[:floor] = done_bytes(current_session)
+          current_session[:transferred] = 0
+          current_session[:skipped] = 0
+        end
+        current_session[:running] = true
+      end
+
+      # @param session [Hash] Session information
+      # @return [Integer] Bytes processed by the session (transferred or skipped), not more than its size
+      def done_bytes(session)
+        done = [session[:floor], session[:transferred] + session[:skipped]].max
+        session[:size].nil? ? done : [done, session[:size]].min
+      end
+
+      # @return [Integer] Bytes processed by all sessions
+      def current_bytes
+        @sessions.each_value.sum { |s| done_bytes(s) }
+      end
+
+      # @return [Integer, nil] Total size of all sessions, `nil` if unknown for one of them
+      def total_bytes
+        return if @sessions.empty? || @sessions.each_value.any? { |s| s[:size].nil? }
+        @sessions.each_value.sum { |s| s[:size] }
+      end
+
+      # @return [Float] Monotonic time in seconds
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      # Record transferred bytes for rate computation
+      # @return [Array(Float, Integer)] The new sample
+      def add_sample
+        sample = [now, @transferred]
+        @start ||= sample
+        @samples.push(sample)
+        # Keep one sample older than the window
+        @samples.shift while @samples.length > 2 && @samples[1].first <= sample.first - RATE_WINDOW_SEC
+        sample
+      end
+
+      # @return [Float, nil] Rate on the sliding window, in bytes per second, `nil` if unknown
+      def rate
+        return if @samples.length < 2
+        elapsed = @samples.last.first - @samples.first.first
+        return if elapsed < RATE_MIN_SEC
+        (@samples.last.last - @samples.first.last) / elapsed
+      end
+
+      # @return [Float, nil] Average rate between first and last sample, in bytes per second, `nil` if unknown
+      def average_rate
+        return if @start.nil?
+        last = @samples.last
+        elapsed = last.first - @start.first
+        return unless elapsed.positive?
+        (last.last - @start.last) / elapsed
+      end
+
+      # Update the progress bar with current state
+      def display
+        if @progress_bar.nil?
+          @progress_bar = ProgressBar.create(output: @output, format: '%a %B', total: nil, autofinish: false, throttle_rate: 0)
+          @format = '%a %B'
+        end
+        current = current_bytes
+        total = total_bytes
+        update_bar(total, current)
+        fields = ['%a', '%B']
+        unless @sessions.empty?
+          bytes_per_second = rate
+          # Fixed width, so that bar does not change size
+          rate_text = self.class.format_rate(bytes_per_second).rjust(11)
+          if total.nil?
+            fields.push(self.class.format_bytes(current).rjust(8), rate_text)
+          else
+            eta = bytes_per_second&.positive? ? (total - current) / bytes_per_second : nil
+            fields.push('%j%%', rate_text, "ETA: #{self.class.format_duration(eta)}")
+          end
+        end
+        update_format(title_text(final: false), fields)
+      end
+
+      # Display final state of the progress bar
+      # @param success [Boolean] `false` if the transfer failed: progress is not completed
+      def finish(success:)
+        return if @progress_bar.nil?
+        current = current_bytes
+        total = total_bytes
+        if success
+          total ||= current
+          current = total
+        end
+        fields = ['%a']
+        unless total.nil?
+          update_bar(total, current)
+          fields.push('%B', '%j%%')
+        end
+        fields.push(self.class.format_bytes(current), self.class.format_rate(average_rate)) unless @sessions.empty?
+        # Last status (e.g. `running`) is no more relevant
+        @title = success ? nil : 'failed'
+        # Final line may be shorter (no bar)
+        @progress_bar.clear
+        update_format(title_text(final: true), fields)
+        success ? @progress_bar.finish : @progress_bar.stop
+      end
+
+      # Set total and progress of the bar, in an order accepted by `ruby-progressbar`
+      # @param total   [Integer, nil] Total size, `nil` if unknown
+      # @param current [Integer]      Processed bytes
+      def update_bar(total, current)
+        if total.nil?
+          # Unknown total: progress of the bar is used for animation only
+          @progress_bar.total = nil unless @progress_bar.total.nil?
+          @progress_bar.increment
+        elsif total >= @progress_bar.progress
+          @progress_bar.total = total unless @progress_bar.total.eql?(total)
+          @progress_bar.progress = current unless @progress_bar.progress.eql?(current)
+        else
+          @progress_bar.progress = current
+          @progress_bar.total = total
+        end
+      end
+
+      # @param final [Boolean] `true` for the final display
+      # @return [String] Title of the progress bar, with number of running sessions if several sessions
+      def title_text(final:)
+        parts = []
+        running = @sessions.count { |_, s| s[:running] }
+        parts.push("[#{running}]") if !final && running.positive? && @sessions.length > 1
+        parts.push(@title) unless @title.to_s.empty?
+        parts.join(' ')
+      end
 
-      def total(key)
-        @sessions.values.inject(0) { |m, s| m + s[key] }
+      # Change format of the bar, if changed
+      # @param title  [String]        Literal text
+      # @param fields [Array<String>] `ruby-progressbar` format elements
+      def update_format(title, fields)
+        new_format = (title.empty? ? fields : [title.gsub('%', '%%'), *fields]).join(' ')
+        return if new_format.eql?(@format)
+        @progress_bar.format = new_format
+        @format = new_format
       end
     end
   end

data/lib/aspera/cli/vault_manager.rb

@@ -10,17 +10,6 @@ module Aspera
     # Mixin providing vault/keychain functionality to Plugin::Config.
     # Depends on `options` and `context.main_folder` being available in the including class.
     module VaultManager
-      def action_vault_show(label:, id: nil, **)
-        v = vault_required
-        kwargs = id && v.method(:get).parameters.any? { |_t, n| n == :id } ? {id: id} : {}
-        Result::SingleObject.new(v.get(label: label, **kwargs))
-      end
-
-      def action_vault_create(info:, **)
-        vault_required.set(info.symbolize_keys)
-        Result::Status.new('Secret added')
-      end
-
       # Import secrets from a JSON array; skips entries missing :label
       def action_vault_import(secrets:, **)
         bulk_result(secrets, command: :import, id_result: 'label') do |entry|
@@ -36,12 +25,6 @@ module Aspera
         Result::Status.new("Secret deleted: #{label}")
       end
 
-      def action_vault_password(new_password:, **)
-        Aspera.assert(vault_required.respond_to?(:change_password), 'Vault does not support password change')
-        vault_required.change_password(new_password)
-        Result::Status.new('Vault password updated')
-      end
-
       # @return [Keychain::Base] vault instance, raises if not configured
       def vault_required
         Aspera.assert(!vault.nil?, type: Cli::BadArgument) { 'Missing mandatory option: vault' }

data/lib/aspera/cli/version.rb

@@ -4,6 +4,6 @@ module Aspera
   module Cli
     # For beta add extension : .beta1
     # For dev version add extension : .pre
-    VERSION = '4.27.2'
+    VERSION = '4.27.4'
   end
 end