killbill 3.2.4 → 4.0.0

data/lib/killbill/ext/active_merchant/jdbc_connection.rb

@@ -1,92 +0,0 @@
-require 'active_record'
-require 'active_record/connection_adapters/jdbc_adapter'
-
-module ActiveRecord
-  module ConnectionAdapters
-    class JdbcConnection
-
-      # Sets the connection factory from the available configuration.
-      #
-      # This differs from the original implementation in the following ways:
-      #   * We attempt to lookup the JNDI data source multiple times, to handle transient lookup issues
-      #   * If the data source is unavailable, we don't fallback to straight JDBC (which is often not configured anyways)
-      #   * In the failure scenario, inspect the exception instead of displaying e.message, which is often empty in our testing
-      def setup_connection_factory
-        if self.class.jndi_config?(config)
-          setup_done   = false
-          jndi_retries = self.class.jndi_retries(config)
-
-          1.upto(jndi_retries) do |i|
-            begin
-              setup_jndi_factory
-              setup_done = true
-              break
-            rescue => e
-              warn "JNDI data source unavailable: #{e.inspect} (attempt ##{i})"
-            end
-          end
-
-          raise "JNDI data source unavailable (tried #{jndi_retries} times)" unless setup_done
-        else
-          setup_jdbc_factory
-        end
-      end
-
-      def self.jndi_retries(config)
-        (config[:jndi_retries] || 5).to_i
-      end
-
-      protected
-
-      def setup_jndi_factory
-        data_source = config[:data_source] || Java::JavaxNaming::InitialContext.new.lookup(config[:jndi].to_s)
-
-        @jndi                   = true
-        # Really slow under high load (see https://github.com/jruby/activerecord-jdbc-adapter/pull/588).
-        #self.connection_factory = JdbcConnectionFactory.impl { data_source.connection }
-        self.connection_factory = RubyJdbcConnectionFactory.new(data_source)
-      end
-
-      class RubyJdbcConnectionFactory
-        include JdbcConnectionFactory
-
-        def initialize(data_source)
-          @data_source = data_source
-        end
-
-        def new_connection
-          @data_source.connection
-        end
-      end
-    end
-  end
-end
-
-require 'active_record/persistence'
-
-module ActiveRecord
-  module Persistence
-
-    # Creates a record with values matching those of the instance attributes
-    # and returns its id.
-    def _create_record(attribute_names = @attributes.keys)
-      attributes_values = arel_attributes_with_values_for_create(attribute_names)
-
-      new_id = self.class.unscoped.insert attributes_values
-
-      # Under heavy load and concurrency, write_attribute_with_type_cast sometimes fail to set the id.
-      # Even though self.class.primary_key returns 'id' and new_id is correctly populated from the database
-      # (see last_insert_id in activerecord-jdbc-adapter-1.3.9/lib/arjdbc/jdbc/adapter.rb), both self.id ||= new_id
-      # and self.id = new_id sometimes don't set the id. I couldn't quite figure it out.
-      # A workaround seems to be to retry the assignment (see also activerecord-4.1.5/lib/active_record/attribute_methods/primary_key.rb).
-      if self.class.primary_key
-        self.id ||= new_id
-        self.id ||= new_id if id.nil?
-        raise "Unable to set id (new_id=#{new_id}) for #{self.inspect}" if id.nil?
-      end
-
-      @new_record = false
-      id
-    end
-  end
-end

data/lib/killbill/ext/active_merchant/proxy_support.rb

@@ -1,58 +0,0 @@
-require 'active_utils/common/posts_data'
-
-# Pass the proxy details to the connection object - see https://github.com/Shopify/active_utils/pull/44
-module ActiveMerchant #:nodoc:
-  module PostsData #:nodoc:
-
-    def self.included(base)
-      base.superclass_delegating_accessor :ssl_strict
-      base.ssl_strict = true
-
-      base.superclass_delegating_accessor :ssl_version
-      base.ssl_version = nil
-
-      base.class_attribute :retry_safe
-      base.retry_safe = false
-
-      base.superclass_delegating_accessor :open_timeout
-      base.open_timeout = 60
-
-      base.superclass_delegating_accessor :read_timeout
-      base.read_timeout = 60
-
-      base.superclass_delegating_accessor :max_retries
-      base.max_retries = Connection::MAX_RETRIES
-
-      base.superclass_delegating_accessor :logger
-      base.superclass_delegating_accessor :wiredump_device
-
-      base.superclass_delegating_accessor :proxy_address
-      base.superclass_delegating_accessor :proxy_port
-    end
-
-    def raw_ssl_request(method, endpoint, data, headers = {})
-      logger.warn "#{self.class} using ssl_strict=false, which is insecure" if logger unless ssl_strict
-
-      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
-
-      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
-  end
-end

data/spec/killbill/helpers/gateway_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Killbill::Plugin::ActiveMerchant::Gateway do
-
-  it 'should honor configuration options' do
-    gateway_builder = Proc.new {}
-    logger          = Logger.new(STDOUT)
-    config          = {}
-
-    verify_config
-
-    ::Killbill::Plugin::ActiveMerchant::Gateway.wrap(gateway_builder, logger, config)
-    verify_config(config)
-
-    config1 = {:open_timeout => 12, :ssl_version => 5}
-    ::Killbill::Plugin::ActiveMerchant::Gateway.wrap(gateway_builder, logger, config1)
-    verify_config(config1)
-
-    config2 = {:retry_safe => true, :ssl_strict => false, :max_retries => nil}
-    ::Killbill::Plugin::ActiveMerchant::Gateway.wrap(gateway_builder, logger, config2)
-    verify_config(config1.merge(config2).delete_if { |k, v| v.nil? })
-  end
-
-  private
-
-  def verify_config(config = {})
-    ::ActiveMerchant::Billing::Gateway.open_timeout.should == (config.has_key?(:open_timeout) ? config[:open_timeout] : 60)
-    ::ActiveMerchant::Billing::Gateway.read_timeout.should == (config.has_key?(:read_timeout) ? config[:read_timeout] : 60)
-    ::ActiveMerchant::Billing::Gateway.retry_safe.should == (config.has_key?(:retry_safe) ? config[:retry_safe] : false)
-    ::ActiveMerchant::Billing::Gateway.ssl_strict.should == (config.has_key?(:ssl_strict) ? config[:ssl_strict] : true)
-    ::ActiveMerchant::Billing::Gateway.ssl_version.should == (config.has_key?(:ssl_version) ? config[:ssl_version] : nil)
-    ::ActiveMerchant::Billing::Gateway.max_retries.should == (config.has_key?(:max_retries) ? config[:max_retries] : 3)
-    ::ActiveMerchant::Billing::Gateway.proxy_address.should == (config.has_key?(:proxy_address) ? config[:proxy_address] : nil)
-    ::ActiveMerchant::Billing::Gateway.proxy_port.should == (config.has_key?(:proxy_port) ? config[:proxy_port] : nil)
-  end
-end