aspera-cli 4.9.0 → 4.11.0

data/lib/aspera/fasp/agent_httpgw.rb

@@ -4,8 +4,8 @@ require 'aspera/fasp/agent_base'
 require 'aspera/fasp/transfer_spec'
 require 'aspera/log'
 require 'aspera/rest'
-require 'websocket-client-simple'
 require 'securerandom'
+require 'websocket'
 require 'base64'
 require 'json'
 
@@ -13,16 +13,32 @@ require 'json'
 # 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
-    class AgentHttpgw < AgentBase
+    # start a transfer using Aspera HTTP Gateway, using web socket session for uploads
+    class AgentHttpgw < Aspera::Fasp::AgentBase
       # message returned by HTTP GW in case of success
-      OK_MESSAGE = 'end upload'
-      # refresh rate for progress
-      UPLOAD_REFRESH_SEC = 0.5
-      private_constant :OK_MESSAGE,:UPLOAD_REFRESH_SEC
+      MSG_END_UPLOAD = 'end upload'
+      MSG_END_SLICE = 'end_slice_upload'
+      DEFAULT_OPTIONS = {
+        url:                    nil,
+        upload_chunksize:       64_000,
+        upload_bar_refresh_sec: 0.5
+      }.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
+
       # send message on http gw web socket
-      def ws_send(ws,type,data)
-        ws.send(JSON.generate({type => data}))
+      def ws_snd_json(data)
+        @slice_uploads += 1 if data.key?(:slice_upload)
+        Log.log.debug{JSON.generate(data)}
+        ws_send(JSON.generate(data))
+      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)
       end
 
       def upload(transfer_spec)
@@ -31,7 +47,7 @@ module Aspera
         # we need to keep track of actual file path because transfer spec is modified to be sent in web socket
         source_paths = []
         # get source root or nil
-        source_root = transfer_spec.has_key?('source_root') && !transfer_spec['source_root'].empty? ? transfer_spec['source_root'] : 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
         transfer_spec.delete('source_root')
         # compute total size of files to upload (for progress)
@@ -40,7 +56,7 @@ module Aspera
           # 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?
+          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)
@@ -48,93 +64,134 @@ module Aspera
           # save so that we can actually read the file later
           source_paths.push(full_src_filepath)
         end
-
+        # identify this session uniquely
         session_id = SecureRandom.uuid
-        ws = ::WebSocket::Client::Simple::Client.new
-        # error message if any in callback
-        error = nil
-        # number of files totally sent
-        received = 0
-        # setup callbacks on websocket
-        ws.on(:message) do |msg|
-          Log.log.info("ws: message: #{msg.data}")
-          message = msg.data
-          if message.eql?(OK_MESSAGE)
-            received += 1
-          else
-            message.chomp!
-            error =
-              if message.start_with?('"') && message.end_with?('"')
-                JSON.parse(Base64.strict_decode64(message.chomp[1..-2]))['message']
-              else
-                "expecting quotes in [#{message}]"
+        @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)
+        # 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: {})
+        @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')
+        # data shared between main thread and read thread
+        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
+        }
+        # 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
-        end
-        ws.on(:error) do |e|
-          error = e
-        end
-        ws.on(:open) do
-          Log.log.info('ws: open')
-        end
-        ws.on(:close) do
-          Log.log.info('ws: close')
-        end
-        # open web socket to end point
-        ws.connect("#{@gw_api.params[:base_url]}/upload")
-        # async wait ready
-        while !ws.open? && error.nil?
-          Log.log.info('ws: wait')
-          sleep(0.2)
+          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_begin(session_id, total_size)
         # first step send transfer spec
-        Log.dump(:ws_spec,transfer_spec)
-        ws_send(ws,:transfer_spec,transfer_spec)
+        Log.dump(:ws_spec, transfer_spec)
+        ws_snd_json(transfer_spec: transfer_spec)
         # current file index
         file_index = 0
         # aggregate size sent
         sent_bytes = 0
         # last progress event
-        lastevent = nil
+        last_progress_time = nil
+
         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
-          numslices = 1 + ((file_size - 1) / @upload_chunksize)
+          numslices = ((file_size - 1) / @options[:upload_chunksize]) + 1
           File.open(source_paths[file_index]) do |file|
             # current slice index
             slicenum = 0
-            while !file.eof?
-              data = file.read(@upload_chunksize)
+            until file.eof?
+              data = file.read(@options[:upload_chunksize])
               slice_data = {
                 name:         file_name,
                 type:         file_mime_type,
                 size:         file_size,
-                data:         Base64.strict_encode64(data),
                 slice:        slicenum,
                 total_slices: numslices,
                 fileIndex:    file_index
               }
-              # log without data
-              Log.dump(:slide_data,slice_data.keys.each_with_object({}){|i,m|m[i] = i.eql?(:data) ? 'base64 data' : slice_data[i];}) if slicenum.eql?(0)
-              ws_send(ws,:slice_upload, slice_data)
+              # Log.dump(:slice_data,slice_data) #if slicenum.eql?(0)
+              # interrupt main thread if read thread failed
+              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)
+                else
+                  ws_snd_json(slice_upload: slice_data) if slicenum.eql?(0)
+                  ws_send(data, type: :binary)
+                  Log.log.debug{"ws: sent buffer: #{file_index} / #{slicenum}"}
+                  ws_snd_json(slice_upload: slice_data) if slicenum.eql?(numslices - 1)
+                end
+              rescue Errno::EPIPE => e
+                raise shared_info[:read_exception] unless shared_info[:read_exception].nil?
+                raise e
+              end
               sent_bytes += data.length
               currenttime = Time.now
-              if lastevent.nil? || ((currenttime - lastevent) > UPLOAD_REFRESH_SEC)
-                notify_progress(session_id,sent_bytes)
-                lastevent = currenttime
+              if last_progress_time.nil? || ((currenttime - last_progress_time) > @options[:upload_bar_refresh_sec])
+                notify_progress(session_id, sent_bytes)
+                last_progress_time = currenttime
               end
               slicenum += 1
-              raise error unless error.nil?
             end
           end
           file_index += 1
         end
-        ws.close
+
+        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?
+        @ws_io = nil
+        http_socket&.finish
+        notify_progress(session_id, sent_bytes)
         notify_end(session_id)
       end
 
@@ -142,18 +199,18 @@ module Aspera
         transfer_spec['zip_required'] ||= false
         transfer_spec['source_root'] ||= '/'
         # is normally provided by application, like package name
-        if !transfer_spec.has_key?('download_name')
+        if !transfer_spec.key?('download_name')
           # by default it is the name of first file
           dname = File.basename(transfer_spec['paths'].first['source'])
           # we remove extension
-          dname = dname.gsub(/\.@gw_api.*$/,'')
+          dname = dname.gsub(/\.@gw_api.*$/, '')
           # ands add indication of number of files if there is more than one
           if transfer_spec['paths'].length > 1
             dname += " #{transfer_spec['paths'].length} Files"
           end
           transfer_spec['download_name'] = dname
         end
-        creation = @gw_api.create('download',{'transfer_spec' => transfer_spec})[:data]
+        creation = @gw_api.create('v1/download', {'transfer_spec' => transfer_spec})[:data]
         transfer_uuid = creation['url'].split('/').last
         file_dest =
           if transfer_spec['zip_required'] || transfer_spec['paths'].length > 1
@@ -163,19 +220,18 @@ module Aspera
             # it is a plain file if we don't require zip and there is only one file
             File.basename(transfer_spec['paths'].first['source'])
           end
-        file_dest = File.join(transfer_spec['destination_root'],file_dest)
-        @gw_api.call({operation: 'GET',subpath: "download/#{transfer_uuid}",save_to_file: file_dest})
+        file_dest = File.join(transfer_spec['destination_root'], file_dest)
+        @gw_api.call({operation: 'GET', subpath: "v1/download/#{transfer_uuid}", save_to_file: file_dest})
       end
 
       # start FASP transfer based on transfer spec (hash table)
       # note that it is asynchronous
       # HTTP download only supports file list
-      def start_transfer(transfer_spec,options={})
+      def start_transfer(transfer_spec)
         raise 'GW URL must be set' if @gw_api.nil?
-        raise 'option: must be hash (or nil)' unless options.is_a?(Hash)
         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.dump(:user_spec, transfer_spec)
         transfer_spec['authentication'] ||= 'token'
         case transfer_spec['direction']
         when Fasp::TransferSpec::DIRECTION_SEND
@@ -200,15 +256,22 @@ module Aspera
 
       private
 
-      def initialize(params)
-        raise 'params must be Hash' unless params.is_a?(Hash)
-        params = params.symbolize_keys
-        raise 'must have only one param: url' unless params.keys.eql?([:url])
+      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
+        @options[:url].gsub(%r{/v1/*$}, '')
         super()
-        @gw_api = Rest.new({base_url: params[:url]})
-        api_info = @gw_api.read('info')[:data]
-        Log.log.info(api_info.to_s)
-        @upload_chunksize = 128_000 # TODO: configurable ?
+        @gw_api = Rest.new({base_url: @options[:url]})
+        @api_info = @gw_api.read('v1/info')[:data]
+        Log.log.info(@api_info.to_s)
       end
     end # AgentHttpgw
   end

data/lib/aspera/fasp/agent_node.rb

@@ -2,6 +2,7 @@
 
 require 'aspera/fasp/agent_base'
 require 'aspera/fasp/transfer_spec'
+require 'aspera/node'
 require 'aspera/log'
 require 'tty-spinner'
 
@@ -9,20 +10,21 @@ 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 < AgentBase
+    class AgentNode < Aspera::Fasp::AgentBase
       # option include: root_id if the node is an access key
       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.has_key?(k) }
+        %i[url username password].each { |k| raise "missing parameter [#{k}] in node specification: #{options}" unless options.key?(k) }
         super()
         # 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] = {
-            'X-Aspera-AccessKey' => options[:username],
-            'Authorization'      => options[:password]
+            Aspera::Node::X_ASPERA_ACCESSKEY => options[:username],
+            'Authorization'                  => options[:password]
           }
           raise 'root_id is required for access key' if @root_id.nil?
         else
@@ -39,7 +41,7 @@ module Aspera
 
       # used internally to ensure node api is set before using.
       def node_api_
-        raise StandardError,'Before using this object, set the node_api attribute to a Aspera::Rest object' if @node_api.nil?
+        raise StandardError, 'Before using this object, set the node_api attribute to a Aspera::Rest object' if @node_api.nil?
         return @node_api
       end
       # use this to read the node_api end point.
@@ -54,7 +56,7 @@ module Aspera
       end
 
       # generic method
-      def start_transfer(transfer_spec,_options=nil)
+      def start_transfer(transfer_spec)
         # add root id if access key
         if !@root_id.nil?
           case transfer_spec['direction']
@@ -64,9 +66,9 @@ module Aspera
           end
         end
         # manage special additional parameter
-        if transfer_spec.has_key?('EX_ssh_key_paths') && transfer_spec['EX_ssh_key_paths'].is_a?(Array) && !transfer_spec['EX_ssh_key_paths'].empty?
+        if transfer_spec.key?('EX_ssh_key_paths') && transfer_spec['EX_ssh_key_paths'].is_a?(Array) && !transfer_spec['EX_ssh_key_paths'].empty?
           # not standard, so place standard field
-          if transfer_spec.has_key?('ssh_private_key')
+          if transfer_spec.key?('ssh_private_key')
             Log.log.warn('Both ssh_private_key and EX_ssh_key_paths are present, using ssh_private_key')
           else
             Log.log.warn('EX_ssh_key_paths has multiple keys, using first one only') unless transfer_spec['EX_ssh_key_paths'].length.eql?(1)
@@ -77,13 +79,13 @@ module Aspera
         if transfer_spec['tags'].is_a?(Hash) && transfer_spec['tags']['aspera'].is_a?(Hash)
           transfer_spec['tags']['aspera']['xfer_retry'] ||= 150
         end
-        # optimisation in case of sending to the same node
-        if transfer_spec['remote_host'].eql?(URI.parse(node_api_.params[:base_url]).host)
-          transfer_spec['remote_host'] = 'localhost'
+        # Optimisation in case of sending to the same node (TODO: probably remove this, as /etc/hosts shall be used for that)
+        if !transfer_spec['wss_enabled'] && transfer_spec['remote_host'].eql?(URI.parse(node_api_.params[:base_url]).host)
+          transfer_spec['remote_host'] = '127.0.0.1'
         end
-        resp = node_api_.create('ops/transfers',transfer_spec)[:data]
+        resp = node_api_.create('ops/transfers', transfer_spec)[:data]
         @transfer_id = resp['id']
-        Log.log.debug("tr_id=#{@transfer_id}")
+        Log.log.debug{"tr_id=#{@transfer_id}"}
         return @transfer_id
       end
 
@@ -99,30 +101,30 @@ module Aspera
           when 'completed'
             notify_end(@transfer_id)
             break
-          when 'waiting','partially_completed','unknown','waiting(read error)'
+          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: trdata['status'])
             spinner.spin
-            #puts trdata
+            # puts trdata
           when 'running'
-            #puts "running: sessions:#{trdata["sessions"].length}, #{trdata["sessions"].map{|i| i['bytes_transferred']}.join(',')}"
+            # puts "running: sessions:#{trdata["sessions"].length}, #{trdata["sessions"].map{|i| i['bytes_transferred']}.join(',')}"
             if !started && trdata['precalc'].is_a?(Hash) &&
-            trdata['precalc']['status'].eql?('ready')
-              notify_begin(@transfer_id,trdata['precalc']['bytes_expected'])
+                trdata['precalc']['status'].eql?('ready')
+              notify_begin(@transfer_id, trdata['precalc']['bytes_expected'])
               started = true
             else
-              notify_progress(@transfer_id,trdata['bytes_transferred'])
+              notify_progress(@transfer_id, trdata['bytes_transferred'])
             end
           else
-            Log.log.warn("trdata -> #{trdata}")
+            Log.log.warn{"trdata -> #{trdata}"}
             raise Fasp::Error, "#{trdata['status']}: #{trdata['error_desc']}"
           end
           sleep(1)
         end
-        #TODO get status of sessions
+        # TODO: get status of sessions
         return []
       end
     end

data/lib/aspera/fasp/agent_trsdk.rb

@@ -6,7 +6,7 @@ require 'json'
 
 module Aspera
   module Fasp
-    class AgentTrsdk < AgentBase
+    class AgentTrsdk < Aspera::Fasp::AgentBase
       DEFAULT_OPTIONS = {
         address: '127.0.0.1',
         port:    55_002
@@ -18,26 +18,26 @@ module Aspera
         raise "expecting Hash (or nil), but have #{user_opts.class}" unless user_opts.nil? || user_opts.is_a?(Hash)
         # set default options and override if specified
         options = DEFAULT_OPTIONS.dup
-        user_opts&.each do |k,v|
-          raise "Unknown local agent parameter: #{k}, expect one of #{DEFAULT_OPTIONS.keys.map(&:to_s).join(',')}" unless DEFAULT_OPTIONS.has_key?(k)
+        user_opts&.each do |k, v|
+          raise "Unknown local agent parameter: #{k}, expect one of #{DEFAULT_OPTIONS.keys.map(&:to_s).join(',')}" unless DEFAULT_OPTIONS.key?(k)
           options[k] = v
         end
-        Log.log.debug("options= #{options}")
+        Log.log.debug{"options= #{options}"}
         super()
         # load and create SDK stub
         $LOAD_PATH.unshift(Installation.instance.sdk_ruby_folder)
         require 'transfer_services_pb'
-        @transfer_client = Transfersdk::TransferService::Stub.new("#{options[:address]}:#{options[:port]}",:this_channel_is_insecure)
+        @transfer_client = Transfersdk::TransferService::Stub.new("#{options[:address]}:#{options[:port]}", :this_channel_is_insecure)
         begin
           get_info_response = @transfer_client.get_info(Transfersdk::InstanceInfoRequest.new)
-          Log.log.debug("daemon info: #{get_info_response}")
+          Log.log.debug{"daemon info: #{get_info_response}"}
         rescue GRPC::Unavailable
           Log.log.warn('no daemon present, starting daemon...')
           # location of daemon binary
-          bin_folder = File.realpath(File.join(Installation.instance.sdk_ruby_folder,'..'))
+          bin_folder = File.realpath(File.join(Installation.instance.sdk_ruby_folder, '..'))
           # config file and logs are created in same folder
-          conf_file = File.join(bin_folder,'sdk.conf')
-          log_base = File.join(bin_folder,'transferd')
+          conf_file = File.join(bin_folder, 'sdk.conf')
+          log_base = File.join(bin_folder, 'transferd')
           # create a config file for daemon
           config = {
             address:      options[:address],
@@ -50,15 +50,15 @@ module Aspera
               }
             }
           }
-          File.write(conf_file,config.to_json)
-          trd_pid = Process.spawn(Installation.instance.path(:transferd),'--config', conf_file, out: "#{log_base}.out", err: "#{log_base}.err")
+          File.write(conf_file, config.to_json)
+          trd_pid = Process.spawn(Installation.instance.path(:transferd), '--config', conf_file, out: "#{log_base}.out", err: "#{log_base}.err")
           Process.detach(trd_pid)
           sleep(2.0)
           retry
         end
       end
 
-      def start_transfer(transfer_spec,_options=nil)
+      def start_transfer(transfer_spec)
         # create a transfer request
         transfer_request = Transfersdk::TransferRequest.new(
           transferType: Transfersdk::TransferType::FILE_REGULAR, # transfer type (file/stream)
@@ -66,9 +66,9 @@ module Aspera
           transferSpec: transfer_spec.to_json) # transfer definition
         # send start transfer request to the transfer manager daemon
         start_transfer_response = @transfer_client.start_transfer(transfer_request)
-        Log.log.debug("start transfer response #{start_transfer_response}")
+        Log.log.debug{"start transfer response #{start_transfer_response}"}
         @transfer_id = start_transfer_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
@@ -76,26 +76,26 @@ module Aspera
         # monitor transfer status
         @transfer_client.monitor_transfers(Transfersdk::RegistrationRequest.new(transferId: [@transfer_id])) do |response|
           Log.dump(:response, response.to_h)
-          #Log.log.debug("#{response.sessionInfo.preTransferBytes} #{response.transferInfo.bytesTransferred}")
+          # Log.log.debug{"#{response.sessionInfo.preTransferBytes} #{response.transferInfo.bytesTransferred}"}
           case response.status
           when :RUNNING
             if !started && !response.sessionInfo.preTransferBytes.eql?(0)
-              notify_begin(@transfer_id,response.sessionInfo.preTransferBytes)
+              notify_begin(@transfer_id, response.sessionInfo.preTransferBytes)
               started = true
             elsif started
-              notify_progress(@transfer_id,response.transferInfo.bytesTransferred)
+              notify_progress(@transfer_id, response.transferInfo.bytesTransferred)
             end
           when :FAILED, :COMPLETED, :CANCELED
             notify_end(@transfer_id)
             raise Fasp::Error, JSON.parse(response.message)['Description'] unless :COMPLETED.eql?(response.status)
             break
-          when :QUEUED,:UNKNOWN_STATUS,:PAUSED,:ORPHANED
+          when :QUEUED, :UNKNOWN_STATUS, :PAUSED, :ORPHANED
             # ignore
           else
-            Log.log.error("unknown status#{response.status}")
+            Log.log.error{"unknown status#{response.status}"}
           end
         end
-        # TODO return status
+        # TODO: return status
         return []
       end
     end

data/lib/aspera/fasp/error.rb

@@ -7,7 +7,8 @@ module Aspera
     # error raised if transfer fails
     class Error < StandardError
       attr_reader :err_code
-      def initialize(message,err_code=nil)
+
+      def initialize(message, err_code=nil)
         super(message)
         @err_code = err_code
       end
@@ -17,7 +18,7 @@ module Aspera
         return r.merge({i: @err_code})
       end
 
-      def retryable?; info[:r];end
+      def retryable?; info[:r]; end
     end
   end
 end

data/lib/aspera/fasp/error_info.rb

@@ -4,6 +4,8 @@ module Aspera
   module Fasp
     # from https://www.google.com/search?q=FASP+error+codes
     # Note that the fact that an error is retryable is not internally defined by protocol, it's client-side responsibility
+    # rubocop:disable Layout/MultilineHashKeyLineBreaks
+    # rubocop:disable Layout/FirstHashElementLineBreak
     ERROR_INFO = {
       # id   retryable      mnemo                       message                                              additional info
       1  => { r: false, c: 'FASP_PROTO',                  m: 'Generic fasp(tm) protocol error',                a: 'fasp(tm) error'},
@@ -18,13 +20,13 @@ module Aspera
       10 => { r: false, c: 'LIC_RATE_EXCEEDED',           m: 'Rate exceeds the cap imposed by license',        a: 'Rate exceeds cap imposed by license'},
       11 => { r: false, c: 'INTERNAL_ERROR',              m: 'Internal error (unexpected error)',              a: 'Internal error'},
       12 => { r: true,  c: 'TRANSFER_ERROR',              m: 'Error establishing control connection',
-                                                          a: 'Error establishing SSH connection (check SSH port and firewall)'},
+                                                              a: 'Error establishing SSH connection (check SSH port and firewall)'},
       13 => { r: true,  c: 'TRANSFER_TIMEOUT',            m: 'Timeout establishing control connection',
-                                                          a: 'Timeout establishing SSH connection (check SSH port and firewall)'},
+                                                              a: 'Timeout establishing SSH connection (check SSH port and firewall)'},
       14 => { r: true,  c: 'CONNECTION_ERROR',            m: 'Error establishing data connection',
-                                                          a: 'Error establishing UDP connection (check UDP port and firewall)'},
+                                                              a: 'Error establishing UDP connection (check UDP port and firewall)'},
       15 => { r: true,  c: 'CONNECTION_TIMEOUT',          m: 'Timeout establishing data connection',
-                                                          a: 'Timeout establishing UDP connection (check UDP port and firewall)'},
+                                                              a: 'Timeout establishing UDP connection (check UDP port and firewall)'},
       16 => { r: true,  c: 'CONNECTION_LOST',             m: 'Connection lost',                                a: 'Connection lost'},
       17 => { r: true,  c: 'RCVR_SEND_ERROR',             m: 'Receiver fails to send feedback',                a: 'Network failure (receiver can\'t send feedback)'},
       18 => { r: true,  c: 'RCVR_RECV_ERROR',             m: 'Receiver fails to receive data packets',         a: 'Network failure (receiver can\'t receive UDP data)'},
@@ -68,20 +70,21 @@ module Aspera
       54 => { r: false, c: 'THRESHOLD_VALIDATION_FAILED', m: 'File threshold validation failed',               a: 'File threshold validation failed'},
       55 => { r: false, c: 'FILEPATH_TOO_LONG',           m: 'File path/name too long for underlying file system', a: 'File path exceeds underlying file system limit'},
       56 => { r: false, c: 'ILLEGAL_CHARS_IN_PATH',       m: 'Windows path contains illegal characters',
-                                                          a: 'Path being written to Windows file system contains illegal characters'},
+                                                              a: 'Path being written to Windows file system contains illegal characters'},
       57 => { r: false, c: 'CHUNK_MUST_MATCH_ALIGNMENT',  m: 'Chunk size/start must be aligned with storage',  a: 'Chunk size/start must be aligned with storage'},
       58 => { r: false, c: 'VALIDATION_SESSION_ABORT',    m: 'Session aborted to due to validation error',     a: 'Session aborted to due validation error'},
       59 => { r: false, c: 'REMOTE_STORAGE_ERROR',        m: 'Remote storage errored',                         a: 'Remote storage errored'},
       60 => { r: false, c: 'LUA_SCRIPT_ABORTED_SESSION',  m: 'Session aborted due to Lua script abort',        a: 'Session aborted due to Lua script abort'},
       61 => { r: true,  c: 'SSEAR_RETRYABLE',             m: 'Transfer failed because of a retryable Encryption at Rest error',
-                                                          a: 'Transfer failed because of a retryable Encryption at Rest error'},
+                                                              a: 'Transfer failed because of a retryable Encryption at Rest error'},
       62 => { r: false, c: 'SSEAR_FATAL',                 m: 'Transfer failed because of a fatal Encryption at Rest error',
-                                                          a: 'Transfer failed because of a fatal Encryption at Rest error'},
+                                                              a: 'Transfer failed because of a fatal Encryption at Rest error'},
       63 => { r: false, c: 'LINK_LOOP',                   m: 'Path refers to a symbolic link loop',            a: 'Path refers to a symbolic link loop'},
       64 => { r: false, c: 'CANNOT_RENAME_PARTIAL_FILES', m: 'Can\'t rename a partial file',                   a: 'Can\'t rename a partial file.'},
       65 => { r: false, c: 'CIPHER_NON_COMPAT_FIPS',      m: 'Can\'t use this cipher with FIPS mode enabled',  a: 'Can\'t use this cipher with FIPS mode enabled'},
       66 => { r: false, c: 'PEER_REQUIRES_FIPS',          m: 'Peer rejects cipher due to FIPS mode enabled on peer',
-                                                          a: 'Peer rejects cipher due to FIPS mode enabled on peer'}
+                                                              a: 'Peer rejects cipher due to FIPS mode enabled on peer'}
     }.freeze
+    # rubocop:enable Layout/MultilineHashKeyLineBreaks
   end
 end