aspera-cli 4.15.0 → 4.16.0

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/cli/plugins/node'
-
+require 'aspera/assert'
 module Aspera
   module Cli
     module Plugins
@@ -49,8 +49,6 @@ module Aspera
 
         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
@@ -84,63 +82,69 @@ module Aspera
             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
+              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
+              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

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-require 'aspera/sync'
+require 'aspera/fasp/sync'
+require 'aspera/assert'
 
 module Aspera
   module Cli
     # Module for sync actions
     module SyncActions
       SIMPLE_ARGUMENTS_SYNC = {
-        direction:  Aspera::Sync::DIRECTIONS,
+        direction:  Aspera::Fasp::Sync::DIRECTIONS,
         local_dir:  String,
         remote_dir: String
       }.stringify_keys.freeze
@@ -19,8 +20,7 @@ module Aspera
       end
 
       def execute_sync_action(&block)
-        # options = Aspera::Cli::Manager.new
-        raise 'Internal Error: No block given' unless block
+        assert(block){'No block given'}
         command = options.get_next_command(%i[start admin])
         # try to get 3 arguments as simple arguments
         case command
@@ -45,13 +45,13 @@ module Aspera
               :sync_info,
               mandatory: false,
               default: {'sessions' => [{'name' => File.basename(simple_session_args['local_dir'])}]})
-            raise "sync_info shall be a Hash with key 'sessions' with Array of Hash: #{async_params}" unless async_params.is_a?(Hash) &&
-              async_params['sessions']&.is_a?(Array) &&
-              async_params['sessions'].first.is_a?(Hash)
+            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::Sync.start(async_params, &block)
+          Aspera::Fasp::Sync.start(async_params, &block)
           return Main.result_success
         when :admin
           command2 = options.get_next_command([:status])
@@ -59,7 +59,7 @@ module Aspera
           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::Sync.admin_status(async_params, sync_session_name)}
+            return {type: :single_object, data: Aspera::Fasp::Sync.admin_status(async_params, sync_session_name)}
           end # command2
         end # command
       end # execute_action

data/lib/aspera/cli/transfer_agent.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require 'aspera/fasp/agent_base'
 require 'aspera/fasp/transfer_spec'
 require 'aspera/cli/info'
+require 'aspera/log'
+require 'aspera/assert'
 
 module Aspera
   module Cli
@@ -28,7 +31,7 @@ module Aspera
         :FILE_LIST_FROM_TRANSFER_SPEC,
         :FILE_LIST_OPTIONS,
         :DEFAULT_TRANSFER_NOTIFY_TEMPLATE
-      TRANSFER_AGENTS = %i[direct node connect httpgw trsdk].freeze
+      TRANSFER_AGENTS = Fasp::AgentBase.agent_list.freeze
 
       class << self
         # @return :success if all sessions statuses returned by "start" are success
@@ -65,7 +68,7 @@ module Aspera
 
       # multiple option are merged
       def option_transfer_spec=(value)
-        raise 'option ts shall be a Hash' unless value.is_a?(Hash)
+        assert_type(value, Hash){'ts'}
         @transfer_spec_command_line.deep_merge!(value)
       end
 
@@ -92,8 +95,8 @@ module Aspera
       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}"
@@ -117,7 +120,8 @@ module Aspera
         # 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
@@ -133,7 +137,7 @@ module Aspera
         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
@@ -181,14 +185,15 @@ module Aspera
         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 Cli::BadArgument, "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
@@ -199,7 +204,7 @@ 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
@@ -223,12 +228,14 @@ module Aspera
         @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_completion
+        result = agent_instance.wait_for_completion
         send_email_transfer_notification(transfer_spec, result)
         return result
       end

data/lib/aspera/cli/transfer_progress.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/log'
+require 'aspera/assert'
 require 'ruby-progressbar'
 
 module Aspera
@@ -25,9 +26,7 @@ module Aspera
 
       def event(session_id:, type:, info: nil)
         Log.log.debug{"progress: #{type} #{session_id} #{info}"}
-        if session_id.nil? && !type.eql?(:pre_start)
-          raise 'Internal error: session_id is nil'
-        end
+        assert(!session_id.nil? || type.eql?(:pre_start)){'session_id is nil'}
         return if @completed
         if @progress_bar.nil?
           @progress_bar = ProgressBar.create(

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.15.0'
+    VERSION = '4.16.0'
   end
 end

data/lib/aspera/command_line_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'aspera/log'
+require 'aspera/assert'
 module Aspera
   # helper class to build command line from a parameter list (key-value hash)
   # constructor takes hash: { 'param1':'value1', ...}
@@ -27,20 +29,20 @@ module Aspera
       # Called by provider of definition before constructor of this class so that params_definition has all mandatory fields
       def normalize_description(full_description)
         full_description.each do |name, options|
-          raise "Expecting Hash, but have #{options.class} in #{name}" unless options.is_a?(Hash)
+          assert_type(options, Hash){name}
           unsupported_keys = options.keys - OPTIONS_KEYS
-          raise "Unsupported definition keys: #{unsupported_keys}" unless unsupported_keys.empty?
-          raise "Missing key: cli for #{name}" unless options.key?(:cli)
-          raise 'Key: cli must be Hash' unless options[:cli].is_a?(Hash)
-          raise 'Missing key: cli.type' unless options[:cli].key?(:type)
-          raise "Unsupported processing type for #{name}: #{options[:cli][:type]}" unless CLI_OPTION_TYPES.include?(options[:cli][:type])
+          assert(unsupported_keys.empty?){"Unsupported definition keys: #{unsupported_keys}"}
+          assert(options.key?(:cli)){"Missing key: cli for #{name}"}
+          assert_type(options[:cli], Hash){'Key: cli'}
+          assert(options[:cli].key?(:type)){'Missing key: cli.type'}
+          assert_values(options[:cli][:type], CLI_OPTION_TYPES){"Unsupported processing type for #{name}"}
           # by default : optional
           options[:mandatory] ||= false
           options[:desc] ||= ''
           options[:desc] = "DEPRECATED: #{options[:deprecation]}\n#{options[:desc]}" if options.key?(:deprecation)
           cli = options[:cli]
           unsupported_cli_keys = cli.keys - CLI_KEYS
-          raise "Unsupported cli keys: #{unsupported_cli_keys}" unless unsupported_cli_keys.empty?
+          assert(unsupported_cli_keys.empty?){"Unsupported cli keys: #{unsupported_cli_keys}"}
           # by default : string, unless it's without arg
           options[:accepted_types] ||= options[:cli][:type].eql?(:opt_without_arg) ? :bool : :string
           # single type is placed in array
@@ -121,7 +123,7 @@ module Aspera
         when :hash then Hash
         when :int then Integer
         when :bool then [TrueClass, FalseClass]
-        else raise "INTERNAL: unexpected value: #{type_symbol}"
+        else error_unexpected_value(type_symbol)
         end
       end.flatten
       # check that value is of expected type
@@ -150,7 +152,7 @@ module Aspera
         raise Fasp::Error, "unsupported #{name}: #{parameter_value}" if converted_value.nil?
         parameter_value = converted_value
       when NilClass
-      else raise "not expected type for convert #{options[:cli][:convert].class} for #{name}"
+      else error_unexpected_value(options[:cli][:convert].class)
       end
 
       case processing_type
@@ -159,14 +161,14 @@ module Aspera
       when :ignore, :special # ignore this parameter or process later
         return
       when :envvar # set in env var
-        raise 'error' unless options[:cli].key?(:variable)
+        assert(options[:cli].key?(:variable)){'missing key: cli.variable'}
         @result[:env][options[:cli][:variable]] = parameter_value
       when :opt_without_arg # if present and true : just add option without value
         add_param = false
         case parameter_value
         when false then nil # nothing to put on command line, no creation by default
         when true then add_param = true
-        else raise Fasp::Error, "unsupported #{name}: #{parameter_value}"
+        else error_unexpected_value(parameter_value){name}
         end
         add_param = !add_param if options[:add_on_false]
         add_command_line_options([options[:cli][:switch]]) if add_param

data/lib/aspera/cos_node.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/log'
+require 'aspera/assert'
 require 'aspera/rest'
 require 'aspera/oauth'
 require 'xmlsimple'
@@ -10,9 +11,9 @@ module Aspera
     class << self
       def parameters_from_svc_credentials(service_credentials, bucket_region)
         # check necessary contents
-        raise 'service_credentials must be a Hash' unless service_credentials.is_a?(Hash)
+        assert_type(service_credentials, Hash){'service_credentials'}
         %w[apikey resource_instance_id endpoints].each do |field|
-          raise "service_credentials must have a field: #{field}" unless service_credentials.key?(field)
+          assert(service_credentials.key?(field)){"service_credentials must have a field: #{field}"}
         end
         Aspera::Log.dump('service_credentials', service_credentials)
         # read endpoints from service provided in service credentials

data/lib/aspera/coverage.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# coverage for tests
+if ENV.key?('ENABLE_COVERAGE')
+  require 'simplecov'
+  require 'securerandom'
+  # compute gem source root based on this script location, assuming it is in bin/
+  # use dirname instead of gsub, in case folder separator is not /
+  development_root = 3.times.inject(File.realpath(__FILE__)) { |p, _| File.dirname(p) }
+  SimpleCov.root(development_root)
+  SimpleCov.enable_for_subprocesses if SimpleCov.respond_to?(:enable_for_subprocesses)
+  # keep cache data for 1 day (must be longer that time to run the whole test suite)
+  SimpleCov.merge_timeout(86400)
+  SimpleCov.command_name(SecureRandom.uuid)
+  SimpleCov.at_exit do
+    original_file_descriptor = $stdout
+    $stdout.reopen(File.join(development_root, 'simplecov.log'))
+    SimpleCov.result.format!
+    $stdout.reopen(original_file_descriptor)
+  end
+  SimpleCov.start
+end

data/lib/aspera/data_repository.rb

@@ -1,15 +1,46 @@
 # frozen_string_literal: true
 
-require 'aspera/log'
+require 'aspera/assert'
 require 'singleton'
+require 'openssl'
 
 module Aspera
   # a simple binary data repository
   class DataRepository
     include Singleton
+    # in same order as elements in folder
+    ELEMENTS = %i[dsa rsa uuid aspera.global-cli-client aspera.drive license]
+    START_INDEX = 1
+    DATA_FOLDER_NAME = 'data'
+
+    # decode data as expected as string
+    # @param name [Symbol] name of the data item
+    # @return [String] decoded data
+    def item(name)
+      index = ELEMENTS.index(name)
+      raise ArgumentError, "unknown data item #{name} (#{name.class})" unless index
+      raw_data = data(START_INDEX + index)
+      case name
+      when :dsa, :rsa
+        # generate PEM from DER
+        return OpenSSL::PKey.const_get(name.to_s.upcase).new(raw_data).to_pem
+      when :license
+        return Zlib::Inflate.inflate(raw_data)
+      when :uuid
+        return format('%08x-%04x-%04x-%04x-%04x%08x', *raw_data.unpack('NnnnnN'))
+      when :'aspera.global-cli-client', :'aspera.drive'
+        return Base64.urlsafe_encode64(raw_data)
+      else error_unexpected_value(name)
+      end
+    end
+
+    private
+
+    private_constant :START_INDEX, :DATA_FOLDER_NAME
+
     # get binary value from data repository
     def data(id)
-      File.read(File.join(__dir__, 'data', id.to_s), mode: 'rb')
+      File.read(File.join(__dir__, DATA_FOLDER_NAME, id.to_s), mode: 'rb')
     end
   end
 end

data/lib/aspera/environment.rb

@@ -2,6 +2,7 @@
 
 # cspell:ignore USERPROFILE HOMEDRIVE HOMEPATH LC_CTYPE msys aarch
 require 'aspera/log'
+require 'aspera/assert'
 require 'rbconfig'
 
 # cspell:words MEBI mswin bccwin
@@ -15,10 +16,11 @@ module Aspera
     OS_AIX = :aix
     OS_LIST = [OS_WINDOWS, OS_X, OS_LINUX, OS_AIX].freeze
     CPU_X86_64 = :x86_64
+    CPU_ARM64 = :arm64
     CPU_PPC64 = :ppc64
     CPU_PPC64LE = :ppc64le
     CPU_S390 = :s390
-    CPU_LIST = [CPU_X86_64, CPU_PPC64, CPU_PPC64LE, CPU_S390].freeze
+    CPU_LIST = [CPU_X86_64, CPU_ARM64, CPU_PPC64, CPU_PPC64LE, CPU_S390].freeze
 
     BITS_PER_BYTE = 8
     MEBI = 1024 * 1024
@@ -88,7 +90,7 @@ module Aspera
 
       # value is provided in block
       def write_file_restricted(path, force: false, mode: nil)
-        raise 'coding error, missing content block' unless block_given?
+        assert(block_given?, exception_class: Aspera::InternalError)
         if force || !File.exist?(path)
           # Windows may give error
           File.unlink(path) rescue nil

data/lib/aspera/fasp/{agent_aspera.rb → agent_alpha.rb}

@@ -2,13 +2,14 @@
 
 require 'aspera/fasp/agent_base'
 require 'aspera/rest'
+require 'aspera/log'
 require 'aspera/json_rpc'
 require 'aspera/open_application'
 require 'securerandom'
 
 module Aspera
   module Fasp
-    class AgentAspera < Aspera::Fasp::AgentBase
+    class AgentAlpha < Aspera::Fasp::AgentBase
       # try twice the main init url in sequence
       START_URIS = ['aspera://']
       # delay between each try to start connect
@@ -66,53 +67,42 @@ module Aspera
         # if there is a token, we ask connect client to use well known ssh private keys
         # instead of asking password
         transfer_spec['authentication'] = 'token' if transfer_spec.key?('token')
-        @client_app_api.start_transfer(app_id: @application_id,transfer_spec: transfer_spec)
-        # @xfer_id = res['transfer_specs'].first['transfer_spec']['tags'][Fasp::TransferSpec::TAG_RESERVED]['xfer_id']
+        result = @client_app_api.start_transfer(app_id: @application_id, desktop_spec: {}, transfer_spec: transfer_spec)
+        @xfer_id = result['uuid']
       end
 
       def wait_for_transfers_completion
-        client_activity_args = {'aspera_client_settings' => @client_settings}
         started = false
         pre_calc = false
-        session_id = @xfer_id
         begin
           loop do
-            tr_info = @client_api.create("transfers/info/#{@xfer_id}", client_activity_args)[:data]
-            Log.log.trace1{Log.dump(:tr_info, tr_info)}
-            if tr_info['transfer_info'].is_a?(Hash)
-              transfer = tr_info['transfer_info']
-              if transfer.nil?
-                Log.log.warn('no session in Connect')
-                break
+            transfer = @client_app_api.get_transfer(app_id: @application_id, transfer_id: @xfer_id)
+            case transfer['status']
+            when 'initiating', 'queued'
+              notify_progress(session_id: nil, type: :pre_start, info: transfer['status'])
+            when 'running'
+              if !started
+                notify_progress(session_id: @xfer_id, type: :session_start)
+                started = true
               end
-              # TODO: get session id
-              case transfer['status']
-              when 'initiating', 'queued'
-                notify_progress(session_id: nil, type: :pre_start, info: transfer['status'])
-              when 'running'
-                if !started
-                  notify_progress(session_id: session_id, type: :session_start)
-                  started = true
-                end
-                if !pre_calc && (transfer['bytes_expected'] != 0)
-                  notify_progress(type: :session_size, session_id: session_id, info: transfer['bytes_expected'])
-                  pre_calc = true
-                else
-                  notify_progress(type: :transfer, session_id: session_id, info: transfer['bytes_written'])
-                end
-              when 'completed'
-                notify_progress(type: :end, session_id: session_id)
-                break
-              when 'failed'
-                notify_progress(type: :end, session_id: session_id)
-                raise Fasp::Error, transfer['error_desc']
-              when 'cancelled'
-                notify_progress(type: :end, session_id: session_id)
-                raise Fasp::Error, 'Transfer cancelled by user'
+              if !pre_calc && (transfer['bytes_expected'] != 0)
+                notify_progress(type: :session_size, session_id: @xfer_id, info: transfer['bytes_expected'])
+                pre_calc = true
               else
-                notify_progress(type: :end, session_id: session_id)
-                raise Fasp::Error, "unknown status: #{transfer['status']}: #{transfer['error_desc']}"
+                notify_progress(type: :transfer, session_id: @xfer_id, info: transfer['bytes_written'])
               end
+            when 'completed'
+              notify_progress(type: :end, session_id: @xfer_id)
+              break
+            when 'failed'
+              notify_progress(type: :end, session_id: @xfer_id)
+              raise Fasp::Error, transfer['error_desc']
+            when 'cancelled'
+              notify_progress(type: :end, session_id: @xfer_id)
+              raise Fasp::Error, 'Transfer cancelled by user'
+            else
+              notify_progress(type: :end, session_id: @xfer_id)
+              raise Fasp::Error, "unknown status: #{transfer['status']}: #{transfer['error_desc']}"
             end
             sleep(1)
           end
@@ -121,6 +111,6 @@ module Aspera
         end
         return [:success]
       end # wait
-    end # AgentAspera
+    end # AgentAlpha
   end
 end

data/lib/aspera/fasp/agent_base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'aspera/log'
+require 'aspera/assert'
 module Aspera
   module Fasp
     # Base class for transfer agents
@@ -10,7 +12,9 @@ module Aspera
           result = options.symbolize_keys
           available = default.map{|k, v|"#{k}(#{v})"}.join(', ')
           result.each do |k, _v|
-            raise "Unknown transfer agent parameter: #{k}, expect one of #{available}" unless default.key?(k)
+            assert_values(k, default.keys){"transfer agent parameter: #{k}"}
+            # check it is the expected type: too limiting, as we can have an Integer or Float, or symbol and string
+            # raise "Invalid value for transfer agent parameter: #{k}, expect #{default[k].class.name}" unless default[k].nil? || v.is_a?(default[k].class)
           end
           default.each do |k, v|
             raise "Missing required agent parameter: #{k}. Parameters: #{available}" if v.eql?(:required) && !result.key?(k)
@@ -18,24 +22,30 @@ module Aspera
           end
           return result
         end
-      end
+
+        def agent_list
+          Dir.entries(File.dirname(File.expand_path(__FILE__))).select do |file|
+            file.start_with?('agent_') && !file.eql?('agent_base.rb')
+          end.map{|file|file.sub(/^agent_/, '').sub(/\.rb$/, '').to_sym}
+        end
+    end
       def wait_for_completion
         # list of: :success or "error message string"
         statuses = wait_for_transfers_completion
         @progress&.reset
-        raise "internal error: bad statuses type: #{statuses.class}" unless statuses.is_a?(Array)
-        raise "internal error: bad statuses content: #{statuses}" unless statuses.select{|i|!i.eql?(:success) && !i.is_a?(StandardError)}.empty?
+        assert_type(statuses, Array)
+        assert(statuses.select{|i|!i.eql?(:success) && !i.is_a?(StandardError)}.empty?){"bad statuses content: #{statuses}"}
         return statuses
       end
 
       private
 
       def initialize(options)
-        raise 'internal error' unless respond_to?(:start_transfer)
-        raise 'internal error' unless respond_to?(:wait_for_transfers_completion)
         # method `shutdown` is optional
+        assert(respond_to?(:start_transfer))
+        assert(respond_to?(:wait_for_transfers_completion))
+        assert_type(options, Hash){'transfer agent options'}
         Log.log.debug{Log.dump(:agent_options, options)}
-        raise "transfer agent options expecting Hash, but have #{options.class}" unless options.is_a?(Hash)
         @progress = options[:progress]
         options.delete(:progress)
       end