nucleus 0.1.0 → 0.2.0

data/lib/nucleus/adapters/v1/heroku/heroku.rb

@@ -127,7 +127,6 @@ module Nucleus
                 latest_version_id = release[:id]
               end
             end
-            latest_version_id
           else
             latest_version = 0
             latest_version_id = nil
@@ -137,8 +136,9 @@ module Nucleus
                 latest_version_id = dyno[:release][:id]
               end
             end
-            latest_version_id
           end
+
+          latest_version_id
         end
       end
     end

data/lib/nucleus/adapters/v1/heroku/logs.rb

@@ -1,108 +1,108 @@
-module Nucleus
-  module Adapters
-    module V1
-      class Heroku < Stub
-        module Logs
-          # Carriage return (newline in Mac OS) + line feed (newline in Unix) == CRLF (newline in Windows)
-          CRLF = "\r\n"
-
-          # @see Stub#logs
-          def logs(application_id)
-            # fails with 404 if application is not available and serves for timestamps
-            app = get("/apps/#{application_id}").body
-
-            available_log_files = []
-            available_log_types.keys.each do |type|
-              # TODO: right now, we always assume the log has recently been updated
-              available_log_files.push(id: type, name: type, type: type,
-                                       created_at: app[:created_at], updated_at: Time.now.utc.iso8601)
-            end
-            available_log_files
-          end
-
-          # @see Stub#log?
-          def log?(application_id, log_id)
-            # fails with 404 if application is not available
-            get("/apps/#{application_id}")
-
-            return true if log_id.to_sym == :all
-            return true if log_id.to_sym == :build
-            available_log_types.key? log_id.to_sym
-          end
-
-          # @see Stub#log_entries
-          def log_entries(application_id, log_id)
-            unless log?(application_id, log_id)
-              fail Errors::AdapterResourceNotFoundError,
-                   "Invalid log file '#{log_id}', not available for application '#{application_id}'"
-            end
-
-            return build_log_entries(application_id) if log_id.to_sym == Enums::ApplicationLogfileType::BUILD
-
-            request_body = request_body(log_id.to_sym).merge(tail: false)
-            log = post("/apps/#{application_id}/log-sessions", body: request_body).body
-            logfile = get(log[:logplex_url], headers: {}).body
-            # process to entries
-            entries = []
-            # skip empty logs, which are detected as Hash by the http client
-            logfile.split(CRLF).each { |logfile_line| entries.push logfile_line } unless logfile == {}
-            entries
-          end
-
-          # @see Stub#tail
-          def tail(application_id, log_id, stream)
-            # Currently no tailing for build log possible
-            if log_id == Enums::ApplicationLogfileType::BUILD
-              entries = build_log_entries(application_id)
-              entries.each { |entry| stream.send_message(entry) }
-              stream.close
-            else
-              request_body = request_body(log_id.to_sym).merge(tail: true)
-              log = post("/apps/#{application_id}/log-sessions", body: request_body).body
-              tail_http_response(log[:logplex_url], stream)
-            end
-          end
-
-          private
-
-          def available_log_types
-            log_types = {}
-            log_types[Enums::ApplicationLogfileType::API] = { source: 'heroku', dyno: 'api' }
-            log_types[Enums::ApplicationLogfileType::APPLICATION] = { source: 'app' }
-            log_types[Enums::ApplicationLogfileType::REQUEST] = { source: 'heroku', dyno: 'router' }
-            # TODO: filter only for web and worker dynos (must be merged manually :/)
-            log_types[Enums::ApplicationLogfileType::SYSTEM] = { source: 'heroku' }
-            log_types
-          end
-
-          def request_body(log_id)
-            return {} if log_id == :all
-            available_log_types[log_id]
-          end
-
-          def build_log_entries(application_id)
-            build_list = get("/apps/#{application_id}/builds").body
-            # limitation: show only the last 3 builds
-            entries = []
-            build_list.last(3).each do |build|
-              entries.push(*build_result_entries(application_id, build[:id]))
-            end
-            entries
-          end
-
-          def build_result_entries(application_id, build_id)
-            build_result = get("/apps/#{application_id}/builds/#{build_id}/result").body
-            entries = []
-            build_result[:lines].each do |line_entry|
-              # skip all blank lines
-              next if line_entry[:line].strip.empty?
-              # push and remove all trailing newline characters
-              entries.push line_entry[:line].chomp('')
-            end
-            entries
-          end
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Logs
+          # Carriage return (newline in Mac OS) + line feed (newline in Unix) == CRLF (newline in Windows)
+          CRLF = "\r\n".freeze
+
+          # @see Stub#logs
+          def logs(application_id)
+            # fails with 404 if application is not available and serves for timestamps
+            app = get("/apps/#{application_id}").body
+
+            available_log_files = []
+            available_log_types.keys.each do |type|
+              # TODO: right now, we always assume the log has recently been updated
+              available_log_files.push(id: type, name: type, type: type,
+                                       created_at: app[:created_at], updated_at: Time.now.utc.iso8601)
+            end
+            available_log_files
+          end
+
+          # @see Stub#log?
+          def log?(application_id, log_id)
+            # fails with 404 if application is not available
+            get("/apps/#{application_id}")
+
+            return true if log_id.to_sym == :all
+            return true if log_id.to_sym == :build
+            available_log_types.key? log_id.to_sym
+          end
+
+          # @see Stub#log_entries
+          def log_entries(application_id, log_id)
+            unless log?(application_id, log_id)
+              fail Errors::AdapterResourceNotFoundError,
+                   "Invalid log file '#{log_id}', not available for application '#{application_id}'"
+            end
+
+            return build_log_entries(application_id) if log_id.to_sym == Enums::ApplicationLogfileType::BUILD
+
+            request_body = request_body(log_id.to_sym).merge(tail: false)
+            log = post("/apps/#{application_id}/log-sessions", body: request_body).body
+            logfile = get(log[:logplex_url], headers: {}).body
+            # process to entries
+            entries = []
+            # skip empty logs, which are detected as Hash by the http client
+            logfile.split(CRLF).each { |logfile_line| entries.push logfile_line } unless logfile == {}
+            entries
+          end
+
+          # @see Stub#tail
+          def tail(application_id, log_id, stream)
+            # Currently no tailing for build log possible
+            if log_id == Enums::ApplicationLogfileType::BUILD
+              entries = build_log_entries(application_id)
+              entries.each { |entry| stream.send_message(entry) }
+              stream.close
+            else
+              request_body = request_body(log_id.to_sym).merge(tail: true)
+              log = post("/apps/#{application_id}/log-sessions", body: request_body).body
+              tail_http_response(log[:logplex_url], stream)
+            end
+          end
+
+          private
+
+          def available_log_types
+            log_types = {}
+            log_types[Enums::ApplicationLogfileType::API] = { source: 'heroku', dyno: 'api' }
+            log_types[Enums::ApplicationLogfileType::APPLICATION] = { source: 'app' }
+            log_types[Enums::ApplicationLogfileType::REQUEST] = { source: 'heroku', dyno: 'router' }
+            # TODO: filter only for web and worker dynos (must be merged manually :/)
+            log_types[Enums::ApplicationLogfileType::SYSTEM] = { source: 'heroku' }
+            log_types
+          end
+
+          def request_body(log_id)
+            return {} if log_id == :all
+            available_log_types[log_id]
+          end
+
+          def build_log_entries(application_id)
+            build_list = get("/apps/#{application_id}/builds").body
+            # limitation: show only the last 3 builds
+            entries = []
+            build_list.last(3).each do |build|
+              entries.push(*build_result_entries(application_id, build[:id]))
+            end
+            entries
+          end
+
+          def build_result_entries(application_id, build_id)
+            build_result = get("/apps/#{application_id}/builds/#{build_id}/result").body
+            entries = []
+            build_result[:lines].each do |line_entry|
+              # skip all blank lines
+              next if line_entry[:line].strip.empty?
+              # push and remove all trailing newline characters
+              entries.push line_entry[:line].chomp('')
+            end
+            entries
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nucleus/core/adapter_authentication_inductor.rb

@@ -15,8 +15,6 @@ module Nucleus
       end
     end
 
-    private
-
     # Patch the actual method that is defined in an API version stub.
     # The method shall than be able to update the authentication token if the initial authentication expired.<br>
     # Only major authentication issues, e.g. if the credentials are repeatedly rejected,

data/lib/nucleus/core/adapter_extensions/auth/http_basic_auth_client.rb

@@ -1,37 +1,37 @@
-module Nucleus
-  module Adapters
-    # Implementation of the AuthClient that works with the HTTP basic authentication.
-    class HttpBasicAuthClient < AuthClient
-      # Create a new instance of an {HttpBasicAuthClient}.
-      # @param [Boolean] check_certificates true if SSL certificates are to be validated,
-      # false if they are to be ignored (e.g. when using self-signed certificates in development environments)
-      # @yield [verify_ssl, username, password] Auth credentials verification block,
-      # must check if the combination of username and password is accepted by the endpoint.
-      # @yieldparam [Hash<String,String>] headers headers for an HTTP request,
-      # including the authentication header to be tested
-      # @yieldreturn [Boolean] true if the authentication was verified to be ok,
-      # false if an error occurred, e.g. with bad credentials
-      def initialize(check_certificates = true, &verification)
-        @verification = verification
-        super(check_certificates)
-      end
-
-      # @see AuthClient#authenticate
-      def authenticate(username, password)
-        packed_credentials = ["#{username}:#{password}"].pack('m*').gsub(/\n/, '')
-        valid = @verification.call(verify_ssl, 'Authorization' => "Basic #{packed_credentials}")
-        fail Errors::EndpointAuthenticationError, 'Authentication failed, credentials seem to be invalid' unless valid
-        # verification passed, credentials are valid
-        @packed_credentials = packed_credentials
-        self
-      end
-
-      # @see AuthClient#auth_header
-      def auth_header
-        fail Errors::EndpointAuthenticationError,
-             'Authentication client was not authenticated yet' unless @packed_credentials
-        { 'Authorization' => "Basic #{@packed_credentials}" }
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    # Implementation of the AuthClient that works with the HTTP basic authentication.
+    class HttpBasicAuthClient < AuthClient
+      # Create a new instance of an {HttpBasicAuthClient}.
+      # @param [Boolean] check_certificates true if SSL certificates are to be validated,
+      # false if they are to be ignored (e.g. when using self-signed certificates in development environments)
+      # @yield [verify_ssl, username, password] Auth credentials verification block,
+      # must check if the combination of username and password is accepted by the endpoint.
+      # @yieldparam [Hash<String,String>] headers headers for an HTTP request,
+      # including the authentication header to be tested
+      # @yieldreturn [Boolean] true if the authentication was verified to be ok,
+      # false if an error occurred, e.g. with bad credentials
+      def initialize(check_certificates = true, &verification)
+        @verification = verification
+        super(check_certificates)
+      end
+
+      # @see AuthClient#authenticate
+      def authenticate(username, password)
+        packed_credentials = ["#{username}:#{password}"].pack('m*').delete("\n")
+        valid = @verification.call(verify_ssl, 'Authorization' => "Basic #{packed_credentials}")
+        fail Errors::EndpointAuthenticationError, 'Authentication failed, credentials seem to be invalid' unless valid
+        # verification passed, credentials are valid
+        @packed_credentials = packed_credentials
+        self
+      end
+
+      # @see AuthClient#auth_header
+      def auth_header
+        fail Errors::EndpointAuthenticationError,
+             'Authentication client was not authenticated yet' unless @packed_credentials
+        { 'Authorization' => "Basic #{@packed_credentials}" }
+      end
+    end
+  end
+end

data/lib/nucleus/core/adapter_extensions/http_client.rb

@@ -1,177 +1,177 @@
-module Nucleus
-  module Adapters
-    module HttpClient
-      # Executes a HEAD request to the given URL.
-      #
-      # @param [String] path path to add to the endpoint URL
-      # @param [Hash] params options to call the post request with
-      # @option params [Array<int>] :expects ([200]) http status code that is expected
-      # @option params [Hash] :headers request headers to use with the request
-      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
-      # unprocessed response
-      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
-      def head(path, params = {})
-        execute_request(:head, [200], path, params, params.delete(:native_call) { false })
-      end
-
-      # Executes a GET request to the given URL.
-      #
-      # @param [String] path path to add to the endpoint URL
-      # @param [Hash] params options to call the post request with
-      # @option params [Array<int>] :expects ([200]) http status code that is expected
-      # @option params [Hash] :headers request headers to use with the request
-      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
-      # unprocessed response
-      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
-      def get(path, params = {})
-        execute_request(:get, [200], path, params, params.delete(:native_call) { false })
-      end
-
-      # Executes a POST request to the given URL.
-      #
-      # @param [String] path path to add to the endpoint URL
-      # @param [Hash] params options to call the post request with
-      # @option params [Array<int>] :expects ([200,201]) http status code that is expected
-      # @option params [Hash] :body request body, will be converted to json format
-      # @option params [Hash] :headers request headers to use with the request
-      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
-      # unprocessed response
-      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
-      def post(path, params = {})
-        execute_request(:post, [200, 201], path, params, params.delete(:native_call) { false })
-      end
-
-      # Executes a PATCH request to the given URL.
-      #
-      # @param [String] path path to add to the endpoint URL
-      # @param [Hash] params options to call the post request with
-      # @option params [Array<int>] :expects ([200,201]) http status code that is expected
-      # @option params [Hash] :body request body, will be converted to json format
-      # @option params [Hash] :headers request headers to use with the request
-      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
-      # unprocessed response
-      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
-      def patch(path, params = {})
-        execute_request(:patch, [200, 201], path, params, params.delete(:native_call) { false })
-      end
-
-      # Executes a PUT request to the given URL.
-      #
-      # @param [String] path path to add to the endpoint URL
-      # @param [Hash] params options to call the post request with
-      # @option params [Array<int>] :expects ([200,201]) http status code that is expected
-      # @option params [Hash] :body request body, will be converted to json format
-      # @option params [Hash] :headers request headers to use with the request
-      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
-      # unprocessed response
-      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
-      def put(path, params = {})
-        execute_request(:put, [200, 201], path, params, params.delete(:native_call) { false })
-      end
-
-      # Executes a DELETE request to the given URL.
-      #
-      # @param [String] path path to add to the endpoint URL
-      # @param [Hash] params options to call the post request with
-      # @option params [Array<int>] :expects ([200,204]) http status code that is expected
-      # @option params [Hash] :headers request headers to use with the request
-      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
-      # unprocessed response
-      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
-      def delete(path, params = {})
-        execute_request(:delete, [200, 204], path, params, params.delete(:native_call) { false })
-      end
-
-      private
-
-      def execute_request(method, default_expect, path, params, native_call = false)
-        params[:expects] = default_expect unless params.key? :expects
-        params[:method] = method
-
-        url = Regexp::PERFECT_URL_PATTERN =~ path ? path : to_url(path)
-        response = Excon.new(url, excon_connection_params(params)).request(add_common_request_params(params))
-        # we never want the JSON string, but always the hash representation
-        response.body = hash_of(response.body)
-        response
-      rescue Excon::Errors::HTTPStatusError => e
-        handle_execute_request_error(e, url, native_call)
-      end
-
-      def handle_execute_request_error(e, url, native_call)
-        log.debug 'ERROR, Excon could not execute the request.'
-        # transform json response to Hash object
-        e.response.body = hash_of(e.response.body)
-
-        # if this is a native API call, do not further process the error
-        return e.response if native_call
-
-        # fail with adapter specific error handling
-        handle_error(e.response) if respond_to?(:handle_error)
-        fallback_error_handling(e, url)
-      end
-
-      def fallback_error_handling(e, url)
-        error_status = e.response.status
-        # arriving here, error could not be processed --> use fallback errors
-        if e.is_a? Excon::Errors::ServerError
-          fail Errors::UnknownAdapterCallError, e.message
-        elsif error_status == 404
-          log.error("Resource not found (404) at '#{url}', indicating an adapter issue")
-          fail Errors::UnknownAdapterCallError, 'Resource not found, probably the adapter must be updated'
-        elsif error_status == 401
-          fail Errors::EndpointAuthenticationError,
-               'Auth. failed, probably cache is outdated or permissions were revoked?'
-        else
-          log.error("Fallback error handling (#{error_status}) at '#{url}', indicating an adapter issue")
-          fail Errors::UnknownAdapterCallError, e.message
-        end
-      end
-
-      def to_url(path)
-        # insert missing slash, prevent double slashes
-        return "#{@endpoint_url}/#{path}" unless @endpoint_url.end_with?('/') || path.start_with?('/')
-        "#{@endpoint_url}#{path}"
-      end
-
-      def excon_connection_params(params)
-        middleware = Excon.defaults[:middlewares].dup
-
-        if params[:follow_redirects] == false
-          middleware = [Excon::Middleware::ResponseParser, Excon::Middleware::Decompress].push(*middleware).uniq
-        else
-          middleware = [Excon::Middleware::ResponseParser, Excon::Middleware::RedirectFollower,
-                        Excon::Middleware::Decompress].push(*middleware).uniq
-        end
-        { middlewares: middleware, ssl_verify_peer: @check_certificates }
-      end
-
-      def hash_of(message_body)
-        return {} if message_body.nil? || message_body.empty?
-        begin
-          return Oj.load(message_body, symbol_keys: true)
-        rescue Oj::Error
-          # parsing failed, content probably is no valid JSON content
-          message_body
-        end
-      end
-
-      def add_common_request_params(params)
-        common_params = { connection_timeout: 610, write_timeout: 600, read_timeout: 600 }
-        # allow to follow redirects in the APIs
-        allowed_status_codes = params.key?(:expects) ? [*params[:expects]] : []
-        unless params[:follow_redirects] == false
-          allowed_status_codes.push(*[301, 302, 303, 307, 308])
-        end
-
-        params[:expects] = allowed_status_codes.uniq
-        # use default or customized headers
-        params[:headers] = headers unless params[:headers]
-        # specify encoding if not done yet: use only gzip since deflate does cause issues with VCR cassettes in tests
-        params[:headers]['Accept-Encoding'] = 'gzip' unless params[:headers].key? 'Accept-Encoding'
-        params[:body] = params[:body].to_json if params.key? :body
-        # merge and return
-        common_params.merge params
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module HttpClient
+      # Executes a HEAD request to the given URL.
+      #
+      # @param [String] path path to add to the endpoint URL
+      # @param [Hash] params options to call the post request with
+      # @option params [Array<int>] :expects ([200]) http status code that is expected
+      # @option params [Hash] :headers request headers to use with the request
+      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
+      # unprocessed response
+      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
+      def head(path, params = {})
+        execute_request(:head, [200], path, params, params.delete(:native_call) { false })
+      end
+
+      # Executes a GET request to the given URL.
+      #
+      # @param [String] path path to add to the endpoint URL
+      # @param [Hash] params options to call the post request with
+      # @option params [Array<int>] :expects ([200]) http status code that is expected
+      # @option params [Hash] :headers request headers to use with the request
+      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
+      # unprocessed response
+      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
+      def get(path, params = {})
+        execute_request(:get, [200], path, params, params.delete(:native_call) { false })
+      end
+
+      # Executes a POST request to the given URL.
+      #
+      # @param [String] path path to add to the endpoint URL
+      # @param [Hash] params options to call the post request with
+      # @option params [Array<int>] :expects ([200,201]) http status code that is expected
+      # @option params [Hash] :body request body, will be converted to json format
+      # @option params [Hash] :headers request headers to use with the request
+      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
+      # unprocessed response
+      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
+      def post(path, params = {})
+        execute_request(:post, [200, 201], path, params, params.delete(:native_call) { false })
+      end
+
+      # Executes a PATCH request to the given URL.
+      #
+      # @param [String] path path to add to the endpoint URL
+      # @param [Hash] params options to call the post request with
+      # @option params [Array<int>] :expects ([200,201]) http status code that is expected
+      # @option params [Hash] :body request body, will be converted to json format
+      # @option params [Hash] :headers request headers to use with the request
+      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
+      # unprocessed response
+      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
+      def patch(path, params = {})
+        execute_request(:patch, [200, 201], path, params, params.delete(:native_call) { false })
+      end
+
+      # Executes a PUT request to the given URL.
+      #
+      # @param [String] path path to add to the endpoint URL
+      # @param [Hash] params options to call the post request with
+      # @option params [Array<int>] :expects ([200,201]) http status code that is expected
+      # @option params [Hash] :body request body, will be converted to json format
+      # @option params [Hash] :headers request headers to use with the request
+      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
+      # unprocessed response
+      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
+      def put(path, params = {})
+        execute_request(:put, [200, 201], path, params, params.delete(:native_call) { false })
+      end
+
+      # Executes a DELETE request to the given URL.
+      #
+      # @param [String] path path to add to the endpoint URL
+      # @param [Hash] params options to call the post request with
+      # @option params [Array<int>] :expects ([200,204]) http status code that is expected
+      # @option params [Hash] :headers request headers to use with the request
+      # @option params [Boolean] :native_call if true the request is a native API call and shall return the
+      # unprocessed response
+      # @raise [Nucleus::Errors::AdapterError] if the call failed and did not return the expected code(s)
+      def delete(path, params = {})
+        execute_request(:delete, [200, 204], path, params, params.delete(:native_call) { false })
+      end
+
+      private
+
+      def execute_request(method, default_expect, path, params, native_call = false)
+        params[:expects] = default_expect unless params.key? :expects
+        params[:method] = method
+
+        url = Regexp::PERFECT_URL_PATTERN =~ path ? path : to_url(path)
+        response = Excon.new(url, excon_connection_params(params)).request(add_common_request_params(params))
+        # we never want the JSON string, but always the hash representation
+        response.body = hash_of(response.body)
+        response
+      rescue Excon::Errors::HTTPStatusError => e
+        handle_execute_request_error(e, url, native_call)
+      end
+
+      def handle_execute_request_error(e, url, native_call)
+        log.debug 'ERROR, Excon could not execute the request.'
+        # transform json response to Hash object
+        e.response.body = hash_of(e.response.body)
+
+        # if this is a native API call, do not further process the error
+        return e.response if native_call
+
+        # fail with adapter specific error handling
+        handle_error(e.response) if respond_to?(:handle_error)
+        fallback_error_handling(e, url)
+      end
+
+      def fallback_error_handling(e, url)
+        error_status = e.response.status
+        # arriving here, error could not be processed --> use fallback errors
+        if e.is_a? Excon::Errors::ServerError
+          fail Errors::UnknownAdapterCallError, e.message
+        elsif error_status == 404
+          log.error("Resource not found (404) at '#{url}', indicating an adapter issue")
+          fail Errors::UnknownAdapterCallError, 'Resource not found, probably the adapter must be updated'
+        elsif error_status == 401
+          fail Errors::EndpointAuthenticationError,
+               'Auth. failed, probably cache is outdated or permissions were revoked?'
+        else
+          log.error("Fallback error handling (#{error_status}) at '#{url}', indicating an adapter issue")
+          fail Errors::UnknownAdapterCallError, e.message
+        end
+      end
+
+      def to_url(path)
+        # insert missing slash, prevent double slashes
+        return "#{@endpoint_url}/#{path}" unless @endpoint_url.end_with?('/') || path.start_with?('/')
+        "#{@endpoint_url}#{path}"
+      end
+
+      def excon_connection_params(params)
+        middleware = Excon.defaults[:middlewares].dup
+
+        middleware = if params[:follow_redirects] == false
+                       [Excon::Middleware::ResponseParser, Excon::Middleware::Decompress].push(*middleware).uniq
+                     else
+                       [Excon::Middleware::ResponseParser, Excon::Middleware::RedirectFollower,
+                        Excon::Middleware::Decompress].push(*middleware).uniq
+                     end
+        { middlewares: middleware, ssl_verify_peer: @check_certificates }
+      end
+
+      def hash_of(message_body)
+        return {} if message_body.nil? || message_body.empty?
+        begin
+          return Oj.load(message_body, symbol_keys: true)
+        rescue Oj::Error
+          # parsing failed, content probably is no valid JSON content
+          message_body
+        end
+      end
+
+      def add_common_request_params(params)
+        common_params = { connection_timeout: 610, write_timeout: 600, read_timeout: 600 }
+        # allow to follow redirects in the APIs
+        allowed_status_codes = params.key?(:expects) ? [*params[:expects]] : []
+        unless params[:follow_redirects] == false
+          allowed_status_codes.push(*[301, 302, 303, 307, 308])
+        end
+
+        params[:expects] = allowed_status_codes.uniq
+        # use default or customized headers
+        params[:headers] = headers unless params[:headers]
+        # specify encoding if not done yet: use only gzip since deflate does cause issues with VCR cassettes in tests
+        params[:headers]['Accept-Encoding'] = 'gzip' unless params[:headers].key? 'Accept-Encoding'
+        params[:body] = params[:body].to_json if params.key? :body
+        # merge and return
+        common_params.merge params
+      end
+    end
+  end
+end