aspera-cli 4.13.0 → 4.15.0

data/lib/aspera/fasp/agent_httpgw.rb

@@ -2,6 +2,7 @@
 
 require 'aspera/fasp/agent_base'
 require 'aspera/fasp/transfer_spec'
+require 'aspera/fasp/faux_file'
 require 'aspera/log'
 require 'aspera/rest'
 require 'securerandom'
@@ -9,44 +10,147 @@ require 'websocket'
 require 'base64'
 require 'json'
 
-# ref: https://api.ibm.com/explorer/catalog/aspera/product/ibm-aspera/api/http-gateway-api/doc/guides-toc
-# https://developer.ibm.com/apis/catalog?search=%22aspera%20http%22
 module Aspera
   module Fasp
-    # start a transfer using Aspera HTTP Gateway, using web socket session for uploads
+    # Start a transfer using Aspera HTTP Gateway, using web socket secure for uploads
+    # ref: https://api.ibm.com/explorer/catalog/aspera/product/ibm-aspera/api/http-gateway-api/doc/guides-toc
+    # https://developer.ibm.com/apis/catalog?search=%22aspera%20http%22
+    # HTTP GW Upload protocol:
+    #   #     type                Contents            Ack                 Counter
+    # v1
+    #   0     JSON.transfer_spec  Transfer Spec       "end upload"        sent_general
+    #   1..   JSON.slice_upload   File base64 chunks  "end upload"        sent_general
+    # v2
+    #   0     JSON.transfer_spec  Transfer Spec       "end upload"        sent_general
+    #   1     JSON.slice_upload   File start          "end_slice_upload"  sent_v2_delimiter
+    #   2..   Binary              File binary chunks  "end upload"        sent_general
+    #   last  JSON.slice_upload   File end            "end_slice_upload"  sent_v2_delimiter
     class AgentHttpgw < Aspera::Fasp::AgentBase
-      # message returned by HTTP GW in case of success
-      MSG_END_UPLOAD = 'end upload'
-      MSG_END_SLICE = 'end_slice_upload'
+      MSG_SEND_TRANSFER_SPEC = 'transfer_spec'
+      MSG_SEND_SLICE_UPLOAD = 'slice_upload'
+      MSG_RECV_DATA_RECEIVED_SIGNAL = 'end upload'
+      MSG_RECV_SLICE_UPLOAD_SIGNAL = 'end_slice_upload'
+      # upload API versions
+      API_V1 = 'v1'
+      API_V2 = 'v2'
       # options available in CLI (transfer_info)
       DEFAULT_OPTIONS = {
-        url:                    nil,
-        upload_chunk_size:      64_000,
-        upload_bar_refresh_sec: 0.5
+        url:               :required,
+        upload_chunk_size: 64_000,
+        api_version:       API_V2,
+        synchronous:       false
       }.freeze
       DEFAULT_BASE_PATH = '/aspera/http-gwy'
-      # upload endpoints
-      V1_UPLOAD = '/v1/upload'
-      V2_UPLOAD = '/v2/upload'
-      private_constant :DEFAULT_OPTIONS, :MSG_END_UPLOAD, :MSG_END_SLICE, :V1_UPLOAD, :V2_UPLOAD
+      THR_RECV = 'recv'
+      LOG_WS_SEND = 'ws: send: '.red
+      LOG_WS_RECV = "ws: #{THR_RECV}: ".green
+      private_constant :DEFAULT_OPTIONS, :MSG_RECV_DATA_RECEIVED_SIGNAL, :MSG_RECV_SLICE_UPLOAD_SIGNAL, :API_V1, :API_V2
 
       # send message on http gw web socket
-      def ws_snd_json(data)
-        @slice_uploads += 1 if data.key?(:slice_upload)
-        Log.log.debug{JSON.generate(data)}
-        ws_send(JSON.generate(data))
+      def ws_snd_json(msg_type, payload)
+        if msg_type.eql?(MSG_SEND_SLICE_UPLOAD) && @options[:api_version].eql?(API_V2)
+          @shared_info[:count][:sent_v2_delimiter] += 1
+        else
+          @shared_info[:count][:sent_general] += 1
+        end
+        Log.log.debug do
+          log_data = payload.dup
+          log_data[:data] = "[data #{log_data[:data].length} bytes]" if log_data.key?(:data)
+          "#{LOG_WS_SEND}json: #{msg_type}: #{JSON.generate(log_data)}"
+        end
+        ws_send(ws_type: :text, data: JSON.generate({msg_type => payload}))
+      end
+
+      # send data on http gw web socket
+      def ws_send(ws_type:, data:)
+        Log.log.debug{"#{LOG_WS_SEND}sending: #{ws_type} (#{data&.length || 0} bytes)"}
+        @shared_info[:count][:sent_general] += 1 if ws_type.eql?(:binary)
+        frame_generator = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: ws_type, version: @ws_handshake.version)
+        @ws_io.write(frame_generator.to_s)
+        if @options[:synchronous]
+          @shared_info[:mutex].synchronize do
+            # if read thread exited, there will be no more updates
+            # we allow for 1 of difference else it stays blocked
+            while @ws_read_thread.alive? &&
+                @shared_info[:read_exception].nil? &&
+                (((@shared_info[:count][:sent_general] - @shared_info[:count][:received_general]) > 1) ||
+                  ((@shared_info[:count][:received_v2_delimiter] - @shared_info[:count][:sent_v2_delimiter]) > 1))
+              if !@shared_info[:cond_var].wait(@shared_info[:mutex], 2.0)
+                Log.log.debug{"#{LOG_WS_SEND}#{'timeout'.blue}: #{@shared_info[:count]}"}
+              end
+            end
+          end
+        end
+        raise @shared_info[:read_exception] unless @shared_info[:read_exception].nil?
+        Log.log.debug{"#{LOG_WS_SEND}counts: #{@shared_info[:count]}"}
+      end
+
+      # message processing for read thread
+      def process_received_message(message)
+        Log.log.debug{"#{LOG_WS_RECV}message: [#{message}] (#{message.class})"}
+        if message.eql?(MSG_RECV_DATA_RECEIVED_SIGNAL)
+          @shared_info[:mutex].synchronize do
+            @shared_info[:count][:received_general] += 1
+            @shared_info[:cond_var].signal
+          end
+        elsif message.eql?(MSG_RECV_SLICE_UPLOAD_SIGNAL)
+          @shared_info[:mutex].synchronize do
+            @shared_info[:count][:received_v2_delimiter] += 1
+            @shared_info[:cond_var].signal
+          end
+        else
+          message.chomp!
+          error_message =
+            if message.start_with?('"') && message.end_with?('"')
+              # remove double quotes : 1..-2
+              JSON.parse(Base64.strict_decode64(message.chomp[1..-2]))['message']
+            elsif message.start_with?('{') && message.end_with?('}')
+              JSON.parse(message)['message']
+            else
+              "unknown message from gateway: [#{message}]"
+            end
+          raise error_message
+        end
       end
 
-      def ws_send(data, type: :text)
-        frame = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: type, version: @ws_handshake.version)
-        @ws_io.write(frame.to_s)
+      # main function of read thread
+      def process_read_thread
+        Log.log.debug{"#{LOG_WS_RECV}read thread started"}
+        frame_parser = ::WebSocket::Frame::Incoming::Client.new(version: @ws_handshake.version)
+        until @ws_io.eof?
+          begin # rubocop:disable Style/RedundantBegin
+            # ready byte by byte until frame is ready
+            # blocking read
+            byte = @ws_io.read(1)
+            Log.log.trace1{"#{LOG_WS_RECV}read: #{byte} (#{byte.class}) eof=#{@ws_io.eof?}"}
+            frame_parser << byte
+            frame_ok = frame_parser.next
+            next if frame_ok.nil?
+            process_received_message(frame_ok.data.to_s)
+            Log.log.debug{"#{LOG_WS_RECV}counts: #{@shared_info[:count]}"}
+          rescue => e
+            Log.log.debug{"#{LOG_WS_RECV}Exception: #{e}"}
+            @shared_info[:mutex].synchronize do
+              @shared_info[:read_exception] = e
+              @shared_info[:cond_var].signal
+            end
+            break
+          end # begin/rescue
+        end # loop
+        Log.log.debug do
+          "#{LOG_WS_RECV}exception: #{@shared_info[:read_exception]},cls=#{@shared_info[:read_exception].class})"
+        end unless @shared_info[:read_exception].nil?
+        Log.log.debug{"#{LOG_WS_RECV}read thread stopped (ws eof=#{@ws_io.eof?})"}
       end
 
       def upload(transfer_spec)
+        # identify this session uniquely
+        session_id = SecureRandom.uuid
+        notify_progress(session_id: nil, type: :pre_start, info: 'starting')
         # total size of all files
-        total_size = 0
+        total_bytes_to_transfer = 0
         # we need to keep track of actual file path because transfer spec is modified to be sent in web socket
-        source_paths = []
+        files_to_read = []
         # get source root or nil
         source_root = transfer_spec.key?('source_root') && !transfer_spec['source_root'].empty? ? transfer_spec['source_root'] : nil
         # source root is ignored by GW, used only here
@@ -55,145 +159,122 @@ module Aspera
         # modify transfer spec to be suitable for GW
         transfer_spec['paths'].each do |item|
           # save actual file location to be able read contents later
-          full_src_filepath = item['source']
-          # add source root if needed
-          full_src_filepath = File.join(source_root, full_src_filepath) unless source_root.nil?
-          # GW expects a simple file name in 'source' but if user wants to change the name, we take it
-          item['source'] = File.basename(item['destination'].nil? ? item['source'] : item['destination'])
-          item['file_size'] = File.size(full_src_filepath)
-          total_size += item['file_size']
+          file_to_add = FauxFile.open(item['source'])
+          if file_to_add
+            item['source'] = file_to_add.path
+            item['file_size'] = file_to_add.size
+          else
+            file_to_add = item['source']
+            # add source root if needed
+            file_to_add = File.join(source_root, file_to_add) unless source_root.nil?
+            # GW expects a simple file name in 'source' but if user wants to change the name, we take it
+            item['source'] = File.basename(item['destination'].nil? ? item['source'] : item['destination'])
+            item['file_size'] = File.size(file_to_add)
+          end
           # save so that we can actually read the file later
-          source_paths.push(full_src_filepath)
+          files_to_read.push(file_to_add)
+          total_bytes_to_transfer += item['file_size']
         end
-        # identify this session uniquely
-        session_id = SecureRandom.uuid
-        @slice_uploads = 0
-        # web socket endpoint: by default use v2 (newer gateways), without base64 encoding
-        upload_api_version = V2_UPLOAD
-        # is the latest supported? else revert to old api
-        upload_api_version = V1_UPLOAD unless @api_info['endpoints'].any?{|i|i.include?(upload_api_version)}
-        Log.log.debug{"api version: #{upload_api_version}"}
-        url = File.join(@gw_api.params[:base_url], upload_api_version)
-        # uri = URI.parse(url)
+        upload_url = File.join(@gw_api.params[:base_url], @options[:api_version], 'upload')
+        notify_progress(session_id: nil, type: :pre_start, info: 'connecting wss')
         # open web socket to end point (equivalent to Net::HTTP.start)
-        http_socket = Rest.start_http_session(url)
-        @ws_io = http_socket.instance_variable_get(:@socket)
-        # @ws_io.debug_output = Log.log
-        @ws_handshake = ::WebSocket::Handshake::Client.new(url: url, headers: {})
+        http_session = Rest.start_http_session(upload_url)
+        # get the underlying socket i/o
+        @ws_io = Rest.io_http_session(http_session)
+        @ws_handshake = ::WebSocket::Handshake::Client.new(url: upload_url, headers: {})
         @ws_io.write(@ws_handshake.to_s)
         sleep(0.1)
         @ws_handshake << @ws_io.readuntil("\r\n\r\n")
         raise 'Error in websocket handshake' unless @ws_handshake.finished?
-        Log.log.debug('ws: handshake success')
+        Log.log.debug{"#{LOG_WS_SEND}handshake success"}
+        # start read thread after handshake
+        @ws_read_thread = Thread.new {process_read_thread}
+        notify_progress(session_id: session_id, type: :session_start)
+        notify_progress(session_id: session_id, type: :session_size, info: total_bytes_to_transfer)
+        sleep(1)
         # data shared between main thread and read thread
-        shared_info = {
+        @shared_info = {
           read_exception: nil, # error message if any in callback
-          end_uploads:    0 # number of files totally sent
-          # mutex: Mutex.new
-          # cond_var: ConditionVariable.new
+          count:          {
+            sent_general:          0,
+            received_general:      0,
+            sent_v2_delimiter:     0,
+            received_v2_delimiter: 0
+          },
+          mutex:          Mutex.new,
+          cond_var:       ConditionVariable.new
         }
-        # start read thread
-        ws_read_thread = Thread.new do
-          Log.log.debug('ws: thread: started')
-          frame = ::WebSocket::Frame::Incoming::Client.new
-          loop do
-            begin # rubocop:disable Style/RedundantBegin
-              frame << @ws_io.readuntil("\n")
-              while (msg = frame.next)
-                Log.log.debug{"ws: thread: message: #{msg.data} #{shared_info[:end_uploads]}"}
-                message = msg.data
-                if message.eql?(MSG_END_UPLOAD)
-                  shared_info[:end_uploads] += 1
-                elsif message.eql?(MSG_END_SLICE)
-                else
-                  message.chomp!
-                  error_message =
-                    if message.start_with?('"') && message.end_with?('"')
-                      JSON.parse(Base64.strict_decode64(message.chomp[1..-2]))['message']
-                    elsif message.start_with?('{') && message.end_with?('}')
-                      JSON.parse(message)['message']
-                    else
-                      "unknown message from gateway: [#{message}]"
-                    end
-                  raise error_message
-                end
-              end
-            rescue => e
-              shared_info[:read_exception] = e unless e.is_a?(EOFError)
-              break
-            end
-          end
-          Log.log.debug{"ws: thread: stopping (exc=#{shared_info[:read_exception]},cls=#{shared_info[:read_exception].class})"}
-        end
         # notify progress bar
-        notify_begin(session_id, total_size)
+        notify_progress(type: :session_size, session_id: session_id, info: total_bytes_to_transfer)
         # first step send transfer spec
-        Log.dump(:ws_spec, transfer_spec)
-        ws_snd_json(transfer_spec: transfer_spec)
+        Log.log.debug{Log.dump(:ws_spec, transfer_spec)}
+        ws_snd_json(MSG_SEND_TRANSFER_SPEC, transfer_spec)
         # current file index
         file_index = 0
         # aggregate size sent
-        sent_bytes = 0
-        # last progress event
-        last_progress_time = nil
-
+        session_sent_bytes = 0
+        # process each file
         transfer_spec['paths'].each do |item|
-          # TODO: get mime type?
-          file_mime_type = ''
-          file_size = item['file_size']
-          file_name = File.basename(item[item['destination'].nil? ? 'source' : 'destination'])
-          # compute total number of slices
-          slice_total = ((file_size - 1) / @options[:upload_chunk_size]) + 1
-          File.open(source_paths[file_index]) do |file|
-            # current slice index
-            slice_index = 0
+          slice_info = {
+            name:       nil,
+            # TODO: get mime type?
+            type:       'application/octet-stream',
+            size:       item['file_size'],
+            slice:      0, # current slice index
+            # index of last slice (i.e number of slices - 1)
+            last_slice: (item['file_size'] - 1) / @options[:upload_chunk_size],
+            fileIndex:  file_index
+          }
+          file = files_to_read[file_index]
+          if file.is_a?(FauxFile)
+            slice_info[:name] = file.path
+          else
+            file = File.open(file)
+            slice_info[:name] = File.basename(item[item['destination'].nil? ? 'source' : 'destination'])
+          end
+          begin
             until file.eof?
-              data = file.read(@options[:upload_chunk_size])
-              slice_data = {
-                name:         file_name,
-                type:         file_mime_type,
-                size:         file_size,
-                slice:        slice_index,
-                total_slices: slice_total,
-                fileIndex:    file_index
-              }
-              # Log.dump(:slice_data,slice_data) #if slice_index.eql?(0)
+              slice_bin_data = file.read(@options[:upload_chunk_size])
               # interrupt main thread if read thread failed
-              raise shared_info[:read_exception] unless shared_info[:read_exception].nil?
+              raise @shared_info[:read_exception] unless @shared_info[:read_exception].nil?
               begin
-                if upload_api_version.eql?(V1_UPLOAD)
-                  slice_data[:data] = Base64.strict_encode64(data)
-                  ws_snd_json(slice_upload: slice_data)
+                if @options[:api_version].eql?(API_V1)
+                  slice_info[:data] = Base64.strict_encode64(slice_bin_data)
+                  ws_snd_json(MSG_SEND_SLICE_UPLOAD, slice_info)
                 else
-                  ws_snd_json(slice_upload: slice_data) if slice_index.eql?(0)
-                  ws_send(data, type: :binary)
-                  Log.log.debug{"ws: sent buffer: #{file_index} / #{slice_index}"}
-                  ws_snd_json(slice_upload: slice_data) if slice_index.eql?(slice_total - 1)
+                  # send once, before data, at beginning
+                  ws_snd_json(MSG_SEND_SLICE_UPLOAD, slice_info) if slice_info[:slice].eql?(0)
+                  ws_send(ws_type: :binary, data: slice_bin_data)
+                  Log.log.debug{"#{LOG_WS_SEND}buffer: file: #{file_index}, slice: #{slice_info[:slice]}/#{slice_info[:last_slice]}"}
+                  # send once, after data, at end
+                  ws_snd_json(MSG_SEND_SLICE_UPLOAD, slice_info) if slice_info[:slice].eql?(slice_info[:last_slice])
                 end
               rescue Errno::EPIPE => e
-                raise shared_info[:read_exception] unless shared_info[:read_exception].nil?
+                raise @shared_info[:read_exception] unless @shared_info[:read_exception].nil?
+                raise e
+              rescue Net::ReadTimeout => e
+                Log.log.warn{'A timeout condition using HTTPGW may signal a permission problem on destination. Check ascp logs on httpgw.'}
                 raise e
               end
-              sent_bytes += data.length
-              current_time = Time.now
-              if last_progress_time.nil? || ((current_time - last_progress_time) > @options[:upload_bar_refresh_sec])
-                notify_progress(session_id, sent_bytes)
-                last_progress_time = current_time
-              end
-              slice_index += 1
+              session_sent_bytes += slice_bin_data.length
+              notify_progress(type: :transfer, session_id: session_id, info: session_sent_bytes)
+              slice_info[:slice] += 1
             end
+          ensure
+            file.close
           end
           file_index += 1
-        end
-
-        Log.log.debug('Finished upload')
-        ws_read_thread.join
-        Log.log.debug{"result: #{shared_info[:end_uploads]} / #{@slice_uploads}"}
-        ws_send(nil, type: :close) unless @ws_io.nil?
+        end # loop on files
+        # throttling may have skipped last one
+        notify_progress(type: :transfer, session_id: session_id, info: session_sent_bytes)
+        notify_progress(type: :end, session_id: session_id)
+        ws_send(ws_type: :close, data: nil)
+        Log.log.debug("Finished upload, waiting for end of #{THR_RECV} thread.")
+        @ws_read_thread.join
+        Log.log.debug{'Read thread joined'}
+        # session no more used
         @ws_io = nil
-        http_socket&.finish
-        notify_progress(session_id, sent_bytes)
-        notify_end(session_id)
+        http_session&.finish
       end
 
       def download(transfer_spec)
@@ -232,7 +313,7 @@ module Aspera
         raise 'GW URL must be set' if @gw_api.nil?
         raise 'paths: must be Array' unless transfer_spec['paths'].is_a?(Array)
         raise 'only token based transfer is supported in GW' unless transfer_spec['token'].is_a?(String)
-        Log.dump(:user_spec, transfer_spec)
+        Log.log.debug{Log.dump(:user_spec, transfer_spec)}
         transfer_spec['authentication'] ||= 'token'
         case transfer_spec['direction']
         when Fasp::TransferSpec::DIRECTION_SEND
@@ -247,32 +328,33 @@ module Aspera
       # wait for completion of all jobs started
       # @return list of :success or error message
       def wait_for_transfers_completion
+        # well ... transfer was done in "start"
         return [:success]
       end
 
-      # terminates monitor thread
-      def shutdown; end
-
+      # TODO: is that useful?
       def url=(api_url); end
 
       private
 
       def initialize(opts)
-        Log.log.debug{"local options= #{opts}"}
-        # set default options and override if specified
-        @options = DEFAULT_OPTIONS.dup
-        raise "httpgw agent parameters (transfer_info): expecting Hash, but have #{opts.class}" unless opts.is_a?(Hash)
-        opts.symbolize_keys.each do |k, v|
-          raise "httpgw agent parameter: Unknown: #{k}, expect one of #{DEFAULT_OPTIONS.keys.map(&:to_s).join(',')}" unless DEFAULT_OPTIONS.key?(k)
-          @options[k] = v
-        end
-        raise 'missing param: url' if @options[:url].nil?
-        # remove /v1 from end
+        super(opts)
+        @options = AgentBase.options(default: DEFAULT_OPTIONS, options: opts)
+        # remove /v1 from end of user-provided GW url: we need the base url only
         @options[:url].gsub(%r{/v1/*$}, '')
-        super()
         @gw_api = Rest.new({base_url: @options[:url]})
         @api_info = @gw_api.read('v1/info')[:data]
-        Log.log.info(@api_info.to_s)
+        Log.log.debug{Log.dump(:api_info, @api_info)}
+        # web socket endpoint: by default use v2 (newer gateways), without base64 encoding
+        # is the latest supported? else revert to old api
+        if !@options[:api_version].eql?(API_V1)
+          if !@api_info['endpoints'].any?{|i|i.include?(@options[:api_version])}
+            Log.log.warn{"API version #{@options[:api_version]} not supported, reverting to #{API_V1}"}
+            @options[:api_version] = API_V1
+          end
+        end
+        @options.freeze
+        Log.log.debug{Log.dump(:agent_options, @options)}
       end
     end # AgentHttpgw
   end

data/lib/aspera/fasp/agent_node.rb

@@ -1,32 +1,36 @@
 # frozen_string_literal: true
 
+# cspell:ignore precalc
 require 'aspera/fasp/agent_base'
 require 'aspera/fasp/transfer_spec'
 require 'aspera/node'
 require 'aspera/log'
-require 'tty-spinner'
+require 'aspera/oauth'
 
 module Aspera
   module Fasp
     # this singleton class is used by the CLI to provide a common interface to start a transfer
     # before using it, the use must set the `node_api` member.
     class AgentNode < Aspera::Fasp::AgentBase
+      DEFAULT_OPTIONS = {
+        url:      :required,
+        username: :required,
+        password: :required,
+        root_id:  nil
+      }.freeze
       # option include: root_id if the node is an access key
-      attr_writer :options
+      # attr_writer :options
 
-      def initialize(options)
-        raise 'node specification must be Hash' unless options.is_a?(Hash)
-        %i[url username password].each { |k| raise "missing parameter [#{k}] in node specification: #{options}" unless options.key?(k) }
-        super()
+      def initialize(opts)
+        raise 'node specification must be Hash' unless opts.is_a?(Hash)
+        super(opts)
+        options = AgentBase.options(default: DEFAULT_OPTIONS, options: opts)
         # root id is required for access key
         @root_id = options[:root_id]
         rest_params = { base_url: options[:url]}
-        if /^Bearer /.match?(options[:password])
-          rest_params[:headers] = {
-            Aspera::Node::HEADER_X_ASPERA_ACCESS_KEY => options[:username],
-            'Authorization'                          => options[:password]
-          }
+        if Oauth.bearer?(options[:password])
           raise 'root_id is required for access key' if @root_id.nil?
+          rest_params[:headers] = Aspera::Node.bearer_headers(options[:password], access_key: options[:username])
         else
           rest_params[:auth] = {
             type:     :basic,
@@ -37,6 +41,7 @@ module Aspera
         @node_api = Rest.new(rest_params)
         # TODO: currently only supports one transfer. This is bad shortcut. but ok for CLI.
         @transfer_id = nil
+        # Log.log.debug{Log.dump(:agent_options, @options)}
       end
 
       # used internally to ensure node api is set before using.
@@ -45,7 +50,7 @@ module Aspera
         return @node_api
       end
       # use this to read the node_api end point.
-      attr_reader :node_api
+      # attr_reader :node_api
 
       # use this to set the node_api end point before using the class.
       def node_api=(new_value)
@@ -94,43 +99,45 @@ module Aspera
 
       # generic method
       def wait_for_transfers_completion
-        started = false
-        spinner = nil
+        # set to true when we know the total size of the transfer
+        session_started = false
+        bytes_expected = nil
         # lets emulate management events to display progress bar
         loop do
           # status is empty sometimes with status 200...
-          transfer_data = node_api_.read("ops/transfers/#{@transfer_id}")[:data] || {'status' => 'unknown'} rescue {'status' => 'waiting(read error)'}
+          transfer_data = node_api_.read("ops/transfers/#{@transfer_id}")[:data] || {'status' => 'unknown'} rescue {'status' => 'waiting(api error)'}
           case transfer_data['status']
-          when 'completed'
-            notify_end(@transfer_id)
-            break
           when 'waiting', 'partially_completed', 'unknown', 'waiting(read error)'
-            if spinner.nil?
-              spinner = TTY::Spinner.new('[:spinner] :title', format: :classic)
-              spinner.start
-            end
-            spinner.update(title: transfer_data['status'])
-            spinner.spin
+            notify_progress(session_id: nil, type: :pre_start, info: transfer_data['status'])
           when 'running'
-            if !started && transfer_data['precalc'].is_a?(Hash) &&
+            if !session_started
+              notify_progress(session_id: @transfer_id, type: :session_start)
+              session_started = true
+            end
+            message = transfer_data['status']
+            message = "#{message} (#{transfer_data['error_desc']})" if !transfer_data['error_desc']&.empty?
+            notify_progress(session_id: nil, type: :pre_start, info: message)
+            if bytes_expected.nil? &&
+                transfer_data['precalc'].is_a?(Hash) &&
                 transfer_data['precalc']['status'].eql?('ready')
-              notify_begin(@transfer_id, transfer_data['precalc']['bytes_expected'])
-              started = true
-            else
-              notify_progress(@transfer_id, transfer_data['bytes_transferred'])
+              bytes_expected = transfer_data['precalc']['bytes_expected']
+              notify_progress(type: :session_size, session_id: @transfer_id, info: bytes_expected)
             end
+            notify_progress(type: :transfer, session_id: @transfer_id, info: transfer_data['bytes_transferred'])
+          when 'completed'
+            notify_progress(type: :transfer, session_id: @transfer_id, info: bytes_expected) if bytes_expected
+            notify_progress(type: :end, session_id: @transfer_id)
+            break
           when 'failed'
+            notify_progress(type: :end, session_id: @transfer_id)
             # Bug in HSTS ? transfer is marked failed, but there is no reason
-            if transfer_data['error_code'].eql?(0) && transfer_data['error_desc'].empty?
-              notify_end(@transfer_id)
-              break
-            end
+            break if transfer_data['error_code'].eql?(0) && transfer_data['error_desc'].empty?
             raise Fasp::Error, "status: #{transfer_data['status']}. code: #{transfer_data['error_code']}. description: #{transfer_data['error_desc']}"
           else
             Log.log.warn{"transfer_data -> #{transfer_data}"}
             raise Fasp::Error, "status: #{transfer_data['status']}. code: #{transfer_data['error_code']}. description: #{transfer_data['error_desc']}"
           end
-          sleep(1)
+          sleep(1.0)
         end
         # TODO: get status of sessions
         return []