aspera-cli 4.18.1 → 4.20.0

data/lib/aspera/cli/plugins/orchestrator.rb

@@ -22,7 +22,7 @@ module Aspera
               next unless base_url.match?('https?://')
               api = Rest.new(base_url: base_url)
               test_endpoint = 'api/remote_node_ping'
-              result = api.read(test_endpoint, {format: :json})
+              result = api.call(operation: 'GET', subpath: test_endpoint, headers: {'Accept' => 'application/json'}, query: {format: :json})
               next unless result[:data]['remote_orchestrator_info']
               url = result[:http].uri.to_s
               return {
@@ -69,7 +69,7 @@ module Aspera
         # @param format [String] the format to request, 'json', 'xml', nil
         # @param args [Hash] the arguments to pass
         # @param xml_arrays [Boolean] if true, force arrays in xml parsing
-        def call_ao(endpoint, prefix: 'api', id: nil, ret_style: nil, format: 'json', args: nil, xml_arrays: true)
+        def call_ao(endpoint, prefix: 'api', id: nil, ret_style: nil, format: 'json', args: nil, xml_arrays: true, http: false)
           # calls are GET
           call_args = {operation: 'GET', subpath: endpoint}
           # specify prefix if necessary
@@ -91,9 +91,10 @@ module Aspera
             end
           end
           result = @api_orch.call(**call_args)
+          return result[:http] if http
           result[:data] = XmlSimple.xml_in(result[:http].body, {'ForceArray' => xml_arrays}) if format.eql?('xml')
           Log.log.debug{Log.dump(:data, result[:data])}
-          return result
+          return result[:data]
         end
 
         def execute_action
@@ -126,7 +127,7 @@ module Aspera
           when :health
             nagios = Nagios.new
             begin
-              info = call_ao('remote_node_ping', format: 'xml', xml_arrays: false)[:data]
+              info = call_ao('remote_node_ping', format: 'xml', xml_arrays: false)
               nagios.add_ok('api', 'accessible')
               nagios.check_product_version('api', 'orchestrator', info['orchestrator-version'])
             rescue StandardError => e
@@ -134,15 +135,15 @@ module Aspera
             end
             return nagios.result
           when :info
-            result = call_ao('remote_node_ping', format: 'xml', xml_arrays: false)[:data]
+            result = call_ao('remote_node_ping', format: 'xml', xml_arrays: false)
             return {type: :single_object, data: result}
           when :processes
             # TODO: Bug ? API has only XML format
-            result = call_ao('processes_status', format: 'xml')[:data]
+            result = call_ao('processes_status', format: 'xml')
             return {type: :object_list, data: result['process']}
           when :plugins
             # TODO: Bug ? only json format on url
-            result = call_ao('plugin_version')[:data]
+            result = call_ao('plugin_version')
             return {type: :object_list, data: result['Plugin']}
           when :workflow
             command = options.get_next_command(%i[list status inputs details start export])
@@ -152,23 +153,23 @@ module Aspera
             case command
             when :status
               wf_id = nil if wf_id.eql?(SpecialValues::ALL)
-              result = call_ao('workflows_status', id: wf_id)[:data]
+              result = call_ao('workflows_status', id: wf_id)
               return {type: :object_list, data: result['workflows']['workflow']}
             when :list
-              result = call_ao('workflows_list', id: 0)[:data]
+              result = call_ao('workflows_list', id: 0)
               return {
                 type:   :object_list,
                 data:   result['workflows']['workflow'],
                 fields: %w[id portable_id name published_status published_revision_id latest_revision_id last_modification]
               }
             when :details
-              result = call_ao('workflow_details', id: wf_id)[:data]
+              result = call_ao('workflow_details', id: wf_id)
               return {type: :object_list, data: result['workflows']['workflow']['statuses']}
             when :inputs
-              result = call_ao('workflow_inputs_spec', id: wf_id)[:data]
+              result = call_ao('workflow_inputs_spec', id: wf_id)
               return {type: :single_object, data: result['workflow_inputs_spec']}
             when :export
-              result = call_ao('export_workflow', id: wf_id, format: nil)[:http]
+              result = call_ao('export_workflow', id: wf_id, format: nil, http: true)
               return {type: :text, data: result.body}
             when :start
               result = {
@@ -196,7 +197,7 @@ module Aspera
               if call_params['synchronous']
                 result[:type] = :text
               end
-              result[:data] = call_ao('initiate', id: wf_id, args: call_params)[:data]
+              result[:data] = call_ao('initiate', id: wf_id, args: call_params)
               return result
             end
           else Aspera.error_unexpected_value(command)

data/lib/aspera/cli/plugins/preview.rb

@@ -133,7 +133,6 @@ module Aspera
             subpath:   "files/#{file_id}/files",
             headers:   headers,
             query:     request_args)[:data]
-          # return @api_node.read("files/#{file_id}/files",request_args)[:data]
         end
 
         # old version based on folders
@@ -146,7 +145,7 @@ module Aspera
           # optionally add iteration token from persistency
           events_filter['iteration_token'] = iteration_persistency.data.first unless iteration_persistency.nil?
           begin
-            events = @api_node.read('events', events_filter)[:data]
+            events = @api_node.read('events', events_filter)
           rescue RestCallError => e
             if e.message.include?('Invalid iteration_token')
               Log.log.warn{"Retrying without iteration token: #{e}"}
@@ -164,7 +163,7 @@ module Aspera
               folder_id = event.dig('data', 'tags', Transfer::Spec::TAG_RESERVED, 'node', 'file_id')
               folder_id ||= event.dig('data', 'file_id')
               if !folder_id.nil?
-                folder_entry = @api_node.read("files/#{folder_id}")[:data] rescue nil
+                folder_entry = @api_node.read("files/#{folder_id}") rescue nil
                 scan_folder_files(folder_entry) unless folder_entry.nil?
               end
             end
@@ -188,12 +187,12 @@ module Aspera
           }
           # optionally add iteration token from persistency
           events_filter['iteration_token'] = iteration_persistency.data.first unless iteration_persistency.nil?
-          events = @api_node.read('events', events_filter)[:data]
+          events = @api_node.read('events', events_filter)
           return if events.empty?
           events.each do |event|
             # process only files
             if event.dig('data', 'type').eql?('file')
-              file_entry = @api_node.read("files/#{event['data']['id']}")[:data] rescue nil
+              file_entry = @api_node.read("files/#{event['data']['id']}") rescue nil
               if !file_entry.nil? &&
                   @option_skip_folders.none?{|d|file_entry['path'].start_with?(d)}
                 file_entry['parent_file_id'] = event['data']['parent_file_id']
@@ -248,7 +247,7 @@ module Aspera
           # original_mtime=DateTime.parse(entry['modified_time'])
           # out: where previews are generated
           local_entry_preview_dir = File.join(@tmp_folder, entry_preview_folder_name(entry))
-          file_info = @api_node.read("files/#{entry['id']}")[:data]
+          file_info = @api_node.read("files/#{entry['id']}")
           # TODO: this does not work because previews is hidden in api (gen4)
           # this_preview_folder_entries=get_folder_entries(@previews_folder_entry['id'],{name: @entry_preview_folder_name})
           # TODO: use gen3 api to list files and get date
@@ -410,10 +409,10 @@ module Aspera
             @api_node = Api::Node.new(**basic_auth_params)
             @transfer_server_address = URI.parse(@api_node.base_url).host
             # get current access key
-            @access_key_self = @api_node.read('access_keys/self')[:data]
+            @access_key_self = @api_node.read('access_keys/self')
             # TODO: check events is activated here:
             # note that docroot is good to look at as well
-            node_info = @api_node.read('info')[:data]
+            node_info = @api_node.read('info')
             Log.log.debug{"root: #{node_info['docroot']}"}
             @access_remote = @option_file_access.eql?(:remote)
             Log.log.debug{"remote: #{@access_remote}"}
@@ -463,7 +462,7 @@ module Aspera
                   'type' => 'folder',
                   'path' => '/' }
               else
-                @api_node.read("files/#{scan_id}")[:data]
+                @api_node.read("files/#{scan_id}")
               end
             @filter_block = Api::Node.file_matcher_from_argument(options)
             scan_folder_files(folder_info, scan_path)

data/lib/aspera/cli/plugins/server.rb

@@ -9,6 +9,7 @@ require 'aspera/ssh'
 require 'aspera/nagios'
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/environment'
 require 'tempfile'
 require 'open3'
 
@@ -32,14 +33,8 @@ module Aspera
         private_constant :SSH_SCHEME, :URI_SCHEMES, :ASCMD_ALIASES, :TRANSFER_COMMANDS
 
         class LocalExecutor
-          def execute(cmd, line)
-            # concatenate arguments, enclose in double quotes
-            cmd = cmd.map{|v|%Q("#{v}")}.join(' ') if cmd.is_a?(Array)
-            Log.log.debug{"Executing: #{cmd} with '#{line}'"}
-            stdout_str, stderr_str, status = Open3.capture3(cmd, stdin_data: line, binmode: true)
-            Log.log.debug{"exec status: #{status} -> #{stderr_str}"}
-            raise "command #{cmd} failed with code #{status.exitstatus} #{stderr_str}" unless status.success?
-            return stdout_str
+          def execute(ascmd_path, line)
+            return Environment.secure_capture(exec: ascmd_path, stdin_data: line, binmode: true)
           end
         end
 
@@ -157,7 +152,8 @@ module Aspera
             Log.log.debug{"SSH keys=#{ssh_key_list}"}
             if !ssh_key_list.empty?
               @ssh_opts[:keys] = ssh_key_list
-              server_transfer_spec['ssh_private_key'] = File.read(ssh_key_list.first)
+              # PEM as per RFC 7468
+              server_transfer_spec['ssh_private_key'] = File.read(ssh_key_list.first).strip
               Log.log.warn{'Using only first SSH key for transfers'} unless ssh_key_list.length.eql?(1)
               cred_set = true
             end
@@ -176,7 +172,7 @@ module Aspera
         def execute_transfer(command, transfer_spec)
           case command
           when :upload, :download
-            Transfer::Spec.action_to_direction(transfer_spec, command)
+            transfer_spec['direction'] = Transfer::Spec.transfer_type_to_direction(command)
             return Main.result_transfer(transfer.start(transfer_spec))
           when :sync
             # lets ignore the arguments provided by execute_sync_action, we just give the transfer spec

data/lib/aspera/cli/plugins/shares.rb

@@ -7,7 +7,10 @@ module Aspera
     module Plugins
       # Plugin for Aspera Shares v1
       class Shares < Cli::BasicAuthPlugin
-        NODE_API_PREFIX = 'node_api'
+        # path for node API after base url
+        NODE_API_PATH = 'node_api'
+        # path for node admin after base url
+        ADMIN_API_PATH = 'api/v1'
         class << self
           def detect(address_or_url)
             address_or_url = "https://#{address_or_url}" unless address_or_url.match?(%r{^[a-z]{1,6}://})
@@ -16,7 +19,7 @@ module Aspera
             begin
               # shall fail: shares requires auth, but we check error message
               # TODO: use ping instead ?
-              api.read("#{NODE_API_PREFIX}/app")
+              api.read("#{NODE_API_PATH}/app")
             rescue RestCallError => e
               if e.response.code.to_s.eql?('401') && e.response.body.eql?('{"error":{"user_message":"API user authentication failed"}}')
                 found = true
@@ -65,7 +68,7 @@ module Aspera
             nagios = Nagios.new
             begin
               res = Rest
-                .new(base_url: "#{options.get_option(:url, mandatory: true)}/#{NODE_API_PREFIX}")
+                .new(base_url: "#{options.get_option(:url, mandatory: true)}/#{NODE_API_PATH}")
                 .call(
                   operation: 'GET',
                   subpath: 'ping',
@@ -77,13 +80,13 @@ module Aspera
             end
             return nagios.result
           when :repository, :files
-            api_shares_node = basic_auth_api(NODE_API_PREFIX)
+            api_shares_node = basic_auth_api(NODE_API_PATH)
             repo_command = options.get_next_command(Node::COMMANDS_SHARES)
             return Node
                 .new(**init_params, api: api_shares_node)
                 .execute_action(repo_command)
           when :admin
-            api_shares_admin = basic_auth_api('api/v1')
+            api_shares_admin = basic_auth_api(ADMIN_API_PATH)
             admin_command = options.get_next_command(%i[node share transfer_settings user group].freeze)
             case admin_command
             when :node
@@ -92,8 +95,9 @@ module Aspera
               share_command = options.get_next_command(%i[user_permissions group_permissions].concat(Plugin::ALL_OPS))
               case share_command
               when *Plugin::ALL_OPS
-                return entity_command(share_command, api_shares_admin, 'data/shares')
-                # return {type: :object_list, data: all_shares, fields: %w[id name status status_message]}
+                return entity_command(
+                  share_command, api_shares_admin, 'data/shares',
+                  display_fields: %w[id name node_id directory percent_free])
               when :user_permissions, :group_permissions
                 share_id = instance_identifier
                 return entity_action(api_shares_admin, "data/shares/#{share_id}/#{share_command}")
@@ -140,11 +144,11 @@ module Aspera
                   entity_parameters.each_key do |p|
                     raise "unsupported field: #{p}, use: #{SAML_IMPORT_ALLOWED.join(',')}" unless SAML_IMPORT_ALLOWED.include?(p)
                   end
-                  api_shares_admin.create("#{entities_path}/import", entity_parameters)[:data]
+                  api_shares_admin.create("#{entities_path}/import", entity_parameters)
                 end
               when :add # ldap
                 return do_bulk_operation(command: entity_verb, descr: "#{entity_type} name", values: String) do |entity_name|
-                  api_shares_admin.create(entities_path, {entity_type=>entity_name})[:data]
+                  api_shares_admin.create(entities_path, {entity_type=>entity_name})
                 end
               when :users # group
                 return entity_action(api_shares_admin, "#{entities_path}/#{instance_identifier}/#{entities_prefix}users")

data/lib/aspera/cli/sync_actions.rb

@@ -7,11 +7,30 @@ module Aspera
   module Cli
     # Module for sync actions
     module SyncActions
-      SIMPLE_ARGUMENTS_SYNC = {
-        direction:  Transfer::Sync::DIRECTIONS,
-        local_dir:  String,
-        remote_dir: String
-      }.stringify_keys.freeze
+      # optional simple command line arguments for sync
+      # in Array to keep option order
+      # conf: key in option --conf
+      # args: key for command line args
+      # values: possible values for argument
+      # type: type for validation
+      SYNC_ARGUMENTS_INFO = [
+        {
+          conf:   'direction',
+          args:   'direction',
+          values: Transfer::Sync::DIRECTIONS
+        }, {
+          conf: 'remote.path',
+          args: 'remote_dir',
+          type: String
+        }, {
+          conf: 'local.path',
+          args: 'local_dir',
+          type: String
+        }
+      ].freeze
+      # name of minimal arguments required, also used to generate a session name
+      SYNC_SIMPLE_ARGS = SYNC_ARGUMENTS_INFO.map{|i|i[:conf]}.freeze
+      private_constant :SYNC_ARGUMENTS_INFO, :SYNC_SIMPLE_ARGS
 
       class << self
         def declare_options(options)
@@ -19,38 +38,60 @@ module Aspera
         end
       end
 
+      # Read command line arguments (3) and converts to sync_info format
+      def sync_args_to_params(async_params)
+        # sync session parameters can be provided on command line instead of sync_info
+        arguments = {}
+        SYNC_ARGUMENTS_INFO.each do |info|
+          value = options.get_next_argument(
+            info[:conf],
+            mandatory: false,
+            validation: info[:type],
+            accept_list: info[:values])
+          break if value.nil?
+          arguments[info[:conf]] = value.to_s
+        end
+        Log.log.debug{Log.dump('arguments', arguments)}
+        raise Cli::BadArgument, "Provide 0 or 3 arguments, not #{arguments.keys.length} for: #{SYNC_SIMPLE_ARGS.join(', ')}" unless
+          [0, 3].include?(arguments.keys.length)
+        if !arguments.empty?
+          session_info = async_params
+          param_path = :conf
+          if async_params.key?('sessions') || async_params.key?('instance')
+            async_params['sessions'] ||= [{}]
+            Aspera.assert(async_params['sessions'].length == 1){'Only one session is supported with arguments'}
+            session_info = async_params['sessions'][0]
+            param_path = :args
+          end
+          SYNC_ARGUMENTS_INFO.each do |info|
+            key_path = info[param_path].split('.')
+            hash_for_key = session_info
+            if key_path.length > 1
+              first = key_path.shift
+              async_params[first] ||= {}
+              hash_for_key = async_params[first]
+            end
+            raise "Parameter #{info[:conf]} is also set in sync_info, remove from sync_info" if hash_for_key.key?(key_path.last)
+            hash_for_key[key_path.last] = arguments[info[:conf]]
+          end
+          if !session_info.key?('name')
+            # if no name is specified, generate one from simple arguments
+            session_info['name'] = SYNC_SIMPLE_ARGS.filter_map do |arg_name|
+              arguments[arg_name]&.gsub(/[^a-zA-Z0-9]/, '')
+            end.reject(&:empty?).join('_')
+          end
+        end
+      end
+
       def execute_sync_action(&block)
         Aspera.assert(block){'No block given'}
         command = options.get_next_command(%i[start admin])
         # try to get 3 arguments as simple arguments
         case command
         when :start
-          simple_session_args = {}
-          SIMPLE_ARGUMENTS_SYNC.each do |arg, check|
-            value = options.get_next_argument(
-              arg,
-              mandatory: false,
-              validation: check.is_a?(Class) ? check : nil,
-              accept_list: check.is_a?(Class) ? nil : check)
-            break if value.nil?
-            simple_session_args[arg] = value.to_s
-          end
-          async_params = nil
-          if simple_session_args.empty?
-            async_params = options.get_option(:sync_info, mandatory: true)
-          else
-            raise Cli::BadArgument,
-              "Provide zero or 3 arguments: #{SIMPLE_ARGUMENTS_SYNC.keys.join(',')}" unless simple_session_args.keys.sort == SIMPLE_ARGUMENTS_SYNC.keys.sort
-            async_params = options.get_option(
-              :sync_info,
-              mandatory: false,
-              default: {'sessions' => [{'name' => File.basename(simple_session_args['local_dir'])}]})
-            Aspera.assert_type(async_params, Hash){'sync_info'}
-            Aspera.assert_type(async_params['sessions'], Array){'sync_info[sessions]'}
-            Aspera.assert_type(async_params['sessions'].first, Hash){'sync_info[sessions][0]'}
-            async_params['sessions'].first.merge!(simple_session_args)
-          end
-          Log.log.debug{Log.dump('async_params', async_params)}
+          # possibilities are:
+          async_params = options.get_option(:sync_info, default: {})
+          sync_args_to_params(async_params)
           Transfer::Sync.start(async_params, &block)
           return Main.result_success
         when :admin

data/lib/aspera/cli/transfer_agent.rb

@@ -22,7 +22,7 @@ module Aspera
         To: <<%=to%>>
         Subject: <%=subject%>
 
-        Transfer is: <%=global_transfer_status%>
+        Transfer is: <%=status%>
 
         <%=ts.to_yaml%>
       END_OF_TEMPLATE
@@ -65,6 +65,16 @@ module Aspera
         @opt_mgr.declare(:transfer, 'Type of transfer agent', values: TRANSFER_AGENTS, default: :direct)
         @opt_mgr.declare(:transfer_info, 'Parameters for transfer agent', types: Hash, handler: {o: self, m: :transfer_info})
         @opt_mgr.parse_options!
+        @notification_cb = nil
+        if !@opt_mgr.get_option(:notify_to).nil?
+          @notification_cb = ->(transfer_spec, global_status) do
+            @config.send_email_template(email_template_default: DEFAULT_TRANSFER_NOTIFY_TEMPLATE, values: {
+              subject: "#{Info::CMD_NAME} transfer: #{global_status}",
+              status:  global_status,
+              ts:      transfer_spec
+            })
+          end
+        end
       end
 
       def option_transfer_spec; @transfer_spec_command_line; end
@@ -116,6 +126,7 @@ module Aspera
           # by default do not display ascp native progress bar
           agent_options[:quiet] = true unless agent_options.key?(:quiet)
           agent_options[:check_ignore_cb] = ->(host, port){@config.ignore_cert?(host, port)}
+          # JRuby
           agent_options[:trusted_certs] = @config.trusted_cert_locations unless agent_options.key?(:trusted_certs)
         when :httpgw
           unless agent_options.key?(:url) || @httpgw_url_lambda.nil?
@@ -250,22 +261,10 @@ module Aspera
         agent_instance.start_transfer(transfer_spec, token_regenerator: rest_token)
         # list of: :success or "error message string"
         result = agent_instance.wait_for_completion
-        send_email_transfer_notification(transfer_spec, result)
+        @notification_cb&.call(transfer_spec, self.class.session_status(result))
         return result
       end
 
-      def send_email_transfer_notification(transfer_spec, statuses)
-        return if @opt_mgr.get_option(:notify_to).nil?
-        global_status = self.class.session_status(statuses)
-        email_vars = {
-          global_transfer_status: global_status,
-          subject:                "#{PROGRAM_NAME} transfer: #{global_status}",
-          body:                   "Transfer is: #{global_status}",
-          ts:                     transfer_spec
-        }
-        @config.send_email_template(email_template_default: DEFAULT_TRANSFER_NOTIFY_TEMPLATE, values: email_vars)
-      end
-
       # shut down if agent requires it
       def shutdown
         @agent.shutdown if @agent.respond_to?(:shutdown)

data/lib/aspera/cli/transfer_progress.rb

@@ -6,27 +6,28 @@ require 'ruby-progressbar'
 
 module Aspera
   module Cli
-    # progress bar for transfers, supports multi-session
+    # Progress bar for transfers.
+    # Supports multi-session.
     class TransferProgress
       def initialize
         reset
       end
 
+      # Reset progress bar, to re-use it.
       def reset
         @progress_bar = nil
         # key is session id
         @sessions = {}
         @completed = false
-        @title = ''
+        @title = nil
       end
 
-      def total(key)
-        @sessions.values.inject(0){|m, s|m + s[key]}
-      end
-
-      def event(session_id:, type:, info: nil)
-        Log.log.debug{"progress: #{type} #{session_id} #{info}"}
-        Aspera.assert(!session_id.nil? || type.eql?(:pre_start)){'session_id is nil'}
+      # Called by user of progress bar with a status on a transfer session
+      # @param session_id the unique identifier of a transfer session
+      # @param type one of: pre_start, session_start, session_size, transfer, end
+      # @param info optional specific additional info for the given event type
+      def event(type, session_id:, info: nil)
+        Log.log.trace1{"progress: #{type} #{session_id} #{info}"}
         return if @completed
         if @progress_bar.nil?
           @progress_bar = ProgressBar.create(
@@ -35,38 +36,55 @@ module Aspera
             title:       '',
             total:       nil)
         end
-        need_increment = true
+        progress_provided = false
         case type
         when :pre_start
+          # give opportunity to show progress of initialization with multiple status
+          Aspera.assert(session_id.nil?)
+          Aspera.assert_type(info, String)
+          # initialization of progress bar
           @title = info
         when :session_start
+          Aspera.assert_type(session_id, String)
+          Aspera.assert(info.nil?)
           raise "Session #{session_id} already started" if @sessions[session_id]
           @sessions[session_id] = {
             job_size: 0, # total size of transfer (pre-calc)
             current:  0
           }
-          @title = ''
+          # remove last pre-start message if any
+          @title = nil
         when :session_size
+          Aspera.assert_type(session_id, String)
+          Aspera.assert(!info.nil?)
           @sessions[session_id][:job_size] = info.to_i
           current_total = total(:job_size)
           @progress_bar.total = current_total unless current_total.eql?(@progress_bar.total) || current_total < @progress_bar.progress
         when :transfer
-          if !@progress_bar.total.nil?
-            need_increment = false
+          Aspera.assert_type(session_id, String)
+          if !@progress_bar.total.nil? && !info.nil?
+            progress_provided = true
             @sessions[session_id][:current] = info.to_i
             current_total = total(:current)
             @progress_bar.progress = current_total unless @progress_bar.progress.eql?(current_total)
           end
         when :end
-          @title = ''
+          Aspera.assert(session_id, String)
+          Aspera.assert(info.nil?)
+          @title = nil
           @completed = true
           @progress_bar.finish
-        else
-          raise "Unknown event type #{type}"
+        else Aspera.error_unexpected_value(type){'event type'}
         end
-        new_title = @sessions.length < 2 ? @title : "[#{@sessions.length}] #{@title}"
+        new_title = @sessions.length < 2 ? @title.to_s : "[#{@sessions.length}] #{@title}"
         @progress_bar.title = new_title unless @progress_bar.title.eql?(new_title)
-        @progress_bar.increment if need_increment && !@completed
+        @progress_bar.increment if !progress_provided && !@completed
+      end
+
+      private
+
+      def total(key)
+        @sessions.values.inject(0){|m, s|m + s[key]}
       end
     end
   end

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.18.1'
+    VERSION = '4.20.0'
   end
 end

data/lib/aspera/command_line_builder.rb

@@ -14,7 +14,7 @@ module Aspera
     OPTIONS_KEYS = %i[desc accepted_types default enum agents required cli ts deprecation].freeze
     CLI_KEYS = %i[type switch convert variable].freeze
 
-    private_constant :CLI_OPTION_TYPE_SWITCH, :OPTIONS_KEYS, :CLI_KEYS
+    private_constant :CLI_OPTION_TYPE_SWITCH, :CLI_OPTION_TYPES, :OPTIONS_KEYS, :CLI_KEYS
 
     class << self
       # transform yes/no to true/false
@@ -22,8 +22,8 @@ module Aspera
         case value
         when 'yes' then return true
         when 'no' then return false
+        else Aspera.error_unexpected_value(value){'only: yes or no: '}
         end
-        raise "unsupported value: #{value}"
       end
 
       # Called by provider of definition before constructor of this class so that params_definition has all mandatory fields
@@ -177,8 +177,7 @@ module Aspera
         parameter_value = [parameter_value] unless parameter_value.is_a?(Array)
         # if transfer_spec value is an array, applies option many times
         parameter_value.each{|v|add_command_line_options([options[:cli][:switch], v])}
-      else
-        raise "ERROR: unknown option processing type: #{processing_type}/#{processing_type.class}"
+      else Aspera.error_unexpected_value(processing_type){processing_type.class.name}
       end
     end
   end

data/lib/aspera/coverage.rb

@@ -17,5 +17,17 @@ if ENV.key?('ENABLE_COVERAGE')
     SimpleCov.result.format!
     $stdout.reopen(original_file_descriptor)
   end
-  SimpleCov.start
+  # lines with those words are ignored from coverage
+  no_cov_functions = %w[error_unreachable_line error_unexpected_value Log.log.trace].freeze
+  SimpleCov.start do
+    add_filter 'lib/aspera/cli/plugins/faspex.rb'
+    add_filter 'lib/aspera/node_simulator.rb'
+    add_filter 'lib/aspera/keychain/macos_security.rb'
+    add_filter do |source_file|
+      source_file.lines.each do |line|
+        line.skipped! if no_cov_functions.any?{|i|line.src.include?(i)}
+      end
+      false
+    end
+  end
 end