aspera-cli 4.24.1 → 4.25.0.pre

data/lib/aspera/cli/plugin.rb

@@ -1,333 +0,0 @@
-# frozen_string_literal: true
-
-require 'aspera/cli/extended_value'
-require 'aspera/assert'
-
-module Aspera
-  module Cli
-    # Base class for plugins
-    class Plugin
-      # operations without id
-      GLOBAL_OPS = %i[create list].freeze
-      # operations with id
-      INSTANCE_OPS = %i[modify delete show].freeze
-      # all standard operations
-      ALL_OPS = (GLOBAL_OPS + INSTANCE_OPS).freeze
-      # special query parameter: max number of items for list command
-      MAX_ITEMS = 'max'
-      # special query parameter: max number of pages for list command
-      MAX_PAGES = 'pmax'
-      # special identifier format: look for this name to find where supported
-      REGEX_LOOKUP_ID_BY_FIELD = /^%([^:]+):(.*)$/
-      PER_PAGE_DEFAULT = 1000
-      private_constant :PER_PAGE_DEFAULT
-
-      class << self
-        def declare_generic_options(options)
-          options.declare(:query, 'Additional filter for for some commands (list/delete)', types: [Hash, Array])
-          options.declare(:property, 'Name of property to set (modify operation)')
-          options.declare(:bulk, 'Bulk operation (only some)', values: :bool, default: :no)
-          options.declare(:bfail, 'Bulk operation error handling', values: :bool, default: :yes)
-        end
-      end
-
-      def initialize(context:)
-        # check presence in descendant of mandatory method and constant
-        Aspera.assert(respond_to?(:execute_action), type: InternalError){"Missing method 'execute_action' in #{self.class}"}
-        Aspera.assert(self.class.constants.include?(:ACTIONS), type: InternalError){"Missing constant 'ACTIONS' in #{self.class}"}
-        @context = context
-        add_manual_header if @context.man_header
-      end
-
-      # Global objects
-      attr_reader :context
-
-      def options; @context.options; end
-      def transfer; @context.transfer; end
-      def config; @context.config; end
-      def formatter; @context.formatter; end
-      def persistency; @context.persistency; end
-
-      def add_manual_header(has_options = true)
-        # manual header for all plugins
-        options.parser.separator('')
-        options.parser.separator("COMMAND: #{self.class.name.split('::').last.downcase}")
-        options.parser.separator("SUBCOMMANDS: #{self.class.const_get(:ACTIONS).map(&:to_s).sort.join(' ')}")
-        options.parser.separator('OPTIONS:') if has_options
-      end
-
-      # Must be called AFTER the instance action:
-      # ... folder browse _call_instance_identifier
-      #
-      # @param description [String] description of the identifier
-      # @param as_option   [Symbol] option name to use if identifier is an option
-      # @param block       [Proc] block to search for identifier based on attribute value
-      # @return   [String, Array] identifier or list of ids
-      def instance_identifier(description: 'identifier', as_option: nil, &block)
-        if as_option.nil?
-          res_id = options.get_next_argument(description, multiple: options.get_option(:bulk)) if res_id.nil?
-        else
-          res_id = options.get_option(as_option)
-        end
-        # can be an Array
-        if res_id.is_a?(String) && (m = res_id.match(REGEX_LOOKUP_ID_BY_FIELD))
-          if block
-            res_id = yield(m[1], ExtendedValue.instance.evaluate(m[2]))
-          else
-            raise Cli::BadArgument, "Percent syntax for #{description} not supported in this context"
-          end
-        end
-        return res_id
-      end
-
-      # For create and delete operations: execute one actin or multiple if bulk is yes
-      # @param command   [Symbol] operation: :create, :delete, ...
-      # @param descr     [String] description of the value
-      # @param values    [Object] the value(s), or the type of value to get from user
-      # @param id_result [String] key in result hash to use as identifier
-      # @param fields    [Array]  fields to display
-      # @param &block    [Proc]   block to execute for each value
-      def do_bulk_operation(command:, descr: nil, values: Hash, id_result: 'id', fields: :default)
-        Aspera.assert(block_given?){'missing block'}
-        is_bulk = options.get_option(:bulk)
-        case values
-        when :identifier
-          values = instance_identifier(description: descr)
-        when Class
-          values = value_create_modify(command: command, description: descr, type: values, bulk: is_bulk)
-        end
-        # if not bulk, there is a single value
-        params = is_bulk ? values : [values]
-        Log.log.warn('Empty list given for bulk operation') if params.empty?
-        Log.dump(:bulk_operation, params)
-        result_list = []
-        params.each do |param|
-          # init for delete
-          result = {id_result => param}
-          begin
-            # execute custom code
-            res = yield(param)
-            # if block returns a hash, let's use this (create)
-            result = res if res.is_a?(Hash)
-            # TODO: remove when faspio gw api fixes this
-            result = res.first if res.is_a?(Array) && res.first.is_a?(Hash)
-            # create -> created
-            result['status'] = "#{command}#{'e' unless command.to_s.end_with?('e')}d".gsub(/yed$/, 'ied')
-          rescue StandardError => e
-            raise e if options.get_option(:bfail)
-            result['status'] = e.to_s
-          end
-          result_list.push(result)
-        end
-        display_fields = [id_result, 'status']
-        if is_bulk
-          return Main.result_object_list(result_list, fields: display_fields)
-        else
-          display_fields = fields unless fields.eql?(:default)
-          return Main.result_single_object(result_list.first, fields: display_fields)
-        end
-      end
-
-      # Operations: Create, Delete, Show, List, Modify
-      # @param api            [Rest]    api to use
-      # @param entity         [String]  sub path in URL to resource relative to base url
-      # @param command        [Symbol]  command to execute: create show list modify delete
-      # @param display_fields [Array]   fields to display by default
-      # @param items_key      [String]  result is in a sub key of the json
-      # @param delete_style   [String]  if set, the delete operation by array in payload
-      # @param id_as_arg      [String]  if set, the id is provided as url argument ?<id_as_arg>=<id>
-      # @param is_singleton   [Boolean] if true, entity is the full path to the resource
-      # @param tclo           [Bool]    if set, :list use paging with total_count, limit, offset
-      # @param block          [Proc]    block to search for identifier based on attribute value
-      # @return result suitable for CLI result
-      def entity_execute(
-        api:,
-        entity:,
-        command: nil,
-        display_fields: nil,
-        items_key: nil,
-        delete_style: nil,
-        id_as_arg: false,
-        is_singleton: false,
-        list_query: nil,
-        tclo: false,
-        &block
-      )
-        command = options.get_next_command(ALL_OPS) if command.nil?
-        if is_singleton
-          one_res_path = entity
-        elsif INSTANCE_OPS.include?(command)
-          one_res_id = instance_identifier(&block)
-          one_res_path = "#{entity}/#{one_res_id}"
-          one_res_path = "#{entity}?#{id_as_arg}=#{one_res_id}" if id_as_arg
-        end
-
-        case command
-        when :create
-          raise BadArgument, 'cannot create singleton' if is_singleton
-          return do_bulk_operation(command: command, descr: 'data', fields: display_fields) do |params|
-            api.create(entity, params)
-          end
-        when :delete
-          raise BadArgument, 'cannot delete singleton' if is_singleton
-          if !delete_style.nil?
-            one_res_id = [one_res_id] unless one_res_id.is_a?(Array)
-            Aspera.assert_type(one_res_id, Array, type: Cli::BadArgument)
-            api.call(
-              operation:    'DELETE',
-              subpath:      entity,
-              content_type: Rest::MIME_JSON,
-              body:         {delete_style => one_res_id},
-              headers:      {'Accept' => Rest::MIME_JSON}
-            )
-            return Main.result_status('deleted')
-          end
-          return do_bulk_operation(command: command, values: one_res_id) do |one_id|
-            api.delete("#{entity}/#{one_id}", query_read_delete)
-            {'id' => one_id}
-          end
-        when :show
-          return Main.result_single_object(api.read(one_res_path), fields: display_fields)
-        when :list
-          if tclo
-            data, total = list_entities_limit_offset_total_count(api: api, entity:, items_key: items_key, query: list_query)
-            return Main.result_object_list(data, total: total, fields: display_fields)
-          end
-          resp = api.call(operation: 'GET', subpath: entity, headers: {'Accept' => Rest::MIME_JSON}, query: query_read_delete)
-          return Main.result_empty if resp[:http].code == '204'
-          data = resp[:data]
-          # TODO: not generic : which application is this for ?
-          if resp[:http]['Content-Type'].start_with?('application/vnd.api+json')
-            Log.log.debug('is vnd.api')
-            data = data[entity]
-          end
-          data = data[items_key] if items_key
-          case data
-          when Hash
-            return Main.result_single_object(data, fields: display_fields)
-          when Array
-            return Main.result_object_list(data, fields: display_fields) if data.empty? || data.first.is_a?(Hash)
-            return Main.result_value_list(data)
-          else
-            raise "An error occurred: unexpected result type for list: #{data.class}"
-          end
-        when :modify
-          parameters = value_create_modify(command: command)
-          property = options.get_option(:property)
-          parameters = {property => parameters} unless property.nil?
-          api.update(one_res_path, parameters)
-          return Main.result_status('modified')
-        else
-          raise "unknown action: #{command}"
-        end
-      end
-
-      # Query parameters in URL suitable for REST: list/GET and delete/DELETE
-      def query_read_delete(default: nil)
-        query = options.get_option(:query)
-        # dup default, as it could be frozen
-        query = default.dup if query.nil?
-        Log.log.debug{"query_read_delete=#{query}".bg_red}
-        begin
-          # check it is suitable
-          URI.encode_www_form(query) unless query.nil?
-        rescue StandardError => e
-          raise Cli::BadArgument, "Query must be an extended value (Hash, Array) which can be encoded with URI.encode_www_form. Refer to manual. (#{e.message})"
-        end
-        return query
-      end
-
-      # Retrieves an extended value from command line, used for creation or modification of entities
-      # @param command [Symbol] command name for error message
-      # @param type [Class] expected type of value, either a Class, an Array of Class
-      # @param bulk [Boolean] if true, value must be an Array of <type>
-      # @param default [Object] default value if not provided
-      def value_create_modify(command:, description: nil, type: Hash, bulk: false, default: nil)
-        value = options.get_next_argument(
-          "parameters for #{command}#{" (#{description})" unless description.nil?}", mandatory: default.nil?,
-          validation: bulk ? Array : type
-        )
-        value = default if value.nil?
-        unless type.nil?
-          type = [type] unless type.is_a?(Array)
-          Aspera.assert(type.all?(Class)){"check types must be a Class, not #{type.map(&:class).join(',')}"}
-          if bulk
-            Aspera.assert_type(value, Array, type: Cli::BadArgument)
-            value.each do |v|
-              Aspera.assert_values(v.class, type, type: Cli::BadArgument)
-            end
-          else
-            Aspera.assert_values(value.class, type, type: Cli::BadArgument)
-          end
-        end
-        return value
-      end
-
-      # Get a (full or partial) list of all entities of a given type with query: offset/limit
-      # @param `api`       [Rest]          the API object
-      # @param `entity`    [String,Symbol] the API endpoint of entity to list
-      # @param `items_key` [String]        key in the result to get the list of items
-      # @param `query`     [Hash,nil]      additional query parameters
-      # @return [Array] items, total_count
-      def list_entities_limit_offset_total_count(
-        api:,
-        entity:,
-        items_key: nil,
-        query: nil
-      )
-        entity = entity.to_s if entity.is_a?(Symbol)
-        items_key = entity.split('/').last if items_key.nil?
-        query = {} if query.nil?
-        Aspera.assert_type(entity, String)
-        Aspera.assert_type(items_key, String)
-        Aspera.assert_type(query, Hash)
-        Log.log.debug{"list_entities t=#{entity} k=#{items_key} q=#{query}"}
-        result = []
-        offset = 0
-        max_items = query.delete(MAX_ITEMS)
-        remain_pages = query.delete(MAX_PAGES)
-        # merge default parameters, by default 100 per page
-        query = {'limit'=> PER_PAGE_DEFAULT}.merge(query)
-        total_count = nil
-        loop do
-          query['offset'] = offset
-          page_result = api.read(entity, query)
-          Aspera.assert_type(page_result[items_key], Array)
-          result.concat(page_result[items_key])
-          # reach the limit set by user ?
-          if !max_items.nil? && (result.length >= max_items)
-            result = result.slice(0, max_items)
-            break
-          end
-          total_count ||= page_result['total_count']
-          break if result.length >= total_count
-          remain_pages -= 1 unless remain_pages.nil?
-          break if remain_pages == 0
-          offset += page_result[items_key].length
-          formatter.long_operation_running
-        end
-        formatter.long_operation_terminated
-        return result, total_count
-      end
-
-      # Lookup an entity id from its name
-      # @param entity    [String] the type of entity to lookup, by default it is the path, and it is also the field name in result
-      # @param value     [String] the value to lookup
-      # @param field     [String] the field to match, by default it is 'name'
-      # @param items_key [String] key in the result to get the list of items (override entity)
-      # @param query     [Hash]   additional query parameters
-      def lookup_entity_by_field(api:, entity:, value:, field: 'name', items_key: nil, query: :default)
-        if query.eql?(:default)
-          Aspera.assert(field.eql?('name')){'Default query is on name only'}
-          query = {'q'=> value}
-        end
-        found = list_entities_limit_offset_total_count(api: api, entity: entity, items_key: items_key, query: query).first.select{ |i| i[field].eql?(value)}
-        case found.length
-        when 0 then raise "No #{entity} with #{field} = #{value}"
-        when 1 then return found.first
-        else raise "Found #{found.length} #{entity} with #{field} = #{value}"
-        end
-      end
-    end
-  end
-end

data/lib/aspera/cli/plugin_factory.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-module Aspera
-  module Cli
-    # Instantiate plugin from well-known locations
-    class PluginFactory
-      include Singleton
-
-      RUBY_FILE_EXT = '.rb'
-      PLUGINS_MODULE = 'Plugins'
-      private_constant :RUBY_FILE_EXT, :PLUGINS_MODULE
-
-      attr_reader :lookup_folders
-
-      def initialize
-        @lookup_folders = []
-        # information on plugins
-        @plugins = {}
-      end
-
-      # @return list of registered plugins
-      def plugin_list
-        @plugins.keys
-      end
-
-      # @return path to source file of plugin
-      def plugin_source(plugin_name_sym)
-        @plugins[plugin_name_sym][:source]
-      end
-
-      # add a folder to the list of folders to look for plugins
-      def add_lookup_folder(folder)
-        @lookup_folders.unshift(folder)
-      end
-
-      # find plugins in defined paths
-      def add_plugins_from_lookup_folders
-        @lookup_folders.each do |folder|
-          next unless File.directory?(folder)
-          # TODO: add gem root to load path ? and require short folder ?
-          # $LOAD_PATH.push(folder) if i[:add_path]
-          Dir.entries(folder).select{ |file| file.end_with?(RUBY_FILE_EXT)}.each do |source|
-            add_plugin_info(File.join(folder, source))
-          end
-        end
-      end
-
-      # @return Class object for plugin
-      def plugin_class(plugin_name_sym)
-        raise NoSuchElement, "plugin not found: #{plugin_name_sym}" unless @plugins.key?(plugin_name_sym)
-        require @plugins[plugin_name_sym][:require_stanza]
-        # Module.nesting[1] is Aspera::Cli
-        return Object.const_get("#{Module.nesting[1]}::#{PLUGINS_MODULE}::#{plugin_name_sym.to_s.capitalize}")
-      end
-
-      # Create specified plugin
-      # @param plugin_name_sym [Symbol] name of plugin
-      # @param args [Hash] arguments to pass to plugin constructor
-      def create(plugin_name_sym, **args)
-        # TODO: check that ancestor is Plugin?
-        plugin_class(plugin_name_sym).new(**args)
-      end
-
-      private
-
-      # add plugin information to list
-      # @param path [String] path to plugin source file
-      def add_plugin_info(path)
-        raise Error, "plugin path must end with #{RUBY_FILE_EXT}" if !path.end_with?(RUBY_FILE_EXT)
-        plugin_symbol = File.basename(path, RUBY_FILE_EXT).to_sym
-        req = path.sub(/#{RUBY_FILE_EXT}$/o, '')
-        if @plugins.key?(plugin_symbol)
-          Log.log.warn{"skipping plugin already registered: #{plugin_symbol}"}
-          return
-        end
-        @plugins[plugin_symbol] = {source: path, require_stanza: req}
-      end
-    end
-  end
-end

data/lib/aspera/resumer.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-require 'aspera/log'
-require 'aspera/assert'
-
-module Aspera
-  # implements a simple resume policy
-  class Resumer
-    # list of supported parameters and default values
-    DEFAULTS = {
-      iter_max:      7,
-      sleep_initial: 2,
-      sleep_factor:  2,
-      sleep_max:     60
-    }.freeze
-
-    # @param params see DEFAULTS
-    def initialize(params = nil)
-      @parameters = DEFAULTS.dup
-      if !params.nil?
-        Aspera.assert_type(params, Hash)
-        params.each do |k, v|
-          Aspera.assert_values(k, DEFAULTS.keys){'resume parameter'}
-          Aspera.assert_type(v, Integer){k}
-          @parameters[k] = v
-        end
-      end
-      Log.log.debug{"resume params=#{@parameters}"}
-    end
-
-    # calls block a number of times (resumes) until success or limit reached
-    # this is re-entrant, one resumer can handle multiple transfers in //
-    def execute_with_resume
-      Aspera.assert(block_given?)
-      # maximum of retry
-      remaining_resumes = @parameters[:iter_max]
-      sleep_seconds = @parameters[:sleep_initial]
-      Log.log.debug{"retries=#{remaining_resumes}"}
-      # try to send the file until ascp is successful
-      loop do
-        Log.log.debug('transfer starting')
-        begin
-          # call provided block
-          yield
-          # exit retry loop if success
-          break
-        rescue Transfer::Error => e
-          Log.log.warn{"An error occurred during transfer: #{e.message}"}
-          # failure in ascp
-          if e.retryable?
-            # exit if we exceed the max number of retry
-            raise Transfer::Error, "Maximum number of retry reached (#{@parameters[:iter_max]})" if remaining_resumes <= 0
-          else
-            # give one chance only to non retryable errors
-            unless remaining_resumes.eql?(@parameters[:iter_max])
-              Log.log.error('non-retryable error'.red.blink)
-              raise e
-            end
-          end
-        end
-
-        # take this retry in account
-        remaining_resumes -= 1
-        Log.log.warn{"Resuming in #{sleep_seconds} seconds (retry left:#{remaining_resumes})"}
-
-        # wait a bit before retrying, maybe network condition will be better
-        sleep(sleep_seconds)
-
-        # increase retry period
-        sleep_seconds *= @parameters[:sleep_factor]
-        # cap value
-        sleep_seconds = @parameters[:sleep_max] if sleep_seconds > @parameters[:sleep_max]
-      end
-    end
-  end
-end

data/lib/aspera/transfer/error_info.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-# cspell:words mnemo PROTO RCVR NOLIC PMTU BRTT VLINK BWMEAS SSEAR FIPS
-
-module Aspera
-  module Transfer
-    # from https://www.google.com/search?q=FASP+error+codes
-    # Note that the fact that an error is retry-able is not internally defined by protocol, it's client-side responsibility
-    # rubocop:disable Layout/FirstHashElementLineBreak
-    ERROR_INFO = {
-      # id   retry-able     mnemo                       message                                              additional info
-      1  => {r: false, c: 'FASP_PROTO',                  m: 'Generic fasp(tm) protocol error',                a: 'fasp(tm) error'},
-      2  => {r: false, c: 'ASCP',                        m: 'Generic SCP error',                              a: 'ASCP error'},
-      3  => {r: false, c: 'AMBIGUOUS_TARGET',            m: 'Target incorrectly specified',                   a: 'Ambiguous target'},
-      4  => {r: false, c: 'NO_SUCH_FILE',                m: 'No such file or directory',                      a: 'No such file or directory'},
-      5  => {r: false, c: 'NO_PERMS',                    m: 'Insufficient permission to read or write',       a: 'Insufficient permissions'},
-      6  => {r: false, c: 'NOT_DIR',                     m: 'Target is not a directory',                      a: 'Target must be a directory'},
-      7  => {r: false, c: 'IS_DIR',                      m: 'File is a directory - expected regular file',    a: 'Expected regular file'},
-      8  => {r: false, c: 'USAGE',                       m: 'Incorrect usage of scp command',                 a: 'Incorrect usage of Aspera scp command'},
-      9  => {r: false, c: 'LIC_DUP',                     m: 'Duplicate license',                              a: 'Duplicate license'},
-      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)'},
-      13 => {r: true,  c: 'TRANSFER_TIMEOUT',            m: 'Timeout establishing control connection',
-                                                              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)'},
-      15 => {r: true,  c: 'CONNECTION_TIMEOUT',          m: 'Timeout establishing data connection',
-                                                              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)'},
-      19 => {r: false, c: 'AUTH',                        m: 'Authentication failure',                         a: 'Authentication failure'},
-      20 => {r: false, c: 'NOTHING',                     m: 'Nothing to transfer',                            a: 'Nothing to transfer'},
-      21 => {r: false, c: 'NOT_REGULAR',                 m: 'Not a regular file (special file)',              a: 'Not a regular file'},
-      22 => {r: false, c: 'FILE_TABLE_OVR',              m: 'File table overflow',                            a: 'File table overflow'},
-      23 => {r: true,  c: 'TOO_MANY_FILES',              m: 'Too many files open',                            a: 'Too many files open'},
-      24 => {r: false, c: 'FILE_TOO_BIG',                m: 'File too big for file system',                   a: 'File too big for filesystem'},
-      25 => {r: false, c: 'NO_SPACE_LEFT',               m: 'No space left on disk',                          a: 'No space left on disk'},
-      26 => {r: false, c: 'READ_ONLY_FS',                m: 'Read only file system',                          a: 'Read only filesystem'},
-      27 => {r: false, c: 'SOME_FILE_ERRS',              m: 'Some individual files failed',                   a: 'One or more files failed'},
-      28 => {r: false, c: 'USER_CANCEL',                 m: 'Cancelled by user',                              a: 'Cancelled by user'},
-      29 => {r: false, c: 'LIC_NOLIC',                   m: 'License not found or unable to access',          a: 'Unable to access license info'},
-      30 => {r: false, c: 'LIC_EXPIRED',                 m: 'License expired',                                a: 'License expired'},
-      31 => {r: false, c: 'SOCK_SETUP',                  m: 'Unable to setup socket (create, bind, etc ...)', a: 'Unable to set up socket'},
-      32 => {r: true,  c: 'OUT_OF_MEMORY',               m: 'Out of memory, unable to allocate',              a: 'Out of memory'},
-      33 => {r: true,  c: 'THREAD_SPAWN',                m: 'Can\'t spawn thread',                            a: 'Unable to spawn thread'},
-      34 => {r: false, c: 'UNAUTHORIZED',                m: 'Unauthorized by external auth server',           a: 'Unauthorized'},
-      35 => {r: true,  c: 'DISK_READ',                   m: 'Error reading source file from disk',            a: 'Disk read error'},
-      36 => {r: true,  c: 'DISK_WRITE',                  m: 'Error writing to disk',                          a: 'Disk write error'},
-      37 => {r: true,  c: 'AUTHORIZATION',               m: 'Used interchangeably with ERR_UNAUTHORIZED',     a: 'Authorization failure'},
-      38 => {r: false, c: 'LIC_ILLEGAL',                 m: 'Operation not permitted by license',             a: 'Operation not permitted by license'},
-      39 => {r: true,  c: 'PEER_ABORTED_SESSION',        m: 'Remote peer terminated session',                 a: 'Peer aborted session'},
-      40 => {r: true,  c: 'DATA_TRANSFER_TIMEOUT',       m: 'Transfer stalled, timed out',                    a: 'Data transfer stalled, timed out'},
-      41 => {r: false, c: 'BAD_PATH',                    m: 'Path violates docroot containment',              a: 'File location is outside \'docroot\' hierarchy'},
-      42 => {r: false, c: 'ALREADY_EXISTS',              m: 'File or directory already exists',               a: 'File or directory already exists'},
-      43 => {r: false, c: 'STAT_FAILS',                  m: 'Cannot stat file',                               a: 'Cannot collect details about file or directory'},
-      44 => {r: true,  c: 'PMTU_BRTT_ERROR',             m: 'UDP session initiation fatal error',             a: 'UDP session initiation fatal error'},
-      45 => {r: true,  c: 'BWMEAS_ERROR',                m: 'Bandwidth measurement fatal error',              a: 'Bandwidth measurement fatal error'},
-      46 => {r: false, c: 'VLINK_ERROR',                 m: 'Virtual link error',                             a: 'Virtual link error'},
-      47 => {r: false, c: 'CONNECTION_ERROR_HTTP',       m: 'Error establishing HTTP connection',
-                                                          a: 'Error establishing HTTP connection (check HTTP port and firewall)'},
-      48 => {r: false, c: 'FILE_ENCRYPTION_ERROR',       m: 'File encryption error, e.g. corrupt file',
-                                                          a: 'File encryption/decryption error, e.g. corrupt file'},
-      49 => {r: false, c: 'FILE_DECRYPTION_PASS',        m: 'File encryption/decryption error, e.g. corrupt file', a: 'File decryption error, bad passphrase'},
-      50 => {r: false, c: 'BAD_CONFIGURATION',           m: 'Aspera.conf contains invalid data and was rejected',  a: 'Invalid configuration'},
-      51 => {r: false, c: 'INSECURE_CONNECTION',         m: 'Remote-host key check failure',                  a: 'Remote host is not who we expected'},
-      52 => {r: false, c: 'START_VALIDATION_FAILED',     m: 'File start validation failed',                   a: 'File start validation failed'},
-      53 => {r: false, c: 'STOP_VALIDATION_FAILED',      m: 'File stop validation failed',                    a: 'File stop validation failed'},
-      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'},
-      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'},
-      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'},
-      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'}
-    }.freeze
-    # rubocop:enable Layout/FirstHashElementLineBreak
-  end
-end