onlinepayments-sdk-ruby 4.23.0 → 5.0.0

data/lib/onlinepayments/sdk/defaultimpl/default_connection.rb

@@ -1,365 +0,0 @@
-require 'securerandom'
-require 'uri'
-require 'httpclient'
-require 'onlinepayments/sdk/multipart_form_data_object'
-require 'onlinepayments/sdk/pooled_connection'
-require 'onlinepayments/sdk/communication_exception'
-require 'onlinepayments/sdk/response_header'
-
-# @private :nodoc: this is not our class
-module RefineHTTPClient
-  refine HTTPClient do
-    # (monkey) patch to gain access to the session pool size in HTTPClient
-    def session_count
-      sess_pool = @session_manager.instance_variable_get(:@sess_pool)
-      sess_pool.size
-    end
-  end
-end
-
-module OnlinePayments::SDK
-  module DefaultImpl
-    class DefaultConnection < PooledConnection
-      using RefineHTTPClient
-
-      CONTENT_TYPE = 'Content-Type'.freeze
-      X_REQUEST_ID_HEADER = 'X-Request-Id'.freeze
-      JSON_CONTENT_TYPE = 'application/json'.freeze
-
-      # @param args [Hash] the parameters to initialize the connection with
-      # @option args [Integer] :connect_timeout connection timeout in seconds.
-      #              Uses {CommunicatorConfiguration.default_connect_timeout} if not given.
-      # @option args [Integer] :socket_timeout socket timeout in seconds.
-      #              Uses {CommunicatorConfiguration.default_socket_timeout} if not given.
-      # @option args [Integer] :max_connections number of connections kept alive in the thread pool.
-      #              Uses {CommunicatorConfiguration.default_max_connections} if not given.
-      # @option args [Hash] :proxy_configuration object that stores the proxy to use.
-      #              If not given the system default proxy is used;
-      #              if there is no system default proxy set either, no proxy is used.
-      def initialize(args)
-        raise ArgumentError unless args.is_a? Hash
-
-        super()
-
-        # Set timeouts to nil if they are negative
-        @connect_timeout = args[:connect_timeout] || CommunicatorConfiguration.default_connect_timeout
-        @connect_timeout = nil unless @connect_timeout&.positive?
-        @socket_timeout = args[:socket_timeout] || CommunicatorConfiguration.default_socket_timeout
-        @socket_timeout = nil unless @socket_timeout&.positive?
-        @max_connections = args[:max_connections] || CommunicatorConfiguration.default_max_connections
-        @proxy_configuration = args[:proxy_configuration]
-
-        # HTTPClient provides the following features:
-        # 1) thread safe, an instance can be used by multiple threads without
-        # explicit synchronization
-        # 2) use persistent connection if HTTP 1.1 is supported. The connection
-        # will be left open until explicitly closed or keep_alive_timeout
-        # 3) a built-in connection pool with no limit for max connections
-        @http_client = create_http_client
-        @http_client.connect_timeout = @connect_timeout
-        @http_client.send_timeout = @socket_timeout
-        @http_client.receive_timeout = @socket_timeout
-      end
-
-      private
-
-      # Create a HTTPClient instance that uses @proxy_configuration or the system proxy if @proxy_configuration is not set
-      def create_http_client
-        if @proxy_configuration
-          httpclient = HTTPClient.new(@proxy_configuration.proxy_uri)
-          httpclient.set_proxy_auth(@proxy_configuration.username, @proxy_configuration.password)
-          httpclient.force_basic_auth = true if @proxy_configuration.username && @proxy_configuration.password
-        else
-          # use system settings
-          proxy_string = ENV['https_proxy'] || ENV['http_proxy']
-          # proxy string format = 'http://username:password@hostname:port'
-          proxy_string =~ %r{https?//(?<username>[^:]):(?<password>[^@])@.*}
-          username = Regexp.last_match(1)
-          password = Regexp.last_match(2)
-          httpclient = HTTPClient.new(proxy_string)
-          httpclient.set_proxy_auth(username, password) if username && password
-          httpclient.force_basic_auth = true if username && password
-        end
-        httpclient
-      end
-
-      public
-
-      # Closes all connections idle for longer than _idle_time_ seconds.
-      # In addition, the keep_alive_timeout is set to _idle_time_
-      # so any future connections idle for longer than _idle_time_ seconds will also be closed.
-      def close_idle_connections(idle_time)
-        # in sec
-        @http_client.keep_alive_timeout = idle_time # set timeout value
-        close_expired_connections
-      end
-
-      # HTTPClient automatically closes expired connections so _close_expired_connections_ is a no-operation.
-      def close_expired_connections
-        # By default the keep alive timeout is 15 sec, which is the HTTP 1.1
-        # standard. To change the value, use keep_alive_timeout= method
-        # do nothing, handled by HTTPClient
-      end
-
-      # Frees all networking resources used.
-      def close
-        @http_client.reset_all
-      end
-
-      # Returns the number of open connections
-      def session_count
-        @http_client.session_count
-      end
-
-      # Performs a GET request to the Online Payments platform
-      # @see request
-      def get(uri, request_headers)
-        request('get', uri, request_headers) do |response_status_code, response_headers, response_body|
-          yield response_status_code, response_headers, response_body
-        end
-      end
-
-      # Performs a DELETE request to the Online Payments platform
-      # @see request
-      def delete(uri, request_headers)
-        request('delete', uri, request_headers) do |response_status_code, response_headers, response_body|
-          yield response_status_code, response_headers, response_body
-        end
-      end
-
-      # Performs a POST request to the Online Payments platform
-      # @see request
-      def post(uri, request_headers, body)
-        request('post', uri, request_headers, body) do |response_status_code, response_headers, response_body|
-          yield response_status_code, response_headers, response_body
-        end
-      end
-
-      # Performs a PUT request to the Online Payments platform
-      # @see request
-      def put(uri, request_headers, body)
-        request('put', uri, request_headers, body) do |response_status_code, response_headers, response_body|
-          yield response_status_code, response_headers, response_body
-        end
-      end
-
-      # Performs a HTTP request and yields the response as the status code, headers and body.
-      # Also ensures the request is logged when sent and its response is logged when received.
-      #
-      # @param method          [String] 'GET', 'DELETE', 'POST' or 'PUT' depending on the HTTP method being used.
-      # @param uri             [URI::HTTP] full URI of the location the request is targeted at, including query parameters.
-      # @param request_headers [Array<OnlinePayments::SDK::RequestHeader>] list of headers that should be used as HTTP headers in the request.
-      # @param body            [String, OnlinePayments::SDK::MultipartFormDataObject] request body.
-      # @yield (Integer, Array<OnlinePayments::SDK::ResponseHeader>, IO) The status code, headers and body of the response.
-      # @raise [OnlinePayments::SDK::CommunicationException] when communication with the Online Payments platform was not successful.
-      def request(method, uri, request_headers, body = nil)
-        request_headers = convert_from_headers(request_headers)
-        request_id = SecureRandom.uuid
-
-        # set X-Request-Id for better traceability
-        request_headers[X_REQUEST_ID_HEADER] = request_id
-
-        content_type = request_headers[CONTENT_TYPE]
-
-        info = { headers: request_headers, content_type: content_type }
-        info[:body] = body if body
-
-        log_request(request_id, method.upcase, uri, info)
-
-        start_time = Time.now
-        begin
-          response_headers = nil
-          response_status_code = nil
-          response_content_type = nil
-          response_body = ''
-
-          if body.is_a? OnlinePayments::SDK::MultipartFormDataObject
-            multipart_request(method, uri, request_headers, body) do |status_code, headers, r_content_type, r_body|
-              response_headers = headers
-              response_status_code = status_code
-              response_content_type = r_content_type
-              unless binary_content_type? response_content_type
-                response_body = r_body.read.force_encoding('UTF-8')
-                r_body = StringIO.new(response_body)
-              end
-
-              yield status_code, headers, r_body
-            end
-          else
-            raw_request(method, uri, request_headers, body) do |status_code, headers, r_content_type, r_body|
-              response_headers = headers
-              response_status_code = status_code
-              response_content_type = r_content_type
-              response_body = r_body.read.force_encoding('UTF-8')
-              r_body = StringIO.new(response_body)
-
-              yield status_code, headers, r_body
-            end
-          end
-
-          log_response(request_id, response_status_code, start_time,
-                       headers: response_headers, body: response_body,
-                       content_type: response_content_type)
-        rescue HTTPClient::TimeoutError => e
-          log_error(request_id, start_time, e)
-          raise OnlinePayments::SDK::CommunicationException, e
-        rescue HTTPClient::KeepAliveDisconnected, HTTPClient::RetryableResponse => e # retry these?
-          log_error(request_id, start_time, e)
-          raise OnlinePayments::SDK::CommunicationException, e
-        rescue StandardError => e
-          log_error(request_id, start_time, e)
-          raise OnlinePayments::SDK::CommunicationException, e
-        end
-      end
-
-      # logging code
-
-      # Enables logging outgoing requests and incoming responses by registering the _communicator_logger_.
-      # Note that only one logger can be registered at a time and calling _enable_logging_
-      # a second time will override the old logger instance with the new one.
-      #
-      # @param communicator_logger [OnlinePayments::SDK::Logging::CommunicatorLogger] the communicator logger the requests and responses are logged to
-      def enable_logging(communicator_logger)
-        raise ArgumentError, 'communicatorLogger is required' unless communicator_logger
-
-        @communicator_logger = communicator_logger
-      end
-
-      # Disables logging by unregistering any previous logger that might be registered.
-      def disable_logging
-        @communicator_logger = nil
-      end
-
-      private
-
-      # Converts a {OnlinePayments::SDK::RequestHeader} list headers to a hash
-      def convert_from_headers(headers)
-        headers.each_with_object({}) { |h, hash| hash[h.name] = h.value }
-      end
-
-      # Converts a hash to a {OnlinePayments::SDK::ResponseHeader} list
-      def convert_to_response_headers(headers)
-        arr ||= []
-        headers.each { |k, v| arr << OnlinePayments::SDK::ResponseHeader.new(k, v) }
-        arr
-      end
-
-      def log_request(request_id, method, uri, args = {})
-        return unless @communicator_logger
-
-        headers = args[:headers]
-        body = args[:body]
-        content_type = args[:content_type]
-        log_msg_builder = OnlinePayments::SDK::Logging::RequestLogMessageBuilder.new(request_id, method, uri)
-        headers.each { |k, v| log_msg_builder.add_headers(k, v) } if headers
-
-        log_msg_builder.set_body(body, content_type)
-
-        begin
-          @communicator_logger.log(log_msg_builder.get_message)
-        rescue StandardError => e
-          @communicator_logger.log("An error occurred trying to log request #{request_id}", e)
-        end
-      end
-
-      # Creates the log_response stream
-      def log_response(request_id, status_code, start_time, args = {})
-        return unless @communicator_logger
-
-        duration = (Time.now - start_time) * 1000 # in milliseconds
-        headers = args[:headers]
-        body = args[:body] if args[:body]
-        content_type = args[:content_type]
-
-        log_msg_builder = OnlinePayments::SDK::Logging::ResponseLogMessageBuilder.new(request_id, status_code, duration)
-        if headers
-          convert_from_headers(headers)
-            .each do |key, value|
-            log_msg_builder.add_headers(key, value)
-          end
-        end
-
-        log_msg_builder.set_body(body, content_type)
-
-        begin
-          @communicator_logger.log(log_msg_builder.get_message)
-        rescue StandardError => e
-          @communicator_logger.log("An error occurred trying to log response #{request_id}", e)
-        end
-      end
-
-      def log_error(request_id, start_time, thrown)
-        return unless @communicator_logger
-
-        duration = (Time.now - start_time) * 1000 # in millisecs
-        @communicator_logger.log("Error occurred for outgoing request (requestId='#{request_id}', #{duration} ms)", thrown)
-      end
-
-      # Makes a request using the specified method
-      #
-      # Yields a status code, an array of {OnlinePayments::SDK::ResponseHeader},
-      # the content_type and body
-      def raw_request(method, uri, headers, body = nil)
-        connection = body ?
-                       @http_client.send("#{method}_async", uri, body: body, header: headers) :
-                       @http_client.send("#{method}_async", uri, header: headers)
-
-        response = connection.pop
-        pipe = response.content
-        response_headers = convert_to_response_headers(response.headers)
-
-        begin
-          yield response.status_code, response_headers, response.content_type, pipe
-        ensure
-          pipe.close
-        end
-      end
-
-      # Makes a request using the specified method
-      #
-      # Yields a status code, an array of {OnlinePayments::SDK::ResponseHeader},
-      # the content_type and body
-      def multipart_request(method, uri, headers, body = nil)
-        unless body.is_a? OnlinePayments::SDK::MultipartFormDataObject
-          raise ArgumentError, 'body should be a MultipartFormDataObject'
-        end
-
-        if method != 'post' && method != 'put'
-          raise ArgumentError, "method #{method} is not supported"
-        end
-
-        connection = @http_client.send method + '_async',
-                                       uri,
-                                       body: multipart_request_body(body),
-                                       header: headers
-
-        response = connection.pop
-        pipe = response.content
-        response_headers = convert_to_sdk_response_headers(response.headers)
-
-        begin
-          yield response.status_code, response_headers, response.content_type, pipe
-        ensure
-          pipe.close
-        end
-      end
-
-      # Creates a request body for the multipart request
-      def multipart_request_body( body )
-        request_body = []
-        body.files.each do |k, v|
-          request_body.push :content => v.content,
-                            'Content-Type' => v.content_type,
-                            'Content-Disposition' => "form-data; name=\"#{k}\"; filename=\"#{v.file_name}\"",
-                            'Content-Transfer-Encoding' => 'binary'
-        end
-
-        body.values.each do |k, v|
-          request_body << { :content => v,
-                            'Content-Disposition' => "form-data; name=\"#{k}\"" }
-        end
-        request_body
-      end
-    end
-  end
-end

data/lib/onlinepayments/sdk/defaultimpl/default_marshaller.rb

@@ -1,32 +0,0 @@
-require 'json'
-require 'singleton'
-
-module OnlinePayments::SDK
-  module DefaultImpl
-    # marshals objects to and from JSON format.
-    # Currently supports marshalling and unmarshalling of classes that support class.new_from_hash and class#to_h
-    class DefaultMarshaller < OnlinePayments::SDK::Marshaller
-      include Singleton
-
-      # NOTE: this alias is needed to not break existing method calls depending on old interface
-      class << self
-        alias_method :INSTANCE, :instance
-      end
-
-      # Marshals the _request_object_ to a JSON string using request_object#to_h
-      def marshal(request_object)
-        JSON.pretty_generate(request_object.to_h)
-      end
-
-      # Unmarshals a JSON string into an object of type _klass_ using klass.new_from_hash
-      # @param [String] json_string
-      def unmarshal(json_string, klass)
-        return nil unless json_string
-        return '' if json_string.empty?
-        return klass.new_from_hash(JSON.parse(json_string)) if klass.respond_to?(:new_from_hash)
-
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/onlinepayments/sdk/defaultimpl.rb

@@ -1,6 +0,0 @@
-prefix = 'onlinepayments/sdk/defaultimpl'
-
-require "#{prefix}/authorization_type"
-require "#{prefix}/default_marshaller"
-require "#{prefix}/default_connection"
-require "#{prefix}/default_authenticator"

data/lib/onlinepayments/sdk/endpoint_configuration.rb

@@ -1,127 +0,0 @@
-require 'uri'
-
-module OnlinePayments::SDK
-
-  # Base class for configuration classes in the SDK.
-  #
-  # @attr [String] api_endpoint     The base URL to the Online Payments platform.
-  # @attr [Integer] connect_timeout The number of seconds before a connection attempt with the Online Payments platform times out.
-  # @attr [Integer] socket_timeout  The number of seconds before a timeout occurs when transmitting data to or from the Online Payments platform.
-  # @attr [Integer] max_connections The number of connections with the Online Payments platform that are kept alive in the connection pool.
-  #       These connections will be reused when possible.
-  # @attr [OnlinePayments::SDK::ProxyConfiguration] proxy_configuration Proxy settings.
-  # @attr [String] integrator       Name of the integrator
-  # @attr [OnlinePayments::SDK::Domain::ShoppingCartExtension] shopping_cart_extension Shopping cart-related metadata.
-  class EndpointConfiguration
-    DEFAULT_CONNECT_TIMEOUT = 10
-    DEFAULT_SOCKET_TIMEOUT = 10
-    DEFAULT_MAX_CONNECTIONS = 10
-
-    # The default number of seconds before a connection attempt with the Online Payments platform times out.
-    # Used if _connectTimeout_ is not present in the properties.
-    def self.default_connect_timeout
-      DEFAULT_CONNECT_TIMEOUT
-    end
-
-    # The default number of seconds before a timeout occurs when transmitting data to or from the Online Payments platform.
-    # Used if _socketTimeout_ is not present in the properties.
-    def self.default_socket_timeout
-      DEFAULT_SOCKET_TIMEOUT
-    end
-
-    # The default number of connections that are kept alive in the connection pool.
-    # Used if _maxConnections_ is not present in the properties.
-    def self.default_max_connections
-      DEFAULT_MAX_CONNECTIONS
-    end
-
-    # Initializes a new EndpointConfiguration.
-    #
-    # The given _properties_ is searched for settings using properties[prefix + '.setting_name']
-    # The following settings are searched:
-    #
-    # endpoint::                This property is searched for *endpoint.host*, *endpoint.scheme* and *endpoint.port*.
-    #                           The found host, scheme and port are used to construct the base URL to the Online Payments platform.
-    # connectTimeout::          The number of seconds before a connection attempt with the Online Payments platform times out.
-    # socketTimeout::           The number of seconds before a timeout occurs when transmitting data to or from the Online Payments platform.
-    # maxConnections::          The number of connections with the Online Payments platform
-    #                           that are kept alive in the connection pool. These connections will be reused when possible.
-    # proxy::                   This property is searched for *proxy.uri*, *proxy.username* and *proxy.password*.
-    #                           The found URI, username and password are used
-    #                           for connecting to the Online Payments platform using a proxy.
-    # integrator::              Name of the integrator
-    # shoppingCartExtension::   Will be used to initialize a {OnlinePayments::SDK::Domain::ShoppingCartExtension}.
-    def initialize(properties = nil, prefix = nil)
-      return unless properties
-
-      @api_endpoint = get_endpoint(properties, prefix)
-      @connect_timeout = get_property(properties, "#{prefix}.connectTimeout", DEFAULT_CONNECT_TIMEOUT)
-      @socket_timeout = get_property(properties, "#{prefix}.socketTimeout", DEFAULT_SOCKET_TIMEOUT)
-      @max_connections = get_property(properties, "#{prefix}.maxConnections", DEFAULT_MAX_CONNECTIONS)
-
-      proxy_uri = properties["#{prefix}.proxy.uri"]
-      if proxy_uri
-        proxy_user = properties["#{prefix}.proxy.username"]
-        proxy_pass = properties["#{prefix}.proxy.password"]
-        @proxy_configuration = ProxyConfiguration.new(address: URI(proxy_uri),
-                                                      username: proxy_user,
-                                                      password: proxy_pass)
-      end
-      @integrator = properties["#{prefix}.integrator"]
-      @shopping_cart_extension = get_shopping_cart_extension(properties, prefix)
-    end
-
-    protected
-
-    def set_endpoint(endpoint)
-      if endpoint
-        raise ArgumentError, 'endpoint should not contain a path' if endpoint.path
-        if endpoint.userinfo || endpoint.query || endpoint.fragment
-          raise ArgumentError('endpoint should not contain user info, query or fragment')
-        end
-      end
-      @api_endpoint = endpoint
-    end
-
-    private
-
-    def get_property(properties, key, default_value)
-      property_value = properties[key]
-      property_value.nil? ? default_value : property_value
-    end
-
-    def get_endpoint(properties, prefix)
-      host = properties["#{prefix}.endpoint.host"]
-      scheme = properties["#{prefix}.endpoint.scheme"] || 'https'
-      port = properties["#{prefix}.endpoint.port"] || -1
-      create_uri(scheme, host, port)
-    end
-
-    def create_uri(scheme, host, port)
-      port == -1 ? "#{scheme}://#{host}" : "#{scheme}://#{host}:#{port}"
-    end
-
-    def get_shopping_cart_extension(properties, prefix)
-      creator = properties["#{prefix}.shoppingCartExtension.creator"]
-      name = properties["#{prefix}.shoppingCartExtension.name"]
-      version = properties["#{prefix}.shoppingCartExtension.version"]
-      extension_id = properties["#{prefix}.shoppingCartExtension.extensionId"]
-      (creator || name || version || extension_id) ?
-        Domain::ShoppingCartExtension.new(creator, name, version, extension_id) :
-        nil
-    end
-
-    public
-
-    attr_reader :api_endpoint
-
-    attr_accessor :connect_timeout
-    attr_accessor :socket_timeout
-    attr_accessor :max_connections
-
-    attr_accessor :proxy_configuration
-
-    attr_accessor :integrator
-    attr_accessor :shopping_cart_extension
-  end
-end

data/lib/onlinepayments/sdk/exceptions.rb

@@ -1,8 +0,0 @@
-prefix = 'onlinepayments/sdk/'
-suffix = '_exception'
-exception_types = %w[api authorization communication declined_transaction
-                    declined_payment declined_refund
-                    payment_platform idempotence marshaller_syntax not_found
-                    reference response validation]
-
-exception_types.each { |type| require prefix + type + suffix }