swiss-activemerchant 1.0.1

data/lib/active_merchant/network_connection_retries.rb

@@ -0,0 +1,78 @@
+require 'openssl'
+
+module ActiveMerchant
+  module NetworkConnectionRetries
+    DEFAULT_RETRIES = 3
+    DEFAULT_CONNECTION_ERRORS = {
+      EOFError               => 'The remote server dropped the connection',
+      Errno::ECONNRESET      => 'The remote server reset the connection',
+      Timeout::Error         => 'The connection to the remote server timed out',
+      Errno::ETIMEDOUT       => 'The connection to the remote server timed out',
+      SocketError            => 'The connection to the remote server could not be established',
+      Errno::EHOSTUNREACH    => 'The connection to the remote server could not be established',
+      OpenSSL::SSL::SSLError => 'The SSL connection to the remote server could not be established'
+    }
+
+    def self.included(base)
+      base.send(:attr_accessor, :retry_safe)
+    end
+
+    def retry_exceptions(options = {})
+      connection_errors = DEFAULT_CONNECTION_ERRORS.merge(options[:connection_exceptions] || {})
+
+      retry_network_exceptions(options) do
+        yield
+      rescue Errno::ECONNREFUSED => e
+        raise ActiveMerchant::RetriableConnectionError.new('The remote server refused the connection', e)
+      rescue OpenSSL::X509::CertificateError => e
+        NetworkConnectionRetries.log(options[:logger], :error, e.message, options[:tag])
+        raise ActiveMerchant::ClientCertificateError, 'The remote server did not accept the provided SSL certificate'
+      rescue Zlib::BufError
+        raise ActiveMerchant::InvalidResponseError, 'The remote server replied with an invalid response'
+      rescue *connection_errors.keys => e
+        raise ActiveMerchant::ConnectionError.new(derived_error_message(connection_errors, e.class), e)
+      end
+    end
+
+    def self.log(logger, level, message, tag = nil)
+      tag ||= self.class.to_s
+      message = "[#{tag}] #{message}"
+      logger&.send(level, message)
+    end
+
+    private
+
+    def retry_network_exceptions(options = {})
+      initial_retries = options[:max_retries] || DEFAULT_RETRIES
+      retries = initial_retries
+      request_start = nil
+
+      begin
+        request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = yield
+        log_with_retry_details(options[:logger], initial_retries - retries + 1, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, 'success', options[:tag])
+        result
+      rescue ActiveMerchant::RetriableConnectionError => e
+        retries -= 1
+
+        log_with_retry_details(options[:logger], initial_retries - retries, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, e.message, options[:tag])
+        retry unless retries.zero?
+        raise ActiveMerchant::ConnectionError.new(e.message, e)
+      rescue ActiveMerchant::ConnectionError, ActiveMerchant::InvalidResponseError => e
+        retries -= 1
+        log_with_retry_details(options[:logger], initial_retries - retries, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, e.message, options[:tag])
+        retry if (options[:retry_safe] || retry_safe) && !retries.zero?
+        raise
+      end
+    end
+
+    def log_with_retry_details(logger, attempts, time, message, tag)
+      NetworkConnectionRetries.log(logger, :info, 'connection_attempt=%d connection_request_time=%.4fs connection_msg="%s"' % [attempts, time, message], tag)
+    end
+
+    def derived_error_message(errors, klass)
+      key = (errors.keys & klass.ancestors).first
+      key ? errors[key] : nil
+    end
+  end
+end

data/lib/active_merchant/post_data.rb

@@ -0,0 +1,26 @@
+require 'cgi'
+
+module ActiveMerchant
+  class PostData < Hash
+    class_attribute :required_fields, instance_writer: false
+    self.required_fields = []
+
+    def []=(key, value)
+      return if value.blank? && !required?(key)
+
+      super
+    end
+
+    def to_post_data
+      collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+    end
+
+    alias to_s to_post_data
+
+    private
+
+    def required?(key)
+      required_fields.include?(key)
+    end
+  end
+end

data/lib/active_merchant/posts_data.rb

@@ -0,0 +1,92 @@
+module ActiveMerchant #:nodoc:
+  module PostsData #:nodoc:
+    def self.included(base)
+      base.class_attribute :ssl_strict
+      base.ssl_strict = true
+
+      base.class_attribute :ssl_version
+      base.ssl_version = nil
+
+      base.class_attribute :min_version
+      base.min_version = Connection::MIN_VERSION
+
+      base.class_attribute :max_version
+      base.max_version = nil
+
+      base.class_attribute :retry_safe
+      base.retry_safe = false
+
+      base.class_attribute :open_timeout
+      base.open_timeout = Connection::OPEN_TIMEOUT
+
+      base.class_attribute :read_timeout
+      base.read_timeout = Connection::READ_TIMEOUT
+
+      base.class_attribute :max_retries
+      base.max_retries = Connection::MAX_RETRIES
+
+      base.class_attribute :logger
+      base.class_attribute :wiredump_device
+
+      base.class_attribute :proxy_address
+      base.class_attribute :proxy_port
+    end
+
+    def ssl_get(endpoint, headers = {})
+      ssl_request(:get, endpoint, nil, headers)
+    end
+
+    def ssl_post(endpoint, data, headers = {})
+      ssl_request(:post, endpoint, data, headers)
+    end
+
+    def ssl_request(method, endpoint, data, headers)
+      handle_response(raw_ssl_request(method, endpoint, data, headers))
+    end
+
+    def raw_ssl_request(method, endpoint, data, headers = {})
+      logger&.warn "#{self.class} using ssl_strict=false, which is insecure" unless ssl_strict
+      logger&.warn "#{self.class} posting to plaintext endpoint, which is insecure" unless endpoint.to_s =~ /^https:/
+
+      connection = new_connection(endpoint)
+      connection.open_timeout = open_timeout
+      connection.read_timeout = read_timeout
+      connection.retry_safe   = retry_safe
+      connection.verify_peer  = ssl_strict
+      connection.ssl_version  = ssl_version
+      connection.logger       = logger
+      connection.max_retries  = max_retries
+      connection.tag          = self.class.name
+      connection.wiredump_device = wiredump_device
+      if connection.respond_to?(:min_version=)
+        connection.min_version = min_version
+        connection.max_version = max_version
+      end
+
+      connection.pem          = @options[:pem] if @options
+      connection.pem_password = @options[:pem_password] if @options
+
+      connection.ignore_http_status = @options[:ignore_http_status] if @options
+
+      connection.proxy_address = proxy_address
+      connection.proxy_port    = proxy_port
+
+      connection.request(method, data, headers)
+    end
+
+    private
+
+    def new_connection(endpoint)
+      Connection.new(endpoint)
+    end
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200...300
+        response.body
+      else
+        raise ResponseError.new(response)
+      end
+    end
+  end
+end

data/lib/active_merchant/version.rb

@@ -0,0 +1,3 @@
+module ActiveMerchant
+  VERSION = '1.0.1'
+end

data/lib/active_merchant.rb

@@ -0,0 +1,63 @@
+#--
+# Copyright (c) 2005-2010 Tobias Luetke
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/conversions'
+require 'active_support/core_ext/object/conversions'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/module/attribute_accessors'
+
+require 'base64'
+require 'securerandom'
+require 'builder'
+require 'cgi'
+require 'rexml/document'
+require 'timeout'
+require 'socket'
+require 'openssl'
+
+require 'active_merchant/network_connection_retries'
+require 'active_merchant/net_http_ssl_connection'
+require 'active_merchant/connection'
+require 'active_merchant/post_data'
+require 'active_merchant/posts_data'
+
+require 'active_merchant/billing'
+require 'active_merchant/version'
+require 'active_merchant/country'
+
+module ActiveMerchant
+  def self.deprecated(message, caller = Kernel.caller[1])
+    warning = caller + ': ' + message
+    if respond_to?(:logger) && logger.present?
+      logger.warn(warning)
+    else
+      warn(warning)
+    end
+  end
+end
+
+I18n.enforce_available_locales = false

data/lib/activemerchant.rb

@@ -0,0 +1 @@
+require 'active_merchant'