aspera-cli 4.27.0 → 4.27.2

data/lib/aspera/agent/base.rb

@@ -28,11 +28,19 @@ module Aspera
         statuses = wait_for_transfers_completion
         @progress&.reset
         Aspera.assert_type(statuses, Array)
-        Aspera.assert(statuses.none?{ |i| !i.eql?(:success) && !i.is_a?(StandardError)}){"bad statuses content: #{statuses}"}
-        errors = statuses.reject{ |i| i.eql?(:success)}
+        Aspera.assert(statuses.none? { |i| !i.eql?(:success) && !i.is_a?(StandardError) }) { "bad statuses content: #{statuses}" }
+        errors = statuses.reject { |i| i.eql?(:success) }
         return errors.empty? ? Transfer::Result.success : Transfer::Result.error(errors.first)
       end
 
+      # Return the job_id of the last transfer submitted by this agent.
+      # In-process agents (direct, httpgw) override this to expose their internal job id.
+      # Remote-daemon agents do not need to override it: TransferAgent generates a UUID itself.
+      # @return [String, nil]
+      def last_job_id
+        nil
+      end
+
       private
 
       Aspera.require_method!(:start_transfer)

data/lib/aspera/agent/connect.rb

@@ -66,12 +66,12 @@ module Aspera
         @connect_settings = {
           'app_id' => SecureRandom.uuid
         }
-        Aspera.assert(Environment.instance.graphical?, type: Error){'Using connect requires a graphical environment'}
+        Aspera.assert(Environment.instance.graphical?, type: Error) { 'Using connect requires a graphical environment' }
         method_index = 0
         begin
           # raise exception if connect not started and file does not exist
           connect_url = self.class.connect_api_url
-          Log.log.debug{"found: #{connect_url}"}
+          Log.log.debug { "found: #{connect_url}" }
           @connect_api = Rest.new(
             base_url: "#{connect_url}/v5/connect", # could use v6 also now
             headers: {'Origin' => RestParameters.instance.user_agent}
@@ -80,11 +80,11 @@ module Aspera
           Log.log.debug('Connect was reached') if method_index > 0
           Log.dump(:connect_version, connect_info)
         rescue StandardError => e # Errno::ECONNREFUSED
-          Log.log.debug{"Exception: #{e}"}
+          Log.log.debug { "Exception: #{e}" }
           start_url = CONNECT_START_URIS[method_index]
           method_index += 1
-          Aspera.assert(!start_url.nil?){"Unable to start connect #{method_index} times"}
-          Log.log.warn{"Aspera Connect is not started (#{e}). Trying to start it ##{method_index}..."}
+          Aspera.assert(!start_url.nil?) { "Unable to start connect #{method_index} times" }
+          Log.log.warn { "Aspera Connect is not started (#{e}). Trying to start it ##{method_index}..." }
           Environment.instance.open_uri_graphical(start_url)
           sleep(SLEEP_SEC_BETWEEN_RETRY)
           retry
@@ -99,7 +99,7 @@ module Aspera
       # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
         if transfer_spec['direction'] == 'send'
-          Log.log.warn{"Connect requires upload selection using GUI, ignoring #{transfer_spec['paths']}".red}
+          Log.log.warn { "Connect requires upload selection using GUI, ignoring #{transfer_spec['paths']}".red }
           transfer_spec.delete('paths')
           selection = @connect_api.create('windows/select-open-file-dialog/', {
             'aspera_connect_settings' => @connect_settings,
@@ -108,7 +108,7 @@ module Aspera
             'allowMultipleSelection'  => true,
             'allowedFileTypes'        => ''
           })
-          transfer_spec['paths'] = selection['dataTransfer']['files'].map{ |i| {'source' => i['name']}}
+          transfer_spec['paths'] = selection['dataTransfer']['files'].map { |i| {'source' => i['name']} }
         end
         # if there is a token, we ask connect client to use well known ssh private keys
         # instead of asking password

data/lib/aspera/agent/desktop.rb

@@ -65,7 +65,7 @@ module Aspera
         @application_id = SecureRandom.uuid
         @transfer_id = nil
         super
-        Aspera.assert(Environment.instance.graphical?, type: Error){'Using client requires a graphical environment'}
+        Aspera.assert(Environment.instance.graphical?, type: Error) { 'Using client requires a graphical environment' }
         method_index = 0
         begin
           # curl 'http://127.0.0.1:33024/' -X POST -H 'content-type: application/json' --data-raw '{"jsonrpc":"2.0","params":[],"id":999999,"method":"rpc.discover"}'
@@ -77,8 +77,8 @@ module Aspera
         rescue Errno::ECONNREFUSED => e
           start_url = START_URIS[method_index]
           method_index += 1
-          Aspera.assert(!start_url.nil?){"Unable to start #{Products::Desktop::APP_NAME} #{method_index} times"}
-          Log.log.warn{"#{Products::Desktop::APP_NAME} is not started (#{e}). Trying to start it ##{method_index}..."}
+          Aspera.assert(!start_url.nil?) { "Unable to start #{Products::Desktop::APP_NAME} #{method_index} times" }
+          Log.log.warn { "#{Products::Desktop::APP_NAME} is not started (#{e}). Trying to start it ##{method_index}..." }
           Environment.instance.open_uri_graphical(start_url)
           sleep(SLEEP_SEC_BETWEEN_RETRY)
           retry

data/lib/aspera/agent/direct.rb

@@ -19,6 +19,30 @@ module Aspera
   module Agent
     # Execute a local `ascp` and use its management port to monitor progress
     class Direct < Base
+      class << self
+        # Re-query the status of a direct transfer that was started in-process.
+        # Only works if the same Ruby process is still alive (e.g. MCP mode).
+        # agent_params must contain '_agent_ref' pointing to the live Direct instance.
+        # @param transfer_id  [String] job_id returned by start_transfer / last_job_id
+        # @param agent_params [Hash]   connection parameters; '_agent_ref' is the live agent
+        # @return [Hash] status hash with at least 'status' key
+        def transfer_status(transfer_id, agent_params)
+          agent = agent_params['_agent_ref']
+          return {'status' => 'unknown', 'note' => 'direct agent not available (different process?)'} if agent.nil?
+          sessions = agent.sessions_by_job(transfer_id)
+          return {'status' => 'unknown', 'note' => "no sessions found for job #{transfer_id}"} if sessions.empty?
+          errors  = sessions.filter_map { |s| s[:error] }
+          running = sessions.any? { |s| s[:thread]&.alive? }
+          if errors.any?
+            {'status' => 'failed', 'error' => errors.first.message}
+          elsif running
+            {'status' => 'running'}
+          else
+            {'status' => 'completed'}
+          end
+        end
+      end
+
       # `ascp` started locally, so listen local
       LISTEN_LOCAL_ADDRESS = '127.0.0.1'
       # 0 means: use any available port
@@ -75,7 +99,7 @@ module Aspera
         @multi_incr_udp = multi_incr_udp.nil? ? Environment.instance.os.eql?(Environment::OS_WINDOWS) : multi_incr_udp
         @monitor = monitor
         @management_cb = management_cb
-        Aspera.assert_type(resume, Hash){'resume'}
+        Aspera.assert_type(resume, Hash) { 'resume' }
         @resume_policy = Transfer::Resumer.new(**resume.symbolize_keys)
         # all transfer jobs, key = SecureRandom.uuid, protected by mutex, cond var on change
         @sessions = []
@@ -101,7 +125,7 @@ module Aspera
           # using a non unique id results in discard of tags in AoC, and a package is never finalized
           # all sessions in a multi-session transfer must have the same xfer_id (see admin manual)
           transfer_spec['tags'][Transfer::Spec::TAG_RESERVED]['xfer_id'] ||= SecureRandom.uuid
-          Log.log.debug{"xfer id=#{transfer_spec['xfer_id']}"}
+          Log.log.debug { "xfer id=#{transfer_spec['xfer_id']}" }
           # TODO: useful ? node only ? seems to be a timeout for retry in node
           transfer_spec['tags'][Transfer::Spec::TAG_RESERVED]['xfer_retry'] ||= 3600
         end
@@ -115,7 +139,7 @@ module Aspera
             count: transfer_spec.delete('multi_session').to_i
           }
           if multi_session_info[:count].negative?
-            Log.log.error{"multi_session(#{transfer_spec['multi_session']}) shall be integer >= 0"}
+            Log.log.error { "multi_session(#{transfer_spec['multi_session']}) shall be integer >= 0" }
             multi_session_info = nil
           elsif multi_session_info[:count].eql?(0)
             Log.log.debug('multi_session count is zero: no multi session')
@@ -145,7 +169,7 @@ module Aspera
         if multi_session_info.nil?
           Log.log.debug('Starting single session thread')
           # single session for transfer : simple
-          session[:thread] = Thread.new{transfer_thread_entry(session)}
+          session[:thread] = Thread.new { transfer_thread_entry(session) }
           @sessions.push(session)
         else
           Log.log.debug('Starting multi session threads')
@@ -161,13 +185,18 @@ module Aspera
             # option: increment (default as per ascp manual) or not (cluster on other side ?)
             exec_spec.args.unshift('-O', (multi_session_info[:udp_base] + i - 1).to_s) if @multi_incr_udp
             # finally start the thread
-            this_session[:thread] = Thread.new{transfer_thread_entry(this_session)}
+            this_session[:thread] = Thread.new { transfer_thread_entry(this_session) }
             @sessions.push(this_session)
           end
         end
         return session[:job_id]
       end
 
+      # @return [String, nil] job_id of the last submitted transfer
+      def last_job_id
+        @sessions.last&.dig(:job_id)
+      end
+
       # wait for completion of all jobs started
       # @return [Array] list of :success or error message
       def wait_for_transfers_completion
@@ -175,7 +204,7 @@ module Aspera
         # set to non-nil to exit loop
         result = []
         @sessions.each do |session|
-          Log.log.debug{"join #{session[:thread]}"}
+          Log.log.debug { "join #{session[:thread]}" }
           session[:thread].join
           result.push(session[:error] || :success)
         end
@@ -194,7 +223,7 @@ module Aspera
       # @param id [String] Transfer session identifier
       # @return [Array] list of sessions for a job
       def sessions_by_job(id)
-        @sessions.select{ |session| session[:job_id].eql?(id)}
+        @sessions.select { |session| session[:job_id].eql?(id) }
       end
 
       # Send command to management port of command (used in `asession).
@@ -224,7 +253,7 @@ module Aspera
         begin
           # set name for logging
           Thread.current[:name] = 'transfer'
-          Log.log.debug{"ENTER (#{Thread.current[:name]})"}
+          Log.log.debug { "ENTER (#{Thread.current[:name]})" }
           # start transfer with selected resumer policy
           @resume_policy.execute_with_resume do
             start_and_monitor_process(session: session, exec_spec: session[:exec_spec])
@@ -234,7 +263,7 @@ module Aspera
           session[:error] = e
           raise if Log.log.debug? || !e.is_a?(Transfer::Error)
         end
-        Log.log.debug{"EXIT (#{Thread.current[:name]})"}
+        Log.log.debug { "EXIT (#{Thread.current[:name]})" }
       end
 
       public
@@ -293,7 +322,7 @@ module Aspera
           return unless @monitor
           # TODO: timeout does not work when Process.spawn is used... until process exits, then it works
           # So we use select to detect that anything happens on the socket (connection)
-          Log.log.debug{"before select, timeout: #{@spawn_timeout_sec}"}
+          Log.log.debug { "before select, timeout: #{@spawn_timeout_sec}" }
           readable, _, _ = IO.select([mgt_server_socket], nil, nil, @spawn_timeout_sec)
           Log.log.debug('after select, before accept')
           Aspera.assert(readable, 'timeout waiting mgt port connect (select not readable)', type: Transfer::Error)
@@ -322,17 +351,17 @@ module Aspera
               commands = JSON.parse(File.read(@command_file))
               send_command(commands)
             rescue => e
-              Log.log.error{e.to_s}
+              Log.log.error { e.to_s }
             end
             File.delete(@command_file)
           end
           Log.log.debug('management io closed')
           # check that last status was received before process exit
           last_event = processor.last_event
-          Aspera.assert_type(last_event, Hash, type: Transfer::Error){'management event'}
+          Aspera.assert_type(last_event, Hash, type: Transfer::Error) { 'management event' }
           case last_event['Type']
           when 'DONE'
-            Log.log.trace1{'Graceful shutdown, DONE message received'}
+            Log.log.trace1 { 'Graceful shutdown, DONE message received' }
           when 'ERROR'
             if /bearer token/i.match?(last_event['Description']) &&
                 session[:token_regenerator].respond_to?(:refreshed_transfer_token)
@@ -342,7 +371,7 @@ module Aspera
               env['ASPERA_SCP_TOKEN'] = session[:token_regenerator].refreshed_transfer_token
             end
             raise Transfer::Error.new(last_event['Description'], code: last_event['Code'].to_i)
-          else Aspera.error_unexpected_value(last_event['Type'], :error){'last event type'}
+          else Aspera.error_unexpected_value(last_event['Type'], :error) { 'last event type' }
           end
         rescue SystemCallError => e
           # Process.spawn failed, or socket error
@@ -361,11 +390,11 @@ module Aspera
               # process stderr of ascp
               stderr_flag = false
               stderr_r.each_line do |line|
-                Log.log.error{"BEGIN stderr #{exec}"} unless stderr_flag
-                Log.log.error{line.chomp}
+                Log.log.error { "BEGIN stderr #{exec}" } unless stderr_flag
+                Log.log.error { line.chomp }
                 stderr_flag = true
               end
-              Log.log.error{"END stderr #{exec}"} if stderr_flag
+              Log.log.error { "END stderr #{exec}" } if stderr_flag
               stderr_r.close
             end
             # status is nil if an exception occurred before starting command
@@ -412,12 +441,12 @@ module Aspera
         when 'SESSION'
         when 'ARGSTOP'
         when 'FILEERROR'
-          Log.log.error{"#{event['Type']} #{event['Description']}"}
+          Log.log.error { "#{event['Type']} #{event['Description']}" }
         when 'STOP'
           # cspell:enable
           # stop event when one file is completed
         else
-          Log.log.debug{"Unknown event type for progress: #{event['Type']}"}
+          Log.log.debug { "Unknown event type for progress: #{event['Type']}" }
         end
       end
     end

data/lib/aspera/agent/factory.rb

@@ -24,9 +24,9 @@ module Aspera
       # Available agents: :long : Capitalized name string, :short : single character symbol
       ALL =
         Dir.children(File.dirname(File.expand_path(__FILE__)))
-          .select{ |file| file.end_with?(Environment::RB_EXT)}
-          .map{ |file| File.basename(file, Environment::RB_EXT).to_sym}
-          .reject{ |item| IGNORED_ITEMS.include?(item)}.to_h do |agent_sym|
+          .select { |file| file.end_with?(Environment::RB_EXT) }
+          .map { |file| File.basename(file, Environment::RB_EXT).to_sym }
+          .reject { |item| IGNORED_ITEMS.include?(item) }.to_h do |agent_sym|
           [agent_sym, {
             long:  agent_sym.to_s.capitalize,
             short: agent_sym.eql?(:direct) ? :a : agent_sym.to_s[0].to_sym

data/lib/aspera/agent/httpgw.rb

@@ -5,10 +5,32 @@ require 'aspera/transfer/spec'
 require 'aspera/api/httpgw'
 require 'aspera/log'
 require 'aspera/assert'
+require 'securerandom'
 
 module Aspera
   module Agent
     class Httpgw < Base
+      class << self
+        # Re-query the status of an httpgw transfer that was started in-process.
+        # Only works if the same Ruby process is still alive (e.g. MCP mode).
+        # agent_params must contain '_agent_ref' pointing to the live Httpgw instance.
+        # @param transfer_id  [String] job_id returned by last_job_id
+        # @param agent_params [Hash]   '_agent_ref' is the live agent instance
+        # @return [Hash] status hash with at least 'status' key
+        def transfer_status(transfer_id, agent_params)
+          agent = agent_params['_agent_ref']
+          return {'status' => 'unknown', 'note' => 'httpgw agent not available (different process?)'} if agent.nil?
+          return {'status' => 'unknown', 'note' => 'no transfer started'} if agent.instance_variable_get(:@transfer_thread).nil?
+          if agent.instance_variable_get(:@transfer_thread).alive?
+            {'status' => 'running'}
+          elsif (err = agent.instance_variable_get(:@transfer_error))
+            {'status' => 'failed', 'error' => err.message}
+          else
+            {'status' => 'completed'}
+          end
+        end
+      end
+
       def initialize(
         url:,
         api_version: Api::Httpgw::API_V2,
@@ -23,34 +45,53 @@ module Aspera
           api_version:       api_version,
           upload_chunk_size: upload_chunk_size,
           synchronous:       synchronous,
-          notify_cb:         ->(*pa, **ka){notify_progress(*pa, **ka)}
+          notify_cb:         ->(*pa, **ka) { notify_progress(*pa, **ka) }
         )
+        @last_job_id = nil
+        @transfer_thread = nil
+        @transfer_error  = nil
       end
 
-      # Start FASP transfer based on transfer spec (hash table)
-      # note that this should be asynchronous, but it is not
-      # HTTP download only supports file list
+      # Start FASP transfer based on transfer spec (hash table).
+      # Non-blocking: the actual upload/download runs in a dedicated thread.
+      # HTTP download only supports file list.
       # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
         Aspera.assert(!@gw_api.nil?, 'GW URL must be set')
-        Aspera.assert_type(transfer_spec['paths'], Array){'paths'}
-        Aspera.assert_type(transfer_spec['token'], String){'only token based transfer is supported in GW'}
+        Aspera.assert_type(transfer_spec['paths'], Array) { 'paths' }
+        Aspera.assert_type(transfer_spec['token'], String) { 'only token based transfer is supported in GW' }
         Log.dump(:user_spec, transfer_spec)
         transfer_spec['authentication'] ||= 'token'
+        @last_job_id     = SecureRandom.uuid
+        @transfer_error  = nil
+        @transfer_thread = Thread.new { run_transfer(transfer_spec) }
+        @last_job_id
+      end
+
+      # Wait for the transfer thread to complete.
+      # @return [Array] list of :success or error
+      def wait_for_transfers_completion
+        @transfer_thread&.join
+        return [@transfer_error || :success]
+      end
+
+      # @return [String, nil] job_id of the last submitted transfer
+      attr_reader :last_job_id
+
+      private
+
+      # Execute the actual transfer (runs inside the transfer thread).
+      def run_transfer(transfer_spec)
         case transfer_spec['direction']
         when Transfer::Spec::DIRECTION_SEND
           @gw_api.upload(transfer_spec)
         when Transfer::Spec::DIRECTION_RECEIVE
           @gw_api.download(transfer_spec)
-        else Aspera.error_unexpected_value(transfer_spec['direction']){'direction'}
+        else Aspera.error_unexpected_value(transfer_spec['direction']) { 'direction' }
         end
-      end
-
-      # Wait for completion of all jobs started
-      # @return [Array] list of :success or error message
-      def wait_for_transfers_completion
-        # well ... transfer was done in "start"
-        return [:success]
+      rescue => e
+        @transfer_error = e
+        Log.log.error { "httpgw transfer thread error: #{e}" }
       end
     end
   end

data/lib/aspera/agent/node.rb

@@ -95,7 +95,7 @@ module Aspera
         transfer_spec['remote_host'] = '127.0.0.1' if !transfer_spec['wss_enabled'] && transfer_spec['remote_host'].eql?(URI.parse(node_api_.base_url).host)
         resp = node_api_.create('ops/transfers', transfer_spec)
         @transfer_id = resp['id']
-        Log.log.debug{"tr_id=#{@transfer_id}"}
+        Log.log.debug { "tr_id=#{@transfer_id}" }
         return @transfer_id
       end
 
@@ -137,7 +137,7 @@ module Aspera
             # Bug in HSTS ? transfer is marked failed, but there is no reason
             break if transfer_data['error_code'].eql?(0) && transfer_data['error_desc'].empty?
             raise Transfer::Error, "status: #{transfer_data['status']}. code: #{transfer_data['error_code']}. description: #{transfer_data['error_desc']}"
-          else Aspera.error_unexpected_value(transfer_data['status']){"transfer_data -> #{transfer_data}"}
+          else Aspera.error_unexpected_value(transfer_data['status']) { "transfer_data -> #{transfer_data}" }
           end
           sleep(1.0)
         end

data/lib/aspera/agent/transferd.rb

@@ -66,7 +66,7 @@ module Aspera
         @transfer_id = nil
         @stop = stop
         is_local_auto_port = url.eql?(AUTO_LOCAL_TCP_PORT)
-        Aspera.assert(!(is_local_auto_port && (!@stop || !start)), type: Error){'Cannot set options `stop` or `start` to false with port zero'}
+        Aspera.assert(!(is_local_auto_port && (!@stop || !start)), type: Error) { 'Cannot set options `stop` or `start` to false with port zero' }
         # keep PID for optional shutdown
         @daemon_pid = nil
         @daemon_endpoint = nil
@@ -81,18 +81,18 @@ module Aspera
           # Initiate actual connection
           get_info_response = @transfer_client.get_info(::Transferd::Api::InstanceInfoRequest.new)
           @daemon_endpoint = daemon_endpoint
-          Log.log.debug{"Daemon info: #{get_info_response}"}
+          Log.log.debug { "Daemon info: #{get_info_response}" }
           Log.log.warn('Attached to existing daemon') unless @daemon_pid || !start || !@stop
-          at_exit{shutdown}
+          at_exit { shutdown }
         rescue GRPC::Unavailable => e
           # if transferd is external: do not start it, or other error
           raise if !start || !e.message.include?('failed to connect')
           # we already tried to start a daemon, but it failed
-          Aspera.assert(@daemon_pid.nil?){"Daemon started with PID #{@daemon_pid}, but connection failed to #{daemon_endpoint}"}
+          Aspera.assert(@daemon_pid.nil?) { "Daemon started with PID #{@daemon_pid}, but connection failed to #{daemon_endpoint}" }
           Log.log.warn('no daemon present, starting daemon...') if !start
           # transferd only supports local ip and port
           daemon_uri = URI.parse("ipv4://#{daemon_endpoint}")
-          Aspera.assert(daemon_uri.scheme.eql?('ipv4')){"Invalid scheme daemon URI #{daemon_endpoint}"}
+          Aspera.assert(daemon_uri.scheme.eql?('ipv4')) { "Invalid scheme daemon URI #{daemon_endpoint}" }
           # create a config file for daemon
           config = {
             address:      daemon_uri.host,
@@ -107,7 +107,7 @@ module Aspera
           }
           # config file and logs are created in same folder
           transferd_base_tmp = TempFileManager.instance.new_file_path_global('transferd')
-          Log.log.debug{"transferd base tmp #{transferd_base_tmp}"}
+          Log.log.debug { "transferd base tmp #{transferd_base_tmp}" }
           conf_file = "#{transferd_base_tmp}.conf"
           log_stdout = "#{transferd_base_tmp}.out"
           log_stderr = "#{transferd_base_tmp}.err"
@@ -128,9 +128,9 @@ module Aspera
           rescue Timeout::Error
             nil
           end
-          Log.log.debug{"Daemon started with pid #{@daemon_pid}"}
+          Log.log.debug { "Daemon started with pid #{@daemon_pid}" }
           Process.detach(@daemon_pid) unless @stop
-          at_exit{shutdown}
+          at_exit { shutdown }
           # update port for next connection attempt (if auto high port was requested)
           daemon_endpoint = "#{LOCAL_SOCKET_ADDR}#{PORT_SEP}#{Products::Transferd.daemon_port_from_log(log_stdout)}" if is_local_auto_port
           # local daemon started, try again
@@ -152,10 +152,10 @@ module Aspera
         ) # transfer definition
         # send start transfer request to the transfer manager daemon
         start_response = @transfer_client.start_transfer(transfer_request)
-        Aspera.assert(!start_response.status.eql?(:FAILED), type: Transfer::Error){start_response.error.description}
-        Log.log.debug{"start transfer response #{start_response}"}
+        Aspera.assert(!start_response.status.eql?(:FAILED), type: Transfer::Error) { start_response.error.description }
+        Log.log.debug { "start transfer response #{start_response}" }
         @transfer_id = start_response.transferId
-        Log.log.debug{"transfer started with id #{@transfer_id}"}
+        Log.log.debug { "transfer started with id #{@transfer_id}" }
       end
 
       def wait_for_transfers_completion
@@ -190,7 +190,7 @@ module Aspera
           when :QUEUED, :UNKNOWN_STATUS, :PAUSED, :ORPHANED
             notify_progress(:sessions_init, info: response.status.to_s.downcase)
           else
-            Log.log.error{"unknown status#{response.status}"}
+            Log.log.error { "unknown status#{response.status}" }
           end
         end
         # TODO: return status