aspera-cli 4.27.1 → 4.27.3

data/lib/aspera/rest.rb

@@ -1,623 +1,9 @@
 # frozen_string_literal: true
 
-require 'aspera/rest_errors_aspera'
-require 'aspera/rest_error_analyzer'
-require 'aspera/log'
-require 'aspera/assert'
-require 'aspera/oauth'
-require 'aspera/hash_ext'
-require 'aspera/timer_limiter'
-require 'net/http'
-require 'net/https'
-require 'json'
-require 'base64'
-require 'singleton'
-require 'securerandom'
-require 'fileutils'
-
-# Cancel method for HTTP
-class Net::HTTP::Cancel < Net::HTTPRequest # rubocop:disable Style/ClassAndModuleChildren
-  METHOD = 'CANCEL'
-  REQUEST_HAS_BODY  = false
-  RESPONSE_HAS_BODY = false
-end
-
-module Aspera
-  # Global settings for Rest object
-  # For example to remove certificate verification globally:
-  # `RestParameters.instance.session_cb = lambda{|http|http.verify_mode=OpenSSL::SSL::VERIFY_NONE}`
-  # @param user_agent [String] HTTP request header: 'User-Agent'
-  # @param download_partial_suffix [String] suffix for partial download
-  # @param session_cb [lambda] lambda called on new HTTP session. Takes the Net::HTTP as arg. Used to change parameters on creation.
-  # @param progress_bar [Object] progress bar object called for file transfer
-  #
-  # @!method self.instance
-  #   Returns the singleton instance of RestParameters
-  #   @return [RestParameters] the singleton instance
-  class RestParameters
-    include Singleton
-
-    attr_accessor :user_agent, :download_partial_suffix, :retry_on_error, :retry_on_timeout, :retry_on_unavailable, :retry_max, :retry_sleep, :session_cb, :progress_bar, :spinner_cb
-
-    private
-
-    def initialize
-      @user_agent = 'RubyAsperaRest'
-      @download_partial_suffix = '.http_partial'
-      @retry_on_error = false
-      @retry_on_timeout = true
-      @retry_on_unavailable = true
-      @retry_max = 1
-      @retry_sleep = 4
-      @session_cb = nil
-      @progress_bar = nil
-      @spinner_cb = nil
-    end
-  end
-
-  class EntityNotFound < Error
-  end
-
-  module Mime
-    JSON = 'application/json'
-    WWW = 'application/x-www-form-urlencoded'
-    TEXT = 'text/plain'
-    # Check if a MIME type is JSON, including parameters, e.g. application/json; charset=utf-8
-    def json?(mime)
-      JSON_LIST.include?(mime)
-    end
-    module_function :json?
-    # Content-Type that are JSON
-    JSON_LIST = [JSON, 'application/vnd.api+json', 'application/x-javascript'].freeze
-    private_constant :JSON_LIST
-  end
-
-  # Make HTTP calls, equivalent to rest-client
-  # rest call errors are raised as exception RestCallError
-  # and error are analyzed in RestErrorAnalyzer
-  class Rest
-    class << self
-      # Build a Basic authentication header value
-      # @param user [String] Username
-      # @param pass [String] Password
-      # @return [String] Basic auth token
-      def basic_authorization(user, pass); return "Basic #{Base64.strict_encode64("#{user}:#{pass}")}"; end
-
-      # Indicate that the given Hash query uses php style for array parameters
-      # @param query [Hash] A key can have Array value and result will use PHP format: a[]=1&a[]=2
-      # @return [Hash] The query parameters.
-      def php_style(query)
-        Aspera.assert_type(query, Hash) { 'query' }
-        query[:x_array_php_style] = true
-        query
-      end
-
-      # Build URI from URL and parameters and check it is `http` or `https`.
-      # Check if php style is specified.
-      # `nil` values in query result in key without value, e.g. `?a`, while empty string values result in `?a=`.
-      # @param url   [String]            The URL without query.
-      # @param query [Hash,Array,String] The query parameters.
-      # @return [URI] The built URI.
-      def build_uri(url, query)
-        uri = URI.parse(url)
-        Aspera.assert_values(uri.scheme, %w[http https]) { 'URI scheme' }
-        return uri if query.nil? || query.respond_to?(:empty?) && query.empty?
-        Log.dump(:query, query)
-        uri.query =
-          case query
-          when String
-            query
-          when Hash
-            URI.encode_www_form(h_to_query_array(query))
-          when Array
-            Aspera.assert(query.all? { |i| i.is_a?(Array) && i.length.eql?(2) }, 'Query must be array of arrays of 2 elements')
-            URI.encode_www_form(query) # remove nil values
-          else Aspera.error_unexpected_value(query.class) { 'query type' }
-          end.gsub('%5B%5D=', '[]=')
-        # [] is allowed in url parameters
-        uri
-      end
-
-      # Support array for query parameter, there is no standard.
-      # Either p=1&p=2 (default)
-      # or p[]=1&p[]=2 (if `:x_array_php_style` is set to true in query)
-      # @param query [Hash] HTTP query as hash
-      # @return [Array<Array>] Array of [key, value] pairs suitable for URI.encode_www_form
-      def h_to_query_array(query)
-        Aspera.assert_type(query, Hash)
-        suffix = query.delete(:x_array_php_style) ? '[]' : nil
-        query.each_with_object([]) do |(k, v), query_array|
-          case v
-          when Array
-            v.each do |e|
-              query_array.push(["#{k}#{suffix}", e])
-            end
-          else
-            query_array.push([k, v])
-          end
-        end
-      end
-
-      # Decode query string as Hash
-      # if parameter is only once, then it's a scalar
-      # if a parameter is several, then it's array
-      # if parameter has [] then it's an array, and [] is removed
-      # Support arrays in query string, e.g. PHP's way is p[]=1&p[]=2
-      # @param query [String] query string as in URI.query
-      # @return [Hash] decoded query
-      def query_to_h(query)
-        URI.decode_www_form(query).each_with_object({}) do |(key, value), h|
-          if key.end_with?('[]')
-            key = key[..-3]
-            h[key] = [] unless h.key?(key)
-          end
-          if h.key?(key)
-            h[key] = [h[key]] if !h[key].is_a?(Array)
-            h[key].push(value)
-          else
-            h[key] = value
-          end
-        end
-      end
-
-      # Start a HTTP/S session, also used for web sockets
-      # @param base_url [String] Base url of HTTP/S session
-      # @return [Net::HTTP] A started HTTP session
-      def start_http_session(base_url)
-        uri = URI.parse(base_url)
-        Aspera.assert_values(uri.scheme, %w[http https]) { 'URI scheme' }
-        # This honors http_proxy env var
-        http_session = Net::HTTP.new(uri.host, uri.port)
-        http_session.use_ssl = uri.scheme.eql?('https')
-        # Set http options in callback, such as timeout and cert. verification
-        RestParameters.instance.session_cb&.call(http_session)
-        # Manually start session for keep alive (if supported by server, else, session is closed every time)
-        http_session.start
-        return http_session
-      end
-
-      # get Net::HTTP underlying socket i/o
-      # little hack, handy because HTTP debug, proxy, etc... will be available
-      # used implement web sockets after `start_http_session`
-      # @param http_session [Net::HTTP] the session object
-      # @return [Net::BufferedIO] The underlying socket i/o
-      def io_http_session(http_session)
-        Aspera.assert_type(http_session, Net::HTTP)
-        # Net::BufferedIO in net/protocol.rb
-        result = http_session.instance_variable_get(:@socket)
-        Aspera.assert(!result.nil?) { "no socket for #{http_session}" }
-        return result
-      end
-
-      # @return [String] PEM certificates of remote server
-      def remote_certificate_chain(url, as_string: true)
-        result = []
-        # initiate a session to retrieve remote certificate
-        http_session = Rest.start_http_session(url)
-        begin
-          # retrieve underlying openssl socket
-          result = Rest.io_http_session(http_session).io.peer_cert_chain
-        rescue
-          result = http_session.peer_cert
-        ensure
-          http_session.finish
-        end
-        result = result.map(&:to_pem).join("\n") if as_string
-        return result
-      end
-
-      # Parses an HTTP Content-Type header string into its media type and parameters
-      # according to RFC 9110 and RFC 6838.
-      # TODO: use gem: content_type
-      #
-      # @param header [String] The Content-Type header string, e.g., "application/json; charset=utf-8"
-      # @return [Hash] A hash with :type and :parameters keys.
-      #   Example:
-      #     {
-      #       type: "application/json",
-      #       parameters: {
-      #         charset: "utf-8",
-      #         version: "1.0"
-      #       }
-      #     }
-      def parse_header(header)
-        parts = header.split(';').map(&:strip)
-        media_type = parts.shift.downcase
-        parameters = parts.filter_map do |param|
-          key, value = param.split('=', 2)
-          next unless key && value
-          key = key.strip.downcase.to_sym
-          value = value.strip.gsub(/\A"|"\z/, '')
-          [key, value]
-        end.to_h
-        {type: media_type, parameters: parameters}
-      end
-    end
-
-    private
-
-    # create and start keep alive connection on demand
-    def http_session
-      @http_session = self.class.start_http_session(@base_url) if @http_session.nil?
-      return @http_session
-    end
-
-    public
-
-    # All original constructor parameters
-    attr_reader :auth_params
-
-    # The root URL for the API
-    attr_reader :base_url
-
-    # Base common headers of API
-    attr_reader :headers
-
-    # @return [Hash] creation parameters
-    def params
-      return {
-        base_url:       @base_url,       # String
-        auth:           @auth_params,    # Hash
-        not_auth_codes: @not_auth_codes, # Array
-        redirect_max:   @redirect_max,   # Integer
-        headers:        @headers         # Hash
-      }
-    end
-
-    # Create a REST object for API calls
-    # HTTP sessions parameters can be modified using global parameters in RestParameters
-    # For example, TLS verification can be skipped.
-    # @param base_url [String] base URL of REST API
-    # @param auth [Hash] authentication parameters:
-    #     :type (:none, :basic, :url, :oauth2)
-    #     :username   [:basic]
-    #     :password   [:basic]
-    #     :url_query  [:url]    a hash
-    #     :*          [:oauth2] see OAuth::Factory class
-    # @param not_auth_codes [Array]   codes that trigger a refresh/regeneration of bearer token
-    # @param redirect_max   [Integer] max redirection allowed
-    # @param headers        [Hash]    default headers to include in all calls
-    def initialize(
-      base_url:,
-      auth: {type: :none},
-      not_auth_codes: ['401'],
-      redirect_max: 0,
-      headers: {}
-    )
-      Aspera.assert_type(base_url, String)
-      # base url with no trailing slashes (note: string may be frozen)
-      @base_url = base_url.chomp('/')
-      # remove trailing port if it is 443 and scheme is https
-      @base_url = @base_url.gsub(/:443$/, '') if @base_url.start_with?('https://')
-      @base_url = @base_url.gsub(/:80$/, '') if @base_url.start_with?('http://')
-      Log.log.debug { "Rest.new(#{@base_url})" }
-      # default is no auth
-      @auth_params = auth
-      Aspera.assert_type(@auth_params, Hash)
-      Aspera.assert(@auth_params.key?(:type), 'no auth type defined')
-      @not_auth_codes = not_auth_codes
-      Aspera.assert_type(@not_auth_codes, Array)
-      # persistent session
-      @http_session = nil
-      @redirect_max = redirect_max
-      Aspera.assert_type(@redirect_max, Integer)
-      @headers = headers.clone
-      Aspera.assert_type(@headers, Hash)
-      @headers['User-Agent'] ||= RestParameters.instance.user_agent
-      # OAuth object (created on demand)
-      @oauth = nil
-    end
-
-    # @return [OAuth::Base] the OAuth object (create, or cached if already created)
-    def oauth
-      if @oauth.nil?
-        Aspera.assert(@auth_params[:type].eql?(:oauth2), 'no OAuth defined')
-        oauth_parameters = @auth_params.reject { |k, _v| k.eql?(:type) }
-        Log.dump(:oauth_parameters, oauth_parameters)
-        @oauth = OAuth::Factory.instance.create(**oauth_parameters)
-      end
-      return @oauth
-    end
-
-    # HTTP/S REST call
-    # @param operation    [String] HTTP operation (GET, POST, PUT, DELETE)
-    # @param subpath      [String] subpath of REST API
-    # @param query        [Hash{String,Symbol => Object}] URL parameters
-    # @param content_type [String, nil] Type of body parameters (one of MIME_*) and serialization, else use headers
-    # @param body         [Hash, String, nil] Body parameters
-    # @param headers      [Hash{String => String}] Additional headers (override Content-Type)
-    # @param save_to      [String, IO, nil] File path or IO object to save response body; progress bar is used when set
-    # @param exception    [Boolean] Whether to raise an exception on HTTP error
-    # @param ret          [Symbol] One of :data, :resp, :both - controls return value
-    # @return [Array(Hash, Net::HTTPResponse)] When `ret` is :both
-    # @return [Net::HTTPResponse] When `ret` is :resp
-    # @return [Hash] When `ret` is :data
-    # @raise [RestCallError] on error if `exception` is true
-    def call(
-      operation:,
-      subpath: nil,
-      query: nil,
-      content_type: nil,
-      body: nil,
-      headers: nil,
-      save_to: nil,
-      exception: true,
-      ret: :data
-    )
-      subpath = subpath.to_s if subpath.is_a?(Symbol)
-      subpath = '' if subpath.nil?
-      Log.log.debug { "call #{operation} [#{subpath}]".red.bold.bg_green }
-      Log.dump(:body, body, level: :trace1)
-      Log.dump(:query, query, level: :trace1)
-      Log.dump(:headers, headers, level: :trace1)
-      Aspera.assert_type(subpath, String)
-      # We must have a way to check return code
-      Aspera.assert(exception || !ret.eql?(:data), 'ret: :data requires exception handler')
-      headers, query = prepare_call(headers, query)
-      result_http = nil
-      result_data = nil
-      # initialize with number of initial retries allowed, nil gives zero
-      tries_remain_redirect = @redirect_max
-      # start a block to be able to retry the actual HTTP request in case of OAuth token expiration
-      begin
-        Log.log.debug("send request (retries=#{tries_remain_redirect})")
-        req = build_request(operation, subpath, query, content_type, body, headers)
-        # we try the call, and will retry on some error types
-        error_tries ||= 1 + RestParameters.instance.retry_max
-        result_mime = nil
-        file_saved = false
-        # make http request (pipelined)
-        http_session.request(req) do |response|
-          result_http = response
-          result_mime = self.class.parse_header(result_http['Content-Type'] || Mime::TEXT)[:type]
-          Log.log.debug { "response: code=#{result_http.code}, mime=#{result_mime}, content-type=#{response['Content-Type']}" }
-          # JSON data needs to be parsed, in case it contains an error code
-          file_saved = save_response(response, result_http, result_mime, save_to)
-        end
-        Log.log.debug { "result: code=#{result_http.code} mime=#{result_mime}" }
-        # sometimes there is a UTF8 char (e.g. (c) )
-        # TODO : related to mime type encoding ?
-        # result_http.body.force_encoding('UTF-8') if result_http.body.is_a?(String)
-        # Log.log.debug{"result: body=#{result_http.body}"}
-        result_data = parse_response(result_http, result_mime)
-        RestErrorAnalyzer.instance.raise_on_error(req, result_data, result_http)
-        unless file_saved || save_to.nil?
-          raise 'save_to: IO object requires a streaming response' if save_to.respond_to?(:write)
-          FileUtils.mkdir_p(File.dirname(save_to))
-          File.write(save_to, result_http.body, binmode: true)
-        end
-      rescue RestCallError => e
-        do_retry = false
-        # AoC have some timeout , like Connect to platform.bss.asperasoft.com:443 ...
-        do_retry ||= true if e.response.body.include?('failed: connect timed out') && RestParameters.instance.retry_on_timeout
-        # AoC sometimes not available
-        do_retry ||= true if RestParameters.instance.retry_on_unavailable && UNAVAILABLE_CODES.include?(result_http.code.to_s)
-        # possibility to retry anything if it fails
-        do_retry ||= true if RestParameters.instance.retry_on_error
-        # not authorized: oauth token expired
-        if @not_auth_codes.include?(result_http.code.to_s) && @auth_params[:type].eql?(:oauth2)
-          begin
-            # try to use refresh token
-            req['Authorization'] = oauth.authorization(refresh: true)
-          rescue RestCallError => e_tok
-            e = e_tok
-            Log.log.error('refresh failed'.bg_red)
-            # regenerate a brand new token
-            req['Authorization'] = oauth.authorization(cache: false)
-          end
-          Log.log.debug('using new token')
-          do_retry ||= true
-        end
-        if do_retry && (error_tries -= 1).positive?
-          sleep(RestParameters.instance.retry_sleep) unless RestParameters.instance.retry_sleep.eql?(0)
-          retry
-        end
-        # redirect ? (any code beginning with 3)
-        if e.response.is_a?(Net::HTTPRedirection) && tries_remain_redirect.positive?
-          tries_remain_redirect -= 1
-          current_uri = URI.parse(@base_url)
-          new_url = e.response['Location']
-          # special case: relative redirect
-          if URI.parse(new_url).host.nil?
-            # we don't manage relative redirects with non-absolute path
-            Aspera.assert(new_url.start_with?('/')) { "redirect location is relative: #{new_url}, but does not start with /." }
-            new_url = "#{current_uri.scheme}://#{current_uri.host}#{new_url}"
-          end
-          # forwards the request to the new location
-          return self.class.new(
-            base_url: new_url,
-            redirect_max: tries_remain_redirect
-          ).call(
-            operation: operation,
-            subpath: new_url.end_with?('/') ? '/' : nil,
-            query: query,
-            body: body,
-            content_type: content_type,
-            save_to: save_to,
-            exception: exception,
-            headers: headers,
-            ret: ret
-          )
-        end
-        # raise exception if could not retry and not return error in result
-        raise e if exception
-      end
-      Log.log.debug { "result=http:#{result_http}, data:#{result_data.class}" }
-      return case ret
-             when :data then result_data
-             when :resp then result_http
-             when :both then [result_data, result_http]
-             else Aspera.error_unexpected_value(ret) { 'Type of result for REST' }
-             end
-    end
-
-    private
-
-    def prepare_call(headers, query)
-      if headers.nil?
-        headers = @headers.clone
-      else
-        h = headers
-        headers = @headers.clone
-        headers.merge!(h)
-      end
-      Aspera.assert_type(headers, Hash)
-      case @auth_params[:type]
-      when :none
-        # no auth
-      when :basic
-        Log.log.debug('using Basic auth')
-        # done in build_req
-      when :oauth2
-        headers['Authorization'] = oauth.authorization unless headers.key?('Authorization')
-      when :url
-        query ||= {}
-        @auth_params[:url_query].each do |key, value|
-          query[key] = value
-        end
-      else Aspera.error_unexpected_value(@auth_params[:type])
-      end
-      [headers, query]
-    end
-
-    def build_request(operation, subpath, query, content_type, body, headers)
-      # TODO: shall we percent encode subpath (spaces) test with access key delete with space in id
-      # URI.escape()
-      separator = ['', '/'].include?(subpath) ? '' : '/'
-      uri = self.class.build_uri("#{@base_url}#{separator}#{subpath}", query)
-      Log.log.debug { "URI=#{uri}" }
-      begin
-        # instantiate request object based on string name
-        req = Net::HTTP.const_get(operation.capitalize).new(uri)
-      rescue NameError
-        raise "unsupported operation : #{operation}"
-      end
-      case content_type
-      when nil # ignore
-      when Mime::JSON
-        req.body = JSON.generate(body) # , ascii_only: true
-        req['Content-Type'] = Mime::JSON
-      when Mime::WWW
-        req.body = URI.encode_www_form(body)
-        req['Content-Type'] = Mime::WWW
-      when Mime::TEXT
-        req.body = body
-        req['Content-Type'] = Mime::TEXT
-      else Aspera.error_unexpected_value(content_type) { 'body type' }
-      end
-      # set headers
-      headers.each do |key, value|
-        req[key] = value
-      end
-      # :type = :basic
-      req.basic_auth(@auth_params[:username], @auth_params[:password]) if @auth_params[:type].eql?(:basic)
-      Log.dump(:req_body, req.body, level: :trace1)
-      req
-    end
-
-    def save_response(response, result_http, result_mime, save_to)
-      return false unless !save_to.nil? && result_http.code.to_s.start_with?('2') && !Mime.json?(result_mime)
-
-      total_size = result_http['Content-Length']&.to_i
-      Log.log.debug('before write file')
-      target_file = save_to
-      # override user's path to path in header
-      unless response['Content-Disposition'].nil?
-        disposition = self.class.parse_header(response['Content-Disposition'])
-        if disposition[:parameters].key?(:filename) && !disposition[:parameters][:filename].eql?('.')
-          # Use only the basename to prevent path traversal via a server-controlled Content-Disposition header
-          safe_filename = File.basename(disposition[:parameters][:filename])
-          target_file = File.join(File.dirname(target_file), safe_filename) unless safe_filename.empty?
-        end
-      end
-      Log.log.debug { "saving to: #{target_file}" }
-      written_size = 0
-      session_id = SecureRandom.uuid.freeze
-      RestParameters.instance.progress_bar&.event(:session_start, session_id: session_id)
-      RestParameters.instance.progress_bar&.event(:session_size, session_id: session_id, info: total_size) if total_size
-      limiter = TimerLimiter.new(0.5)
-      if target_file.respond_to?(:write)
-        # IO object: stream directly into it
-        result_http.read_body do |fragment|
-          target_file.write(fragment)
-          written_size += fragment.length
-          RestParameters.instance.progress_bar&.event(:transfer, session_id: session_id, info: written_size) if limiter.trigger?
-        end
-      else
-        # file path: download to partial name first, then rename atomically
-        target_file_tmp = "#{target_file}#{RestParameters.instance.download_partial_suffix}"
-        FileUtils.mkdir_p(File.dirname(target_file_tmp))
-        File.open(target_file_tmp, 'wb') do |file|
-          result_http.read_body do |fragment|
-            file.write(fragment)
-            written_size += fragment.length
-            RestParameters.instance.progress_bar&.event(:transfer, session_id: session_id, info: written_size) if limiter.trigger?
-          end
-        end
-        File.rename(target_file_tmp, target_file)
-      end
-      RestParameters.instance.progress_bar&.event(:session_end, session_id: session_id)
-      RestParameters.instance.progress_bar&.event(:end)
-      true
-    end
-
-    def parse_response(result_http, result_mime)
-      result_data = result_http.body
-      Log.dump(:result_data_raw, result_data, level: :trace1)
-      # TODO: Remove next 2 lines when bug in async node api is fixed. (Aspera/core/issues/4490)
-      node_api_bug = result_data&.index('}HTTP/1.1 400 Bad Request') if result_data.is_a?(String)
-      result_data = result_data[0..node_api_bug] if node_api_bug
-      result_data = JSON.parse(result_data) if Mime.json?(result_mime) && !result_data.nil? && !result_data.empty?
-      Log.dump(:result_data, result_data)
-      result_data
-    end
-
-    public
-
-    #
-    # CRUD simplified methods here
-    # If specific elements are needed, then use the full `call` method
-    #
-
-    # Create: `POST`
-    def create(subpath, params, **kwargs)
-      kwargs[:headers] ||= {}
-      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
-      kwargs[:content_type] = Mime::JSON unless kwargs.key?(:content_type)
-      return call(operation: 'POST', subpath: subpath, body: params, **kwargs)
-    end
-
-    # Read: `GET`
-    def read(subpath, query = nil, **kwargs)
-      kwargs[:headers] ||= {}
-      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
-      return call(operation: 'GET', subpath: subpath, query: query, **kwargs)
-    end
-
-    # Update: `PUT`
-    def update(subpath, params, **kwargs)
-      kwargs[:headers] ||= {}
-      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
-      kwargs[:content_type] = Mime::JSON unless kwargs.key?(:content_type)
-      return call(operation: 'PUT', subpath: subpath, body: params, **kwargs)
-    end
-
-    # Delete: `DELETE`
-    def delete(subpath, params = nil, **kwargs)
-      kwargs[:headers] ||= {}
-      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
-      return call(operation: 'DELETE', subpath: subpath, query: params, **kwargs)
-    end
-
-    # Cancel: `CANCEL`
-    def cancel(subpath, **kwargs)
-      kwargs[:headers] ||= {}
-      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
-      return call(operation: 'CANCEL', subpath: subpath, **kwargs)
-    end
-
-    UNAVAILABLE_CODES = ['503']
-
-    private_constant :UNAVAILABLE_CODES
-  end
-end
+require 'aspera/rest/parameters'
+require 'aspera/rest/util'
+require 'aspera/rest/call_error'
+require 'aspera/rest/error_analyzer'
+require 'aspera/rest/aspera_errors'
+require 'aspera/rest/client'
+require 'aspera/rest/list'