aspera-cli 4.10.0 → 4.11.0

data/lib/aspera/fasp/agent_httpgw.rb

@@ -14,7 +14,7 @@ require 'json'
 module Aspera
   module Fasp
     # start a transfer using Aspera HTTP Gateway, using web socket session for uploads
-    class AgentHttpgw < AgentBase
+    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'
@@ -23,15 +23,15 @@ module Aspera
         upload_chunksize:       64_000,
         upload_bar_refresh_sec: 0.5
       }.freeze
-      DEFAULT_BASE_PATH='/aspera/http-gwy'
+      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
+      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_snd_json(data)
-        @slice_uploads += 1 if data.has_key?(:slice_upload)
+        @slice_uploads += 1 if data.key?(:slice_upload)
         Log.log.debug{JSON.generate(data)}
         ws_send(JSON.generate(data))
       end
@@ -47,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)
@@ -56,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)
@@ -66,18 +66,18 @@ module Aspera
         end
         # identify this session uniquely
         session_id = SecureRandom.uuid
-        @slice_uploads=0
+        @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)}
+        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)
+        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_io.debug_output = Log.log
         @ws_handshake = ::WebSocket::Handshake::Client.new(url: url, headers: {})
         @ws_io.write(@ws_handshake.to_s)
         sleep(0.1)
@@ -85,21 +85,21 @@ module Aspera
         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={
+        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
+          # 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
+            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]}")
+                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
@@ -122,12 +122,12 @@ module Aspera
               break
             end
           end
-          Log.log.debug("ws: thread: stopping #{shared_info[:read_exception]} #{shared_info[:read_exception].class}")
+          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)
+        Log.dump(:ws_spec, transfer_spec)
         ws_snd_json(transfer_spec: transfer_spec)
         # current file index
         file_index = 0
@@ -135,58 +135,63 @@ module Aspera
         sent_bytes = 0
         # last progress event
         last_progress_time = nil
-        begin
-          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) / @options[:upload_chunksize])
-            File.open(source_paths[file_index]) do |file|
-              # current slice index
-              slicenum = 0
-              while !file.eof?
-                # interrupt main thread if read thread failed
-                raise shared_info[:read_exception] unless shared_info[:read_exception].nil?
-                data = file.read(@options[:upload_chunksize])
-                slice_data = {
-                  name:         file_name,
-                  type:         file_mime_type,
-                  size:         file_size,
-                  slice:        slicenum,
-                  total_slices: numslices,
-                  fileIndex:    file_index
-                }
-                #Log.dump(:slice_data,slice_data) #if slicenum.eql?(0)
+
+        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 = ((file_size - 1) / @options[:upload_chunksize]) + 1
+          File.open(source_paths[file_index]) do |file|
+            # current slice index
+            slicenum = 0
+            until file.eof?
+              data = file.read(@options[:upload_chunksize])
+              slice_data = {
+                name:         file_name,
+                type:         file_mime_type,
+                size:         file_size,
+                slice:        slicenum,
+                total_slices: numslices,
+                fileIndex:    file_index
+              }
+              # 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)
+                  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
-                sent_bytes += data.length
-                currenttime = Time.now
-                if last_progress_time.nil? || ((currenttime - last_progress_time) > @options[:upload_bar_refresh_sec])
-                  notify_progress(session_id,sent_bytes)
-                  last_progress_time = currenttime
+                  ws_snd_json(slice_upload: slice_data) if slicenum.eql?(numslices - 1)
                 end
-                slicenum += 1
+              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 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
             end
-            file_index += 1
           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?
         @ws_io = nil
         http_socket&.finish
-        notify_progress(session_id,sent_bytes)
+        notify_progress(session_id, sent_bytes)
         notify_end(session_id)
       end
 
@@ -194,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('v1/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
@@ -215,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: "v1/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
@@ -253,17 +257,17 @@ module Aspera
       private
 
       def initialize(opts)
-        Log.log.debug("local options= #{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.has_key?(k)
+        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/*$},'')
+        @options[:url].gsub(%r{/v1/*$}, '')
         super()
         @gw_api = Rest.new({base_url: @options[:url]})
         @api_info = @gw_api.read('v1/info')[:data]

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