aspera-cli 4.14.0 → 4.16.0

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

@@ -1,33 +1,54 @@
 # frozen_string_literal: true
 
 require 'aspera/cli/plugins/node'
-
+require 'aspera/assert'
 module Aspera
   module Cli
     module Plugins
       # Plugin for Aspera Shares v1
       class Shares < Aspera::Cli::BasicAuthPlugin
+        API_BASE = 'node_api'
         class << self
-          def detect(base_url)
-            api = Rest.new({base_url: base_url})
-            # Shares
+          def detect(address_or_url)
+            address_or_url = "https://#{address_or_url}" unless address_or_url.match?(%r{^[a-z]{1,6}://})
+            api = Rest.new(base_url: address_or_url, redirect_max: 1)
+            found = false
             begin
               # shall fail: shares requires auth, but we check error message
               # TODO: use ping instead ?
-              api.read('node_api/app')
+              api.read("#{API_BASE}/app")
             rescue RestCallError => e
               if e.response.code.to_s.eql?('401') && e.response.body.eql?('{"error":{"user_message":"API user authentication failed"}}')
-                return {version: 'unknown'}
+                found = true
               end
             end
-            nil
+            return nil unless found
+            version = 'unknown'
+            test_page = api.call({ operation: 'GET', subpath: 'login' })
+            if (m = test_page[:http].body.match(/\(v(1\..*)\)/))
+              version = m[1]
+            end
+            return {
+              version: version,
+              url:     address_or_url
+            }
+          end
+
+          def wizard(object:, private_key_path: nil, pub_key_pem: nil)
+            options = object.options
+            return {
+              preset_value: {
+                url:      options.get_option(:url, mandatory: true),
+                username: options.get_option(:username, mandatory: true),
+                password: options.get_option(:password, mandatory: true)
+              },
+              test_args:    'files br /'
+            }
           end
         end
 
         def initialize(env)
           super(env)
-          options.declare(:type, 'Type of user/group for operations', values: %i[any local ldap saml], default: :any)
-          options.parse_options!
         end
 
         SAML_IMPORT_MANDATORY = %w[id name_id].freeze
@@ -44,7 +65,7 @@ module Aspera
             nagios = Nagios.new
             begin
               Rest
-                .new(base_url: options.get_option(:url, mandatory: true) + '/node_api')
+                .new(base_url: "#{options.get_option(:url, mandatory: true)}/#{API_BASE}")
                 .call(
                   operation: 'GET',
                   subpath: 'ping',
@@ -56,69 +77,74 @@ module Aspera
             end
             return nagios.result
           when :repository, :files
-            api_shares_node = basic_auth_api('node_api')
+            api_shares_node = basic_auth_api(API_BASE)
             repo_command = options.get_next_command(Node::COMMANDS_SHARES)
-            return Node.new(@agents.merge(skip_basic_auth_options: true, node_api: api_shares_node)).execute_action(repo_command)
+            return Node.new(@agents, api: api_shares_node).execute_action(repo_command)
           when :admin
             api_shares_admin = basic_auth_api('api/v1')
-            admin_command = options.get_next_command(%i[user group share node].freeze)
+            admin_command = options.get_next_command(%i[node share transfer_settings user group].freeze)
             case admin_command
             when :node
               return entity_action(api_shares_admin, 'data/nodes')
+            when :share
+              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]}
+              when :user_permissions, :group_permissions
+                share_id = instance_identifier
+                return entity_action(api_shares_admin, "data/shares/#{share_id}/#{share_command}")
+              end
+            when :transfer_settings
+              xfer_settings_command = options.get_next_command(%i[show modify])
+              return entity_command(xfer_settings_command, api_shares_admin, 'data/transfer_settings', is_singleton: true)
             when :user, :group
               entity_type = admin_command
-              entities_location = options.get_option(:type, mandatory: true)
+              entities_location = options.get_next_command(%i[all local ldap saml])
               entities_path = "data/#{entities_location}_#{entity_type}s"
               entity_action = nil
               case entities_location
-              when :any
+              when :all
                 entities_path = "data/#{entity_type}s"
                 entity_action = %i[list show delete]
                 entity_action.concat(USR_GRP_SETTINGS)
                 entity_action.push(:users) if entity_type.eql?(:group)
                 entity_action.freeze
               when :local
-                entity_action = %i[list show create modify delete].freeze
+                entity_action = %i[list show delete create modify].freeze
               when :ldap
                 entity_action = %i[add].freeze
               when :saml
                 entity_action = %i[import].freeze
               end
               entity_verb = options.get_next_command(entity_action)
-              # entity_path = "#{entities_path}/#{instance_identifier}" if %i[app_authorizations share_permissions].include?(entity_verb)
               case entity_verb
-              when *Plugin::ALL_OPS
+              when *Plugin::ALL_OPS # list, show, delete, create, modify
                 display_fields = entity_type.eql?(:user) ? %w[id username first_name last_name email] : nil
-                display_fields.push(:directory_user) if entity_type.eql?(:user) && entities_location.eql?(:any)
+                display_fields.push(:directory_user) if entity_type.eql?(:user) && entities_location.eql?(:all)
                 return entity_command(entity_verb, api_shares_admin, entities_path, display_fields: display_fields)
-              when :import
-                return do_bulk_operation(value_create_modify(type: :bulk_hash), 'created') do |entity_parameters|
+              when *USR_GRP_SETTINGS # transfer_settings, app_authorizations, share_permissions
+                group_id = instance_identifier
+                entities_path = "#{entities_path}/#{group_id}/#{entity_verb}"
+                return entity_action(api_shares_admin, entities_path, is_singleton: !entity_verb.eql?(:share_permissions))
+              when :import # saml
+                return do_bulk_operation(command: entity_verb, descr: 'user information') do |entity_parameters|
                   entity_parameters = entity_parameters.transform_keys{|k|k.gsub(/\s+/, '_').downcase}
-                  raise 'expecting Hash' unless entity_parameters.is_a?(Hash)
+                  assert_type(entity_parameters, Hash)
                   SAML_IMPORT_MANDATORY.each{|p|raise "missing mandatory field: #{p}" if entity_parameters[p].nil?}
                   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]
                 end
-              when :add
-                return do_bulk_operation(value_create_modify(type: :bulk_hash), 'created') do |entity_name|
-                  raise "expecting string (name), have #{entity_name.class}" unless entity_name.is_a?(String)
+              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]
                 end
-              when *USR_GRP_SETTINGS
-                group_id = instance_identifier
-                entities_path = "#{entities_path}/#{group_id}/#{entity_verb}"
-                return entity_action(api_shares_admin, entities_path, is_singleton: !entity_verb.eql?(:share_permissions))
-              end
-            when :share
-              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]}
-              when :user_permissions, :group_permissions
-                return entity_action(api_shares_admin, "data/shares/#{instance_identifier}/#{share_command}")
+              when :users # group
+                raise "TODO, not implemented"
+              else error_unexpected_value(entity_verb)
               end
             end
           end

data/lib/aspera/cli/sync_actions.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'aspera/fasp/sync'
+require 'aspera/assert'
+
+module Aspera
+  module Cli
+    # Module for sync actions
+    module SyncActions
+      SIMPLE_ARGUMENTS_SYNC = {
+        direction:  Aspera::Fasp::Sync::DIRECTIONS,
+        local_dir:  String,
+        remote_dir: String
+      }.stringify_keys.freeze
+
+      class << self
+        def declare_options(options)
+          options.declare(:sync_info, 'Information for sync instance and sessions', types: Hash)
+        end
+      end
+
+      def execute_sync_action(&block)
+        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,
+              type: check.is_a?(Class) ? check : nil,
+              expected: check.is_a?(Class) ? :single : check,
+              mandatory: false)
+            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'])}]})
+            assert_type(async_params, Hash){'sync_info'}
+            assert_type(async_params['sessions'], Array){'sync_info[sessions]'}
+            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)}
+          Aspera::Fasp::Sync.start(async_params, &block)
+          return Main.result_success
+        when :admin
+          command2 = options.get_next_command([:status])
+          case command2
+          when :status
+            sync_session_name = options.get_next_argument('name of sync session', mandatory: false, type: String)
+            async_params = options.get_option(:sync_info, mandatory: true)
+            return {type: :single_object, data: Aspera::Fasp::Sync.admin_status(async_params, sync_session_name)}
+          end # command2
+        end # command
+      end # execute_action
+    end # SyncActions
+  end # Cli
+end # Aspera

data/lib/aspera/cli/transfer_agent.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
+require 'aspera/fasp/agent_base'
 require 'aspera/fasp/transfer_spec'
-require 'aspera/cli/listener/logger'
-require 'aspera/cli/listener/progress_multi'
 require 'aspera/cli/info'
+require 'aspera/log'
+require 'aspera/assert'
 
 module Aspera
   module Cli
@@ -16,7 +17,7 @@ module Aspera
       # special value for --sources : read file list from transfer spec (--ts)
       FILE_LIST_FROM_TRANSFER_SPEC = '@ts'
       FILE_LIST_OPTIONS = [FILE_LIST_FROM_ARGS, FILE_LIST_FROM_TRANSFER_SPEC, 'Array'].freeze
-      DEFAULT_TRANSFER_NOTIF_TMPL = <<~END_OF_TEMPLATE
+      DEFAULT_TRANSFER_NOTIFY_TEMPLATE = <<~END_OF_TEMPLATE
         From: <%=from_name%> <<%=from_email%>>
         To: <<%=to%>>
         Subject: <%=subject%>
@@ -29,8 +30,8 @@ module Aspera
       private_constant :FILE_LIST_FROM_ARGS,
         :FILE_LIST_FROM_TRANSFER_SPEC,
         :FILE_LIST_OPTIONS,
-        :DEFAULT_TRANSFER_NOTIF_TMPL
-      TRANSFER_AGENTS = %i[direct node connect httpgw trsdk].freeze
+        :DEFAULT_TRANSFER_NOTIFY_TEMPLATE
+      TRANSFER_AGENTS = Fasp::AgentBase.agent_list.freeze
 
       class << self
         # @return :success if all sessions statuses returned by "start" are success
@@ -43,15 +44,15 @@ module Aspera
       end
 
       # @param env external objects: option manager, config file manager
-      def initialize(opt_mgr, config)
+      def initialize(opt_mgr, config_plugin)
         @opt_mgr = opt_mgr
-        @config = config
+        @config = config_plugin
         # command line can override transfer spec
-        @transfer_spec_cmdline = {'create_dir' => true}
+        @transfer_spec_command_line = {'create_dir' => true}
+        # options for transfer agent
         @transfer_info = {}
         # the currently selected transfer agent
         @agent = nil
-        @progress_listener = Listener::ProgressMulti.new
         # source/destination pair, like "paths" of transfer spec
         @transfer_paths = nil
         @opt_mgr.declare(:ts, 'Override transfer spec values', types: Hash, handler: {o: self, m: :option_transfer_spec})
@@ -59,73 +60,68 @@ module Aspera
         @opt_mgr.declare(:sources, "How list of transferred files is provided (#{FILE_LIST_OPTIONS.join(',')})")
         @opt_mgr.declare(:src_type, 'Type of file list', values: %i[list pair], default: :list)
         @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: :option_transfer_info})
-        @opt_mgr.declare(:progress, 'Type of progress bar', values: %i[none native multi], default: :native)
+        @opt_mgr.declare(:transfer_info, 'Parameters for transfer agent', types: Hash, handler: {o: self, m: :transfer_info})
         @opt_mgr.parse_options!
       end
 
-      def option_transfer_spec; @transfer_spec_cmdline; end
+      def option_transfer_spec; @transfer_spec_command_line; end
 
       # multiple option are merged
       def option_transfer_spec=(value)
-        raise 'option ts shall be a Hash' unless value.is_a?(Hash)
-        @transfer_spec_cmdline.deep_merge!(value)
+        assert_type(value, Hash){'ts'}
+        @transfer_spec_command_line.deep_merge!(value)
       end
 
       # add other transfer spec parameters
-      def option_transfer_spec_deep_merge(ts); @transfer_spec_cmdline.deep_merge!(ts); end
+      def option_transfer_spec_deep_merge(ts); @transfer_spec_command_line.deep_merge!(ts); end
 
       # @return [Hash] transfer spec with updated values from command line, including removed values
       def updated_ts(transfer_spec={})
-        transfer_spec.deep_merge!(@transfer_spec_cmdline)
+        transfer_spec.deep_merge!(@transfer_spec_command_line)
         # recursively remove values that are nil (user wants to delete)
         transfer_spec.deep_do { |hash, key, value, _unused| hash.delete(key) if value.nil?}
         return transfer_spec
       end
 
-      def option_transfer_info; @transfer_info; end
+      attr_reader :transfer_info
 
       # multiple option are merged
-      def option_transfer_info=(value)
-        raise 'option transfer_info shall be a Hash' unless value.is_a?(Hash)
+      def transfer_info=(value)
         @transfer_info.deep_merge!(value)
       end
 
       def agent_instance=(instance)
         @agent = instance
-        @agent.add_listener(Listener::Logger.new)
-        # use local progress bar if asked so, or if native and non local ascp (because only local ascp has native progress bar)
-        if @opt_mgr.get_option(:progress, mandatory: true).eql?(:multi) ||
-            (@opt_mgr.get_option(:progress, mandatory: true).eql?(:native) && !instance.class.to_s.eql?('Aspera::Fasp::AgentDirect'))
-          @agent.add_listener(@progress_listener)
-        end
       end
 
       # analyze options and create new agent if not already created or set
-      def set_agent_by_options
-        return nil unless @agent.nil?
+      def agent_instance
+        return @agent unless @agent.nil?
         agent_type = @opt_mgr.get_option(:transfer, mandatory: true)
         # agent plugin is loaded on demand to avoid loading unnecessary dependencies
         require "aspera/fasp/agent_#{agent_type}"
-        agent_options = @opt_mgr.get_option(:transfer_info)
-        raise CliBadArgument, "the transfer agent configuration shall be Hash, not #{agent_options.class} (#{agent_options}), "\
-          'e.g. use @json:<json>' unless agent_options.is_a?(Hash)
-        # special case: use default node
-        if agent_type.eql?(:node) && agent_options.empty?
-          param_set_name = @config.get_plugin_default_config_name(:node)
-          raise CliBadArgument, "No default node configured. Please specify #{Manager.option_name_to_line(:transfer_info)}" if param_set_name.nil?
-          agent_options = @config.preset_by_name(param_set_name)
-        end
-        # special case: native progress bar
-        if agent_type.eql?(:direct) && @opt_mgr.get_option(:progress, mandatory: true).eql?(:native)
-          agent_options[:quiet] = false
+        # set keys as symbols
+        agent_options = @opt_mgr.get_option(:transfer_info).symbolize_keys
+        # special cases
+        case agent_type
+        when :node
+          if agent_options.empty?
+            param_set_name = @config.get_plugin_default_config_name(:node)
+            raise Cli::BadArgument, "No default node configured. Please specify #{Manager.option_name_to_line(:transfer_info)}" if param_set_name.nil?
+            agent_options = @config.preset_by_name(param_set_name).symbolize_keys
+          end
+        when :direct
+          # by default do not display ascp native progress bar
+          agent_options[:quiet] = true unless agent_options.key?(:quiet)
+          agent_options[:check_ignore] = ->(host, port){@config.ignore_cert?(host, port)}
+          agent_options[:trusted_certs] = @config.trusted_cert_locations(files_only: true) unless agent_options.key?(:trusted_certs)
         end
-        # normalize after getting from user or default node
-        agent_options = agent_options.symbolize_keys
+        agent_options[:progress] = @config.progress_bar
         # get agent instance
         new_agent = Kernel.const_get("Aspera::Fasp::Agent#{agent_type.capitalize}").new(agent_options)
         self.agent_instance = new_agent
-        return nil
+        Log.log.debug{"transfer agent is a #{@agent.class}"}
+        return @agent
       end
 
       # return destination folder for transfers
@@ -135,13 +131,13 @@ module Aspera
         dest_folder = @opt_mgr.get_option(:to_folder)
         # do not expand path, if user wants to expand path: user @path:
         return dest_folder unless dest_folder.nil?
-        dest_folder = @transfer_spec_cmdline['destination_root']
+        dest_folder = @transfer_spec_command_line['destination_root']
         return dest_folder unless dest_folder.nil?
         # default: / on remote, . on local
         case direction.to_s
         when Fasp::TransferSpec::DIRECTION_SEND then dest_folder = '/'
         when Fasp::TransferSpec::DIRECTION_RECEIVE then dest_folder = '.'
-        else raise "wrong direction: #{direction}"
+        else error_unexpected_value(direction)
         end
         return dest_folder
       end
@@ -161,7 +157,7 @@ module Aspera
         # return cache if set
         return @transfer_paths unless @transfer_paths.nil?
         # start with lower priority : get paths from transfer spec on command line
-        @transfer_paths = @transfer_spec_cmdline['paths'] if @transfer_spec_cmdline.key?('paths')
+        @transfer_paths = @transfer_spec_command_line['paths'] if @transfer_spec_command_line.key?('paths')
         # is there a source list option ?
         file_list = @opt_mgr.get_option(:sources)
         case file_list
@@ -169,34 +165,35 @@ module Aspera
           Log.log.debug('getting file list as parameters')
           # get remaining arguments
           file_list = @opt_mgr.get_next_argument('source file list', expected: :multiple)
-          raise CliBadArgument, 'specify at least one file on command line or use '\
+          raise Cli::BadArgument, 'specify at least one file on command line or use ' \
             "--sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !file_list.is_a?(Array) || file_list.empty?
         when FILE_LIST_FROM_TRANSFER_SPEC
           Log.log.debug('assume list provided in transfer spec')
           special_case_direct_with_list =
             @opt_mgr.get_option(:transfer, mandatory: true).eql?(:direct) &&
-            Fasp::Parameters.ts_has_ascp_file_list(@transfer_spec_cmdline, @opt_mgr.get_option(:transfer_info))
-          raise CliBadArgument, 'transfer spec on command line must have sources' if @transfer_paths.nil? && !special_case_direct_with_list
+            Fasp::Parameters.ts_has_ascp_file_list(@transfer_spec_command_line, @opt_mgr.get_option(:transfer_info))
+          raise Cli::BadArgument, 'transfer spec on command line must have sources' if @transfer_paths.nil? && !special_case_direct_with_list
           # here we assume check of sources is made in transfer agent
           return @transfer_paths
         when Array
           Log.log.debug('getting file list as extended value')
-          raise CliBadArgument, 'sources must be a Array of String' if !file_list.reject{|f|f.is_a?(String)}.empty?
+          raise Cli::BadArgument, 'sources must be a Array of String' if !file_list.reject{|f|f.is_a?(String)}.empty?
         else
-          raise CliBadArgument, "sources must be a Array, not #{file_list.class}"
+          raise Cli::BadArgument, "sources must be a Array, not #{file_list.class}"
         end
         # here, file_list is an Array or String
         if !@transfer_paths.nil?
           Log.log.warn('--sources overrides paths from --ts')
         end
-        case @opt_mgr.get_option(:src_type, mandatory: true)
+        source_type=@opt_mgr.get_option(:src_type, mandatory: true)
+        case source_type
         when :list
           # when providing a list, just specify source
           @transfer_paths = file_list.map{|i|{'source' => i}}
         when :pair
-          raise CliBadArgument, "When using pair, provide an even number of paths: #{file_list.length}" unless file_list.length.even?
+          assert(file_list.length.even?, exception_class: Cli::BadArgument){"When using pair, provide an even number of paths: #{file_list.length}"}
           @transfer_paths = file_list.each_slice(2).to_a.map{|s, d|{'source' => s, 'destination' => d}}
-        else raise 'Unsupported src_type'
+        else error_unexpected_value(source_type)
         end
         Log.log.debug{"paths=#{@transfer_paths}"}
         return @transfer_paths
@@ -207,44 +204,44 @@ module Aspera
       # @param rest_token [Rest] if oauth token regeneration supported
       def start(transfer_spec, rest_token: nil)
         # check parameters
-        raise 'transfer_spec must be hash' unless transfer_spec.is_a?(Hash)
+        assert_type(transfer_spec, Hash){'transfer_spec'}
         # process :src option
         case transfer_spec['direction']
         when Fasp::TransferSpec::DIRECTION_RECEIVE
           # init default if required in any case
-          @transfer_spec_cmdline['destination_root'] ||= destination_folder(transfer_spec['direction'])
+          @transfer_spec_command_line['destination_root'] ||= destination_folder(transfer_spec['direction'])
         when Fasp::TransferSpec::DIRECTION_SEND
           if transfer_spec.dig('tags', Fasp::TransferSpec::TAG_RESERVED, 'node', 'access_key')
             # gen4
-            @transfer_spec_cmdline.delete('destination_root') if @transfer_spec_cmdline.key?('destination_root_id')
+            @transfer_spec_command_line.delete('destination_root') if @transfer_spec_command_line.key?('destination_root_id')
           elsif transfer_spec.key?('token')
             # gen3
             # in that case, destination is set in return by application (API/upload_setup)
             # but to_folder was used in initial API call
-            @transfer_spec_cmdline.delete('destination_root')
+            @transfer_spec_command_line.delete('destination_root')
           else
             # init default if required
-            @transfer_spec_cmdline['destination_root'] ||= destination_folder(transfer_spec['direction'])
+            @transfer_spec_command_line['destination_root'] ||= destination_folder(transfer_spec['direction'])
           end
         end
         # update command line paths, unless destination already has one
-        @transfer_spec_cmdline['paths'] = transfer_spec['paths'] || ts_source_paths
+        @transfer_spec_command_line['paths'] = transfer_spec['paths'] || ts_source_paths
         # updated transfer spec with command line
         updated_ts(transfer_spec)
+        # if TS from app has content_protection (e.g. F5), that means content is protected: ask password if not provided
+        if transfer_spec['content_protection'].eql?('decrypt') && !transfer_spec.key?('content_protection_password')
+          transfer_spec['content_protection_password'] = @opt_mgr.prompt_user_input('content protection password', true)
+        end
         # create transfer agent
-        set_agent_by_options
-        Log.log.debug{"transfer agent is a #{@agent.class}"}
-        @agent.start_transfer(transfer_spec, token_regenerator: rest_token)
+        agent_instance.start_transfer(transfer_spec, token_regenerator: rest_token)
         # list of: :success or "error message string"
-        result = @agent.wait_for_transfers_completion
-        @progress_listener.reset
-        Fasp::AgentBase.validate_status_list(result)
+        result = agent_instance.wait_for_completion
         send_email_transfer_notification(transfer_spec, result)
         return result
       end
 
       def send_email_transfer_notification(transfer_spec, statuses)
-        return if @opt_mgr.get_option(:notif_to).nil?
+        return if @opt_mgr.get_option(:notify_to).nil?
         global_status = self.class.session_status(statuses)
         email_vars = {
           global_transfer_status: global_status,
@@ -252,7 +249,7 @@ module Aspera
           body:                   "Transfer is: #{global_status}",
           ts:                     transfer_spec
         }
-        @config.send_email_template(email_template_default: DEFAULT_TRANSFER_NOTIF_TMPL, values: email_vars)
+        @config.send_email_template(email_template_default: DEFAULT_TRANSFER_NOTIFY_TEMPLATE, values: email_vars)
       end
 
       # shut down if agent requires it

data/lib/aspera/cli/transfer_progress.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'aspera/log'
+require 'aspera/assert'
+require 'ruby-progressbar'
+
+module Aspera
+  module Cli
+    # progress bar for transfers, supports multi-session
+    class TransferProgress
+      def initialize
+        reset
+      end
+
+      def reset
+        @progress_bar = nil
+        # key is session id
+        @sessions = {}
+        @completed = false
+        @title = ''
+      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}"}
+        assert(!session_id.nil? || type.eql?(:pre_start)){'session_id is nil'}
+        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)
+        end
+        need_increment = true
+        case type
+        when :pre_start
+          @title = info
+        when :session_start
+          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 = ''
+        when :session_size
+          @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
+            @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 = ''
+          @completed = true
+          @progress_bar.finish
+        else
+          raise "Unknown event type #{type}"
+        end
+        new_title = @sessions.length < 2 ? @title : "[#{@sessions.length}] #{@title}"
+        @progress_bar.title = new_title unless @progress_bar.title.eql?(new_title)
+        @progress_bar.increment if need_increment && !@completed
+      end
+    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.14.0'
+    VERSION = '4.16.0'
   end
 end

data/lib/aspera/colors.rb

@@ -14,10 +14,12 @@ class String
   # it adds control chars to set color (and reset at the end).
   VT_STYLES = {
     bold:          1,
+    dim:           2,
     italic:        3,
     underline:     4,
     blink:         5,
     reverse_color: 7,
+    invisible:     8,
     black:         30,
     red:           31,
     green:         32,
@@ -38,7 +40,7 @@ class String
   private_constant :VT_STYLES
   # defines methods to String, one per entry in VT_STYLES
   VT_STYLES.each do |name, code|
-    if $stderr.tty?
+    if $stdout.tty?
       begin_seq = vt_cmd(code)
       end_code = 0 # by default reset all
       if code <= 7 then code + 20