aspera-cli 4.14.0 → 4.16.0

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
@@ -55,31 +57,34 @@ module Aspera
 
     attr_reader :params_definition
 
-    # @param param_hash
+    # @param [Hash] param_hash with parameters
+    # @param [Hash] params_definition with definition of parameters
     def initialize(param_hash, params_definition)
       @param_hash = param_hash # keep reference so that it can be modified by caller before calling `process_params`
       @params_definition = params_definition
-      @result_env = {}
-      @result_args = []
+      @result = {
+        env:  {},
+        args: []
+      }
       @used_param_names = []
     end
 
-    # adds keys :env :args with resulting values after processing
-    # warns if some parameters were not used
-    def add_env_args(env, args)
-      Log.log.debug{"ENV=#{@result_env}, ARGS=#{@result_args}"}
+    # add processed parameters to env and args, warns about unused parameters
+    # @param [Hash] env_args with :env and :args
+    def add_env_args(env_args)
+      Log.log.debug{"add_env_args: ENV=#{@result[:env]}, ARGS=#{@result[:args]}"}
       # warn about non translated arguments
       @param_hash.each_pair{|key, val|Log.log.warn{"unrecognized parameter: #{key} = \"#{val}\""} if !@used_param_names.include?(key)}
       # set result
-      env.merge!(@result_env)
-      args.push(*@result_args)
+      env_args[:env].merge!(@result[:env])
+      env_args[:args].push(*@result[:args])
       return nil
     end
 
     # add options directly to command line
     def add_command_line_options(options)
       return if options.nil?
-      options.each{|o|@result_args.push(o.to_s)}
+      options.each{|o|@result[:args].push(o.to_s)}
     end
 
     def process_params
@@ -118,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
@@ -147,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
@@ -156,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)
-        @result_env[options[:cli][:variable]] = parameter_value
+        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,17 +1,19 @@
 # frozen_string_literal: true
 
 require 'aspera/log'
+require 'aspera/assert'
 require 'aspera/rest'
+require 'aspera/oauth'
 require 'xmlsimple'
 
 module Aspera
   class CosNode < Aspera::Node
     class << self
-      def parameters_from_svc_creds(service_credentials, bucket_region)
+      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
@@ -85,7 +87,7 @@ module Aspera
           receiver_client_ids: 'aspera_ats'
         }})
       # get delegated token to be placed in rest call header and in transfer tags
-      @storage_credentials['token'][TOKEN_FIELD] = delegated_oauth.get_authorization.gsub(/^Bearer /, '')
+      @storage_credentials['token'][TOKEN_FIELD] = Oauth.bearer_extract(delegated_oauth.get_authorization)
       @params[:headers] = {'X-Aspera-Storage-Credentials' => JSON.generate(@storage_credentials)}
     end
   end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+# cspell:ignore USERPROFILE HOMEDRIVE HOMEPATH LC_CTYPE msys aarch
 require 'aspera/log'
+require 'aspera/assert'
 require 'rbconfig'
 
 # cspell:words MEBI mswin bccwin
@@ -14,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
@@ -52,7 +55,7 @@ module Aspera
           return CPU_PPC64
         when /s390/
           return CPU_S390
-        when /arm/
+        when /arm/, /aarch64/
           # arm on mac has rosetta 2
           return CPU_X86_64 if os.eql?(OS_X)
         end
@@ -71,9 +74,9 @@ module Aspera
       # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably than %HOMEDRIVE%%HOMEPATH%
       # so, tell Ruby the right way
       def fix_home
-        return unless os.eql?(OS_WINDOWS) && ENV.key?('USERPROFILE') && Dir.exist?(ENV['USERPROFILE'])
-        ENV['HOME'] = ENV['USERPROFILE']
-        Log.log.debug{"Windows: set home to USERPROFILE: #{ENV['HOME']}"}
+        return unless os.eql?(OS_WINDOWS) && ENV.key?('USERPROFILE') && Dir.exist?(ENV.fetch('USERPROFILE', nil))
+        ENV['HOME'] = ENV.fetch('USERPROFILE', nil)
+        Log.log.debug{"Windows: set HOME to USERPROFILE: #{Dir.home}"}
       end
 
       def empty_binding
@@ -81,13 +84,13 @@ module Aspera
       end
 
       # secure execution of Ruby code
-      def secure_eval(code)
-        Kernel.send('lave'.reverse, code, empty_binding, __FILE__, __LINE__)
+      def secure_eval(code, file, line)
+        Kernel.send('lave'.reverse, code, empty_binding, file, line)
       end
 
       # 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
@@ -113,6 +116,16 @@ module Aspera
       rescue => e
         Log.log.warn(e.message)
       end
+
+      def terminal?
+        $stdout.tty?
+      end
+
+      # @return true if we can display Unicode characters
+      def use_unicode?
+        @use_unicode = terminal? && ENV.values_at('LC_ALL', 'LC_CTYPE', 'LANG').compact.first.include?('UTF-8') if @use_unicode.nil?
+        return @use_unicode
+      end
     end # self
   end # Environment
 end # Aspera

data/lib/aspera/fasp/agent_alpha.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+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 AgentAlpha < Aspera::Fasp::AgentBase
+      # try twice the main init url in sequence
+      START_URIS = ['aspera://']
+      # delay between each try to start connect
+      SLEEP_SEC_BETWEEN_RETRY = 3
+      private_constant :START_URIS, :SLEEP_SEC_BETWEEN_RETRY
+      def initialize(options)
+        @application_id = SecureRandom.uuid
+        super(options)
+        raise 'Using client requires a graphical environment' if !OpenApplication.default_gui_mode.eql?(:graphical)
+        method_index = 0
+        begin
+          @client_app_api = Aspera::JsonRpcClient.new(Aspera::Rest.new(base_url: aspera_client_api_url))
+          client_info = @client_app_api.get_info
+          Log.log.debug{Log.dump(:client_version, client_info)}
+          # my_transfer_id = '0513fe85-65cf-465b-ad5f-18fd40d8c69f'
+          # @client_app_api.get_all_transfers({app_id: @application_id})
+          # @client_app_api.get_transfer(app_id: @application_id, transfer_id: my_transfer_id)
+          # @client_app_api.start_transfer(app_id: @application_id,transfer_spec: {})
+          # @client_app_api.remove_transfer
+          # @client_app_api.stop_transfer
+          # @client_app_api.modify_transfer
+          # @client_app_api.show_directory({app_id: @application_id, transfer_id: my_transfer_id})
+          # @client_app_api.get_files_list({app_id: @application_id, transfer_id: my_transfer_id})
+          Log.log.info('Client was reached') if method_index > 0
+        rescue StandardError => e # Errno::ECONNREFUSED
+          start_url = START_URIS[method_index]
+          method_index += 1
+          raise StandardError, "Unable to start connect #{method_index} times" if start_url.nil?
+          Log.log.warn{"Aspera Connect is not started (#{e}). Trying to start it ##{method_index}..."}
+          if !OpenApplication.uri_graphical(start_url)
+            OpenApplication.uri_graphical('https://downloads.asperasoft.com/connect2/')
+            raise StandardError, 'Connect is not installed'
+          end
+          sleep(SLEEP_SEC_BETWEEN_RETRY)
+          retry
+        end
+      end
+
+      def aspera_client_api_url
+        log_file = File.join(Dir.home, 'Library', 'Logs', 'IBM Aspera', 'ibm-aspera-desktop.log')
+        url = nil
+        File.open(log_file, 'r') do |file|
+          file.each_line do |line|
+            line = line.chomp
+            if (m = line.match(/JSON-RPC server listening on (.*)/))
+              url = "http://#{m[1]}"
+            end
+          end
+        end
+        return url
+      end
+
+      def start_transfer(transfer_spec, token_regenerator: nil)
+        @request_id = SecureRandom.uuid
+        # 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')
+        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
+        started = false
+        pre_calc = false
+        begin
+          loop do
+            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
+              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: :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
+        rescue StandardError => e
+          return [e]
+        end
+        return [:success]
+      end # wait
+    end # AgentAlpha
+  end
+end

data/lib/aspera/fasp/agent_base.rb

@@ -1,94 +1,58 @@
 # frozen_string_literal: true
 
+require 'aspera/log'
+require 'aspera/assert'
 module Aspera
   module Fasp
-    # Base class for FASP transfer agents
-    # sub classes shall implement start_transfer and shutdown
+    # Base class for transfer agents
     class AgentBase
-      # fields description for JSON generation
-      # spellchecker: disable
-      INTEGER_FIELDS = %w[Bytescont FaspFileArgIndex StartByte Rate MinRate Port Priority RateCap MinRateCap TCPPort CreatePolicy TimePolicy
-                          DatagramSize XoptFlags VLinkVersion PeerVLinkVersion DSPipelineDepth PeerDSPipelineDepth ReadBlockSize WriteBlockSize
-                          ClusterNumNodes ClusterNodeId Size Written Loss FileBytes PreTransferBytes TransferBytes PMTU Elapsedusec ArgScansAttempted
-                          ArgScansCompleted PathScansAttempted FileScansCompleted TransfersAttempted TransfersPassed Delay].freeze
-      BOOLEAN_FIELDS = %w[Encryption Remote RateLock MinRateLock PolicyLock FilesEncrypt FilesDecrypt VLinkLocalEnabled VLinkRemoteEnabled
-                          MoveRange Keepalive TestLogin UseProxy Precalc RTTAutocorrect].freeze
-      EXPECTED_METHODS = %i[text struct enhanced].freeze
-      private_constant :INTEGER_FIELDS, :BOOLEAN_FIELDS, :EXPECTED_METHODS
-      # spellchecker: enable
-
       class << self
-        # This checks the validity of the value returned by wait_for_transfers_completion
-        # it must be a list of :success or exception
-        def validate_status_list(statuses)
-          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?
-        end
-      end
-
-      private
-
-      # translates legacy event into enhanced (JSON) event
-      def enhanced_event_format(event)
-        return event.keys.each_with_object({}) do |e, h|
-          # capital_to_snake_case
-          new_name = e
-              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-              .gsub(/([a-z\d])(usec)$/, '\1_\2')
-              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-              .downcase
-          value = event[e]
-          value = value.to_i if INTEGER_FIELDS.include?(e)
-          value = value.eql?('Yes') if BOOLEAN_FIELDS.include?(e)
-          h[new_name] = value
-        end
-      end
-
-      def initialize
-        @listeners = []
-      end
-
-      def notify_listeners(current_event_text, current_event_data)
-        Log.log.debug('send event to listeners')
-        enhanced_event = nil
-        @listeners.each do |listener|
-          listener.event_text(current_event_text) if listener.respond_to?(:event_text)
-          listener.event_struct(current_event_data) if listener.respond_to?(:event_struct)
-          if listener.respond_to?(:event_enhanced)
-            enhanced_event = enhanced_event_format(current_event_data) if enhanced_event.nil?
-            listener.event_enhanced(enhanced_event)
+        # compute options from user provided and default options
+        def options(default:, options:)
+          result = options.symbolize_keys
+          available = default.map{|k, v|"#{k}(#{v})"}.join(', ')
+          result.each do |k, _v|
+            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)
+            result[k] = v unless result.key?(k)
           end
+          return result
         end
-      end # notify_listeners
 
-      def notify_begin(id, size)
-        notify_listeners('emulated', {LISTENER_SESSION_ID_B => id, 'Type' => 'NOTIFICATION', 'PreTransferBytes' => size})
+        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
+        assert_type(statuses, Array)
+        assert(statuses.select{|i|!i.eql?(:success) && !i.is_a?(StandardError)}.empty?){"bad statuses content: #{statuses}"}
+        return statuses
       end
 
-      def notify_progress(id, size)
-        notify_listeners('emulated', {LISTENER_SESSION_ID_B => id, 'Type' => 'STATS', 'Bytescont' => size})
-      end
+      private
 
-      def notify_end(id)
-        notify_listeners('emulated', {LISTENER_SESSION_ID_B => id, 'Type' => 'DONE'})
+      def initialize(options)
+        # 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)}
+        @progress = options[:progress]
+        options.delete(:progress)
       end
 
-      public
-
-      LISTENER_SESSION_ID_B = 'ListenerSessionId'
-      LISTENER_SESSION_ID_S = 'listener_session_id'
-
-      # listener receives events
-      def add_listener(listener)
-        raise "expect one of #{EXPECTED_METHODS}" if EXPECTED_METHODS.inject(0){|m, e|m + (listener.respond_to?("event_#{e}") ? 1 : 0)}.eql?(0)
-        @listeners.push(listener)
-        self
+      def notify_progress(**parameters)
+        @progress&.event(**parameters)
       end
-
-      # the following methods must be implemented by subclass:
-      # start_transfer(transfer_spec, token_regenerator: nil) : start transfer
-      # wait_for_transfers_completion : wait for termination of all transfers, @return list of : :success or error message
-      # optional: shutdown
     end
   end
 end

data/lib/aspera/fasp/agent_connect.rb

@@ -4,7 +4,6 @@ require 'aspera/fasp/agent_base'
 require 'aspera/rest'
 require 'aspera/open_application'
 require 'securerandom'
-require 'tty-spinner'
 
 module Aspera
   module Fasp
@@ -14,20 +13,20 @@ module Aspera
       # delay between each try to start connect
       SLEEP_SEC_BETWEEN_RETRY = 3
       private_constant :CONNECT_START_URIS, :SLEEP_SEC_BETWEEN_RETRY
-      def initialize(_options)
-        super()
+      def initialize(options)
+        super(options)
         @connect_settings = {
           'app_id' => SecureRandom.uuid
         }
         raise 'Using connect requires a graphical environment' if !OpenApplication.default_gui_mode.eql?(:graphical)
         method_index = 0
         begin
-          connect_url = Installation.instance.connect_uri
+          connect_url = Products.connect_uri
           Log.log.debug{"found: #{connect_url}"}
           @connect_api = Rest.new({base_url: "#{connect_url}/v5/connect", headers: {'Origin' => Rest.user_agent}}) # could use v6 also now
           connect_info = @connect_api.read('info/version')[:data]
           Log.log.info('Connect was reached') if method_index > 0
-          Log.dump(:connect_version, connect_info)
+          Log.log.debug{Log.dump(:connect_version, connect_info)}
         rescue StandardError => e # Errno::ECONNREFUSED
           start_url = CONNECT_START_URIS[method_index]
           method_index += 1
@@ -74,10 +73,12 @@ module Aspera
       def wait_for_transfers_completion
         connect_activity_args = {'aspera_connect_settings' => @connect_settings}
         started = false
-        spinner = nil
+        pre_calc = false
+        session_id = @xfer_id
         begin
           loop do
             tr_info = @connect_api.create("transfers/info/#{@xfer_id}", connect_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?
@@ -86,32 +87,30 @@ module Aspera
               end
               # TODO: get session id
               case transfer['status']
-              when 'completed'
-                notify_end(@connect_settings['app_id'])
-                break
               when 'initiating', 'queued'
-                if spinner.nil?
-                  spinner = TTY::Spinner.new('[:spinner] :title', format: :classic)
-                  spinner.start
-                end
-                spinner.update(title: transfer['status'])
-                spinner.spin
+                notify_progress(session_id: nil, type: :pre_start, info: transfer['status'])
               when 'running'
-                # puts "running: sessions:#{transfer['sessions'].length}, #{transfer['sessions'].map{|i| i['bytes_transferred']}.join(',')}"
-                if !started && (transfer['bytes_expected'] != 0)
-                  spinner&.success
-                  notify_begin(@connect_settings['app_id'], transfer['bytes_expected'])
+                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(@connect_settings['app_id'], transfer['bytes_written'])
+                  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'
-                spinner&.error
+                notify_progress(type: :end, session_id: session_id)
                 raise Fasp::Error, transfer['error_desc']
               when 'cancelled'
-                spinner&.error
+                notify_progress(type: :end, session_id: session_id)
                 raise Fasp::Error, 'Transfer cancelled by user'
               else
+                notify_progress(type: :end, session_id: session_id)
                 raise Fasp::Error, "unknown status: #{transfer['status']}: #{transfer['error_desc']}"
               end
             end