killbill 3.1.9 → 3.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fecf6eec986317ba4b930aea485670c18fbc88b2
-  data.tar.gz: 642dbcbe75183170bfe68b07925653bf51855a29
+  metadata.gz: 53241b3ff5ba7293ab885ae36942071b396cdb03
+  data.tar.gz: 6c78b3cb59a3c28140b30fdfbcc080425858f5ce
 SHA512:
-  metadata.gz: 900a0cb3ce17d6060cac359fe685fe42b593a492fa97b4f1a9c418255524c18415a67641c09092716a82827c17d3c905eedab1036f76f23c57a761967adda8be
-  data.tar.gz: f03f0c261d3390cae2246a9a31464a0cc10ee5093ca414d8381eb8d1a300d4706df5aed100de725f3496a24c6871f39dcd2d774765c5c35b288cf8b5490fa700
+  metadata.gz: c131124735e38e0e61e7934190e36e661490df54d308d5bb8ffd74e743312b35e4561eec42f8bd9bd5df50a15e51746fd79966a72340e3ab93a680f24dfe74bf
+  data.tar.gz: 3e69182738dba3c38f5f012afc6846b9306454c4e97e5cb70c1ac1a6f60cfdf8fe26c4f518a4aaeaf6e416246fc40e5176442df08cddfb8c62fcf84f2f30f89a

data/NEWS

@@ -1,6 +1,15 @@
+3.1.10
+    Add workarounds for ActiveRecord bugs under high load/concurrency
+    BoundedLRUCache performance improvements
+    Introduce :payment_processor_account_id option to route payment requests
+    Add before_gateways / after_gateways hooks
+
 3.1.9
     Fix memory leak in database connection handling
     Change void implementation to be more generic (and work with Cybersource)
+    ActiveMerchant: pass the transaction external key as the order id
+    Add before_gateway / after_gateway hooks
+    Fix API queries in multi-tenancy mode
 
 3.1.8
     Make ActiveMerchant HTTP backend configurable, add support for Typhoeus

data/VERSION

@@ -1 +1 @@
-3.1.9
+3.1.10

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

@@ -0,0 +1,69 @@
+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
+    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/helpers/active_merchant.rb

@@ -3,6 +3,8 @@ module Killbill
     module ActiveMerchant
       require 'killbill'
 
+      require 'killbill/ext/active_merchant/jdbc_connection'
+
       require 'active_support/core_ext'
       require File.dirname(__FILE__) + '/active_merchant/core_ext.rb'
       require File.dirname(__FILE__) + '/active_merchant/configuration.rb'
@@ -18,4 +20,4 @@ module Killbill
       end
     end
   end
-end
+end

data/lib/killbill/helpers/active_merchant/active_record/models/helpers.rb

@@ -8,7 +8,7 @@ module Killbill
         # We don't want to issue raw SQL because we still want to be able to support multiple back-ends (at least SQLite and MySQL),
         # so we cache the quoted values (this should also give us SQL injection protection).
         # The gain is not 50% but more around 30% due to the Mutex overhead in the cache
-        def build_quotes_cache(max_size=1000)
+        def build_quotes_cache(max_size=10000)
           # See ::ActiveRecord::Sanitization::ClassMethods.quote_bound_value
           quote_bound_value_proc = Proc.new { |value|
             c = connection

data/lib/killbill/helpers/active_merchant/active_record/models/transaction.rb

@@ -27,6 +27,11 @@ module Killbill
             # For convenience
             alias_method :authorizations_from_kb_payment_id, :authorizes_from_kb_payment_id
 
+            # For convenience
+            def voids_from_kb_payment_id(kb_payment_id, kb_tenant_id)
+              [void_from_kb_payment_id(kb_payment_id, kb_tenant_id)]
+            end
+
             # void is special: unique void per payment_id
             def void_from_kb_payment_id(kb_payment_id, kb_tenant_id)
               transaction_from_kb_payment_id(:VOID, kb_payment_id, kb_tenant_id, :single)

data/lib/killbill/helpers/active_merchant/configuration.rb

@@ -5,24 +5,38 @@ module Killbill
     module ActiveMerchant
       mattr_reader :config
       mattr_reader :currency_conversions
-      mattr_reader :gateway
+      mattr_reader :gateways
       mattr_reader :initialized
       mattr_reader :kb_apis
       mattr_reader :logger
-      mattr_reader :test
 
       def self.initialize!(gateway_builder, gateway_name, logger, config_file, kb_apis)
         @@config = Properties.new(config_file)
         @@config.parse!
 
-        @@currency_conversions = @@config[:currency_conversions]
-        @@kb_apis = kb_apis
-        @@test = @@config[gateway_name][:test]
+        @@logger           = logger
+        @@logger.log_level = Logger::DEBUG if (@@config[:logger] || {})[:debug]
 
-        @@gateway = Gateway.wrap(gateway_builder, logger, @@config[gateway_name.to_sym])
+        @@currency_conversions = @@config[:currency_conversions]
+        @@kb_apis              = kb_apis
 
-        @@logger = logger
-        @@logger.log_level = Logger::DEBUG if (@@config[:logger] || {})[:debug]
+        @@gateways      = {}
+        gateway_configs = @@config[gateway_name.to_sym]
+        if gateway_configs.is_a?(Array)
+          default_gateway = nil
+          gateway_configs.each_with_index do |gateway_config, idx|
+            gateway_account_id = gateway_config[:account_id]
+            if gateway_account_id.nil?
+              @@logger.warn "Skipping config #{gateway_config} -- missing :account_id"
+            else
+              @@gateways[gateway_account_id.to_sym] = Gateway.wrap(gateway_builder, logger, gateway_config)
+              default_gateway                       = @@gateways[gateway_account_id.to_sym] if idx == 0
+            end
+          end
+          @@gateways[:default] = default_gateway if @@gateways[:default].nil?
+        else
+          @@gateways[:default] = Gateway.wrap(gateway_builder, logger, gateway_configs)
+        end
 
         if defined?(JRUBY_VERSION)
           begin

data/lib/killbill/helpers/active_merchant/gateway.rb

@@ -16,10 +16,13 @@ module Killbill
             ::ActiveMerchant::Billing::Gateway.wiredump_device.sync = true
           end
 
-          Gateway.new(gateway_builder.call(config))
+          Gateway.new(config, gateway_builder.call(config))
         end
 
-        def initialize(am_gateway)
+        attr_reader :config
+
+        def initialize(config, am_gateway)
+          @config = config
           @gateway = am_gateway
         end
 

data/lib/killbill/helpers/active_merchant/payment_plugin.rb

@@ -42,152 +42,72 @@ module Killbill
         end
 
         def authorize_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
-          amount_in_cents = to_cents(amount, currency)
-
-          options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_transaction.external_key
-          options[:currency]    ||= currency.to_s.upcase
-          options[:description] ||= "Kill Bill authorization for #{kb_payment_transaction_id}"
-
-          # Retrieve the payment method
-          payment_source        = get_payment_source(kb_payment_method_id, properties, options, context)
-
-          before_gateway(kb_transaction, nil, payment_source, amount_in_cents, currency, options)
-
-          # Go to the gateway
-          gw_response           = gateway.authorize(amount_in_cents, payment_source, options)
-          response, transaction = save_response_and_transaction(gw_response, :authorize, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :AUTHORIZE, amount_in_cents, currency)
-
-          after_gateway(response, transaction, gw_response)
+          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+            gateway.authorize(amount_in_cents, payment_source, options)
+          end
 
-          response.to_transaction_info_plugin(transaction)
+          dispatch_to_gateways(:authorize, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
         end
 
         def capture_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
-          amount_in_cents = to_cents(amount, currency)
-
-          options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_transaction.external_key
-          options[:currency]    ||= currency.to_s.upcase
-          options[:description] ||= "Kill Bill capture for #{kb_payment_transaction_id}"
-
-          # Retrieve the authorization
-          # TODO We use the last AUTH transaction at the moment, is it good enough?
-          authorization         = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last.txn_id
-
-          before_gateway(kb_transaction, authorization, nil, amount_in_cents, currency, options)
-
-          # Go to the gateway
-          gw_response           = gateway.capture(amount_in_cents, authorization, options)
-          response, transaction = save_response_and_transaction(gw_response, :capture, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :CAPTURE, amount_in_cents, currency)
-
-          after_gateway(response, transaction, gw_response)
+          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+            # TODO We use the last transaction at the moment, is it good enough?
+            last_authorization = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+            raise "Unable to retrieve last authorization for operation=capture, kb_payment_id=#{kb_payment_id}, kb_payment_transaction_id=#{kb_payment_transaction_id}, kb_payment_method_id=#{kb_payment_method_id}" if last_authorization.nil?
+            gateway.capture(amount_in_cents, last_authorization.txn_id, options)
+          end
 
-          response.to_transaction_info_plugin(transaction)
+          dispatch_to_gateways(:capture, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
         end
 
         def purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
-          amount_in_cents = to_cents(amount, currency)
-
-          options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_transaction.external_key
-          options[:currency]    ||= currency.to_s.upcase
-          options[:description] ||= "Kill Bill purchase for #{kb_payment_transaction_id}"
-
-          # Retrieve the payment method
-          payment_source        = get_payment_source(kb_payment_method_id, properties, options, context)
-
-          before_gateway(kb_transaction, nil, payment_source, amount_in_cents, currency, options)
-
-          # Go to the gateway
-          gw_response           = gateway.purchase(amount_in_cents, payment_source, options)
-          response, transaction = save_response_and_transaction(gw_response, :purchase, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :PURCHASE, amount_in_cents, currency)
-
-          after_gateway(response, transaction, gw_response)
+          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+            gateway.purchase(amount_in_cents, payment_source, options)
+          end
 
-          response.to_transaction_info_plugin(transaction)
+          dispatch_to_gateways(:purchase, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
         end
 
         def void_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
-          kb_transaction = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
-
-          options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_transaction.external_key
-          options[:description] ||= "Kill Bill void for #{kb_payment_transaction_id}"
-
-          # If an authorization is being voided, we're performing an 'auth_reversal', otherwise,
-          # we're voiding an unsettled capture or purchase (which often needs to happen within 24 hours).
-          last_transaction      = @transaction_model.purchases_from_kb_payment_id(kb_payment_id, context.tenant_id).last
-          if last_transaction.nil?
-            last_transaction = @transaction_model.captures_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+            # If an authorization is being voided, we're performing an 'auth_reversal', otherwise,
+            # we're voiding an unsettled capture or purchase (which often needs to happen within 24 hours).
+            last_transaction = @transaction_model.purchases_from_kb_payment_id(kb_payment_id, context.tenant_id).last
             if last_transaction.nil?
-              last_transaction = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+              last_transaction = @transaction_model.captures_from_kb_payment_id(kb_payment_id, context.tenant_id).last
               if last_transaction.nil?
-                raise ArgumentError.new("Kill Bill payment #{kb_payment_id} has no auth, capture or purchase, thus cannot be voided")
+                last_transaction = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+                if last_transaction.nil?
+                  raise ArgumentError.new("Kill Bill payment #{kb_payment_id} has no auth, capture or purchase, thus cannot be voided")
+                end
               end
             end
-          end
-          authorization = last_transaction.txn_id
-
-          before_gateway(kb_transaction, last_transaction, nil, nil, nil, options)
-
-          # Go to the gateway - while some gateways implementations are smart and have void support 'auth_reversal' and 'void' (e.g. Litle),
-          # others (e.g. CyberSource) implement different methods
-          gw_response           = last_transaction.transaction_type == 'AUTHORIZE' && gateway.respond_to?(:auth_reversal) ? gateway.auth_reversal(last_transaction.amount_in_cents, authorization, options) : gateway.void(authorization, options)
-          response, transaction = save_response_and_transaction(gw_response, :void, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :VOID)
+            authorization = last_transaction.txn_id
 
-          after_gateway(response, transaction, gw_response)
+            # Go to the gateway - while some gateways implementations are smart and have void support 'auth_reversal' and 'void' (e.g. Litle),
+            # others (e.g. CyberSource) implement different methods
+            last_transaction.transaction_type == 'AUTHORIZE' && gateway.respond_to?(:auth_reversal) ? gateway.auth_reversal(last_transaction.amount_in_cents, authorization, options) : gateway.void(authorization, options)
+          end
 
-          response.to_transaction_info_plugin(transaction)
+          dispatch_to_gateways(:void, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, nil, nil, properties, context, gateway_call_proc)
         end
 
         def credit_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
-          amount_in_cents = to_cents(amount, currency)
-
-          options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_transaction.external_key
-          options[:currency]    ||= currency.to_s.upcase
-          options[:description] ||= "Kill Bill credit for #{kb_payment_transaction_id}"
-
-          # Retrieve the payment method
-          payment_source        = get_payment_source(kb_payment_method_id, properties, options, context)
-
-          before_gateway(kb_transaction, nil, payment_source, amount_in_cents, currency, options)
-
-          # Go to the gateway
-          gw_response           = gateway.credit(amount_in_cents, payment_source, options)
-          response, transaction = save_response_and_transaction(gw_response, :credit, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :CREDIT, amount_in_cents, currency)
-
-          after_gateway(response, transaction, gw_response)
+          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+            gateway.credit(amount_in_cents, payment_source, options)
+          end
 
-          response.to_transaction_info_plugin(transaction)
+          dispatch_to_gateways(:credit, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
         end
 
         def refund_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
-          amount_in_cents = to_cents(amount, currency)
-
-          options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_transaction.external_key
-          options[:currency]    ||= currency.to_s.upcase
-          options[:description] ||= "Kill Bill refund for #{kb_payment_transaction_id}"
-
-          # Find a transaction to refund
-          transaction           = @transaction_model.find_candidate_transaction_for_refund(kb_payment_id, context.tenant_id, amount_in_cents)
-
-          before_gateway(kb_transaction, transaction, nil, amount_in_cents, currency, options)
-
-          # Go to the gateway
-          gw_response           = gateway.refund(amount_in_cents, transaction.txn_id, options)
-          response, transaction = save_response_and_transaction(gw_response, :refund, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :REFUND, amount_in_cents, currency)
-
-          after_gateway(response, transaction, gw_response)
+          gateway_call_proc = Proc.new do |gateway, payment_source, amount_in_cents, options|
+            transaction = @transaction_model.find_candidate_transaction_for_refund(kb_payment_id, context.tenant_id, amount_in_cents)
+            raise "Unable to retrieve transaction to refund for operation=capture, kb_payment_id=#{kb_payment_id}, kb_payment_transaction_id=#{kb_payment_transaction_id}, kb_payment_method_id=#{kb_payment_method_id}" if transaction.nil?
+            gateway.refund(amount_in_cents, transaction.txn_id, options)
+          end
 
-          response.to_transaction_info_plugin(transaction)
+          dispatch_to_gateways(:refund, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
         end
 
         def get_payment_info(kb_account_id, kb_payment_id, properties, context)
@@ -212,6 +132,7 @@ module Killbill
           payment_source        = get_payment_source(nil, all_properties, options, context)
 
           # Go to the gateway
+          gateway               = lookup_gateway(options[:payment_processor_account_id] || :default)
           gw_response           = gateway.store(payment_source, options)
           response, transaction = save_response_and_transaction gw_response, :add_payment_method, kb_account_id, context.tenant_id
 
@@ -235,9 +156,10 @@ module Killbill
         def delete_payment_method(kb_account_id, kb_payment_method_id, properties, context)
           options = properties_to_hash(properties)
 
-          pm = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
+          pm      = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
 
           # Delete the card
+          gateway = lookup_gateway(options[:payment_processor_account_id] || :default)
           if options[:customer_id]
             gw_response = gateway.unstore(options[:customer_id], pm.token, options)
           else
@@ -402,6 +324,64 @@ module Killbill
 
         # Utilities
 
+        # TODO Split settlements is partially implemented. Left to be done:
+        # * payment_source should probably be retrieved per gateway
+        # * amount per gateway should be retrieved from the options
+        def dispatch_to_gateways(operation, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
+          kb_transaction        = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
+          amount_in_cents       = amount.nil? ? nil : to_cents(amount, currency)
+
+          # Setup options for ActiveMerchant
+          options               = properties_to_hash(properties)
+          options[:order_id]    ||= kb_transaction.external_key
+          options[:currency]    ||= currency.to_s.upcase unless currency.nil?
+          options[:description] ||= "Kill Bill #{operation.to_s} for #{kb_payment_transaction_id}"
+
+          # Retrieve the payment method
+          payment_source        = get_payment_source(kb_payment_method_id, properties, options, context)
+
+          # Sanity checks
+          if [:authorize, :purchase, :credit].include?(operation)
+            raise "Unable to retrieve payment source for operation=#{operation}, kb_payment_id=#{kb_payment_id}, kb_payment_transaction_id=#{kb_payment_transaction_id}, kb_payment_method_id=#{kb_payment_method_id}" if payment_source.nil?
+          end
+
+          # Retrieve the previous transaction for the same operation and payment id - this is useful to detect dups for example
+          last_transaction = @transaction_model.send("#{operation.to_s}s_from_kb_payment_id", kb_payment_id, context.tenant_id).last
+
+          # Filter before all gateways call
+          before_gateways(kb_transaction, last_transaction, payment_source, amount_in_cents, currency, options)
+
+          # Dispatch to the gateways. In most cases (non split settlements), we only dispatch to a single gateway account
+          gw_responses                  = []
+          responses                     = []
+          transactions                  = []
+          payment_processor_account_ids = options[:payment_processor_account_ids].nil? ? [options[:payment_processor_account_id] || :default] : options[:payment_processor_account_ids].split(',')
+          payment_processor_account_ids.each do |payment_processor_account_id|
+            # Find the gateway
+            gateway = lookup_gateway(payment_processor_account_id)
+
+            # Filter before each gateway call
+            before_gateway(gateway, kb_transaction, last_transaction, payment_source, amount_in_cents, currency, options)
+
+            # Perform the operation in the gateway
+            gw_response           = gateway_call_proc.call(gateway, payment_source, amount_in_cents, options)
+            response, transaction = save_response_and_transaction(gw_response, operation, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, operation.upcase, amount_in_cents, currency)
+
+            # Filter after each gateway call
+            after_gateway(response, transaction, gw_response)
+
+            gw_responses << gw_response
+            responses << response
+            transactions << transaction
+          end
+
+          # Filter after all gateways call
+          after_gateways(responses, transactions, gw_responses)
+
+          # Merge data
+          merge_transaction_info_plugins(payment_processor_account_ids, responses, transactions)
+        end
+
         def get_kb_transaction(kb_payment_id, kb_payment_transaction_id, kb_tenant_id)
           kb_payment     = @kb_apis.payment_api.get_payment(kb_payment_id, false, [], @kb_apis.create_context(kb_tenant_id))
           kb_transaction = kb_payment.transactions.find { |t| t.id == kb_payment_transaction_id }
@@ -410,7 +390,13 @@ module Killbill
           kb_transaction
         end
 
-        def before_gateway(kb_transaction, transaction, payment_source, amount_in_cents, currency, options)
+        def before_gateways(kb_transaction, last_transaction, payment_source, amount_in_cents, currency, options)
+        end
+
+        def after_gateways(response, transaction, gw_response)
+        end
+
+        def before_gateway(gateway, kb_transaction, last_transaction, payment_source, amount_in_cents, currency, options)
           # Can be used to implement idempotency for example: lookup the payment in the gateway
           # and pass options[:skip_gw] if the payment has already been through
         end
@@ -482,8 +468,10 @@ module Killbill
           return response, transaction
         end
 
-        def gateway
-          ::Killbill::Plugin::ActiveMerchant.gateway
+        def lookup_gateway(payment_processor_account_id=:default)
+          gateway = ::Killbill::Plugin::ActiveMerchant.gateways[payment_processor_account_id.to_sym]
+          raise "Unable to lookup gateway for payment_processor_account_id #{payment_processor_account_id}, gateways: #{::Killbill::Plugin::ActiveMerchant.gateways}" if gateway.nil?
+          gateway
         end
 
         def config
@@ -518,6 +506,68 @@ module Killbill
         def get_active_merchant_module
           ::ActiveMerchant::Billing::Integrations.const_get(@identifier.to_s.camelize)
         end
+
+        def merge_transaction_info_plugins(payment_processor_account_ids, responses, transactions)
+          result                             = Killbill::Plugin::Model::PaymentTransactionInfoPlugin.new
+          result.amount                      = nil
+          result.properties                  = []
+          result.status                      = :PROCESSED
+          # Nothing meaningful we can set here
+          result.first_payment_reference_id  = nil
+          result.second_payment_reference_id = nil
+
+          responses.each_with_index do |response, idx|
+            t_info_plugin = response.to_transaction_info_plugin(transactions[idx])
+            if responses.size == 1
+              # We're done
+              return t_info_plugin
+            end
+
+            # Unique values
+            [:kb_payment_id, :kb_transaction_payment_id, :transaction_type, :currency].each do |element|
+              result_element        = result.send(element)
+              t_info_plugin_element = t_info_plugin.send(element)
+              if result_element.nil?
+                result.send("#{element}=", t_info_plugin_element)
+              elsif result_element != t_info_plugin_element
+                raise "#{element.to_s} mismatch, #{result_element} != #{t_info_plugin_element}"
+              end
+            end
+
+            # Arbitrary values
+            [:created_date, :effective_date].each do |element|
+              if result.send(element).nil?
+                result.send("#{element}=", t_info_plugin.send(element))
+              end
+            end
+
+            t_info_plugin.properties.each do |property|
+              prop       = Killbill::Plugin::Model::PluginProperty.new
+              prop.key   = "#{property.key}_#{payment_processor_account_ids[idx]}"
+              prop.value = property.value
+              result.properties << prop
+            end
+
+            if result.amount.nil?
+              result.amount = t_info_plugin.amount
+            elsif !t_info_plugin.nil?
+              # TODO Adding decimals - are we losing precision?
+              result.amount = result.amount + t_info_plugin.amount
+            end
+
+            # We set an error status if we have at least one error
+            # TODO Does this work well with retries?
+            if t_info_plugin.status == :ERROR
+              result.status             = :ERROR
+
+              # Return the first error
+              result.gateway_error      = t_info_plugin.gateway_error if  result.gateway_error.nil?
+              result.gateway_error_code = t_info_plugin.gateway_error_code if  result.gateway_error_code.nil?
+            end
+          end
+
+          result
+        end
       end
     end
   end

data/lib/killbill/helpers/active_merchant/utils.rb

@@ -20,16 +20,73 @@ module Killbill
         # Relies on the fact that hashes enumerate their values in the order that the corresponding keys were inserted (Ruby 1.9+)
         class BoundedLRUCache
 
-          def initialize(proc, max_size=1000)
+          def initialize(proc, max_size=10000)
             @proc     = proc
             @max_size = max_size
 
-            @semaphore = Mutex.new
-            # TODO Pre-allocate?
-            @data      = {}
+            if defined?(JRUBY_VERSION)
+              @is_jruby  = true
+              @semaphore = nil
+
+              lru_cache = Class.new(java.util.LinkedHashMap) do
+                def initialize(max_size)
+                  super(max_size, 1.0, true)
+                  @max_size = max_size
+                end
+
+                # Note: renaming it to remove_eldest_entry won't work
+                def removeEldestEntry(eldest)
+                  size > @max_size
+                end
+              end.new(@max_size)
+              @data     = java.util.Collections.synchronizedMap(lru_cache)
+            else
+              @is_jruby  = false
+              @semaphore = Mutex.new
+              # TODO Pre-allocate?
+              @data      = {}
+            end
           end
 
           def [](key)
+            @is_jruby ? jruby_get(key) : ruby_get(key)
+          end
+
+          def []=(key, val)
+            @is_jruby ? jruby_set(key, val) : ruby_set(key, val)
+          end
+
+          # For testing
+
+          def size
+            @data.size
+          end
+
+          def keys_to_a
+            @is_jruby ? @data.key_set.to_a : @data.keys
+          end
+
+          def values_to_a
+            @is_jruby ? @data.values.to_a : @data.values
+          end
+
+          private
+
+          def jruby_get(key)
+            value = @data.get(key)
+            if value.nil?
+              value = @proc.call(key)
+              # Somebody may have beaten us to it but the mapping key -> value is constant for our purposes
+              jruby_set(key, value)
+            end
+            value
+          end
+
+          def jruby_set(key, val)
+            @data.put(key, val)
+          end
+
+          def ruby_get(key)
             @semaphore.synchronize do
               found = true
               value = @data.delete(key) { found = false }
@@ -43,7 +100,7 @@ module Killbill
             end
           end
 
-          def []=(key, val)
+          def ruby_set(key, val)
             @semaphore.synchronize do
               @data.delete(key)
               @data[key] = val

data/spec/killbill/helpers/configuration_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Killbill::Plugin::ActiveMerchant do
+
+  before(:all) do
+    @logger       = Logger.new(STDOUT)
+    @logger.level = Logger::INFO
+  end
+
+  it 'should support a configuration for a single gateway' do
+    do_initialize!(<<-eos)
+  :login: admin
+  :password: password
+  :test: true
+    eos
+
+    do_common_checks
+
+    gw = ::Killbill::Plugin::ActiveMerchant.gateways
+    gw.size.should == 1
+    gw[:default][:login].should == 'admin'
+    gw[:default][:password].should == 'password'
+  end
+
+  it 'should support a configuration for multiple gateways with a default' do
+    do_initialize!(<<-eos)
+  - :account_id: :credentials_1
+    :test: true
+    :login: admin_1
+    :password: password_1
+  - :account_id: :credentials_2
+    :test: true
+    :login: admin_2
+    :password: password_2
+  - :account_id: :default
+    :test: true
+    :login: admin_3
+    :password: password_3
+  - :account_id: :credentials_4
+    :test: true
+    :login: admin_4
+    :password: password_4
+    eos
+
+    do_common_checks
+
+    gw = ::Killbill::Plugin::ActiveMerchant.gateways
+    gw.size.should == 4
+    [1, 2, 4].each do |i|
+      gw["credentials_#{i}".to_sym][:login].should == "admin_#{i}"
+      gw["credentials_#{i}".to_sym][:password].should == "password_#{i}"
+    end
+    gw[:default][:login].should == 'admin_3'
+    gw[:default][:password].should == 'password_3'
+  end
+
+  it 'should support a configuration for multiple gateways without a default' do
+    do_initialize!(<<-eos)
+  - :account_id: :credentials_1
+    :login: admin_1
+    :password: password_1
+  - :account_id: :credentials_2
+    :login: admin_2
+    :password: password_2
+  - :account_id: :credentials_3
+    :login: admin_3
+    :password: password_3
+  - :account_id: :credentials_4
+    :login: admin_4
+    :password: password_4
+    eos
+
+    do_common_checks
+
+    gw = ::Killbill::Plugin::ActiveMerchant.gateways
+    gw.size.should == 5
+    [1, 2, 3, 4].each do |i|
+      gw["credentials_#{i}".to_sym][:login].should == "admin_#{i}"
+      gw["credentials_#{i}".to_sym][:password].should == "password_#{i}"
+    end
+    gw[:default][:login].should == 'admin_1'
+    gw[:default][:password].should == 'password_1'
+  end
+
+  private
+
+  def do_common_checks
+    ::Killbill::Plugin::ActiveMerchant.config.should_not be_nil
+    ::Killbill::Plugin::ActiveMerchant.currency_conversions.should be_nil
+    ::Killbill::Plugin::ActiveMerchant.initialized.should be_true
+    ::Killbill::Plugin::ActiveMerchant.kb_apis.should_not be_nil
+    ::Killbill::Plugin::ActiveMerchant.logger.should == @logger
+  end
+
+  def do_initialize!(extra_config='')
+    Dir.mktmpdir do |dir|
+      file = File.new(File.join(dir, 'test.yml'), 'w+')
+      file.write(<<-eos)
+:test:
+#{extra_config}
+# As defined by spec_helper.rb
+:database:
+  :adapter: 'sqlite3'
+  :database: 'test.db'
+      eos
+      file.close
+
+      ::Killbill::Plugin::ActiveMerchant.initialize! Proc.new { |config| config },
+                                                     :test,
+                                                     @logger,
+                                                     file.path,
+                                                     ::Killbill::Plugin::KillbillApi.new('test', {})
+    end
+  end
+end

data/spec/killbill/helpers/connection_spec.rb

@@ -9,7 +9,8 @@ describe Killbill::Plugin::ActiveMerchant::Utils do
     # Verify the reaper is a no-op. Management is in our hands
     pool.reaper.frequency.should be_nil
 
-    # spec_helper created the table, so there is one active connection for that thread already
+    # Check-out a new connection or retrieve the one associated with the thread
+    ::ActiveRecord::Base.connection.should_not be_nil
     pool.active_connection?.should be_true
     pool.connections.size.should == 1
 

data/spec/killbill/helpers/utils_spec.rb

@@ -1,22 +1,80 @@
 require 'spec_helper'
 
 describe Killbill::Plugin::ActiveMerchant::Utils do
-  it "should convert back and forth UUIDs" do
-    uuid = SecureRandom.uuid
-    packed = Killbill::Plugin::ActiveMerchant::Utils.compact_uuid(uuid)
+  it 'should convert back and forth UUIDs' do
+    uuid     = SecureRandom.uuid
+    packed   = Killbill::Plugin::ActiveMerchant::Utils.compact_uuid(uuid)
     unpacked = Killbill::Plugin::ActiveMerchant::Utils.unpack_uuid(packed)
     unpacked.should == uuid
   end
 
-  it "should respect leading 0s" do
-    uuid = "0ae18a4c-be57-44c3-84ba-a82962a2de03"
+  it 'should respect leading 0s' do
+    uuid = '0ae18a4c-be57-44c3-84ba-a82962a2de03'
     0.upto(35) do |i|
       # Skip hyphens
       next if [8, 13, 18, 23].include?(i)
-      uuid[i] = '0'
-      packed = Killbill::Plugin::ActiveMerchant::Utils.compact_uuid(uuid)
+      uuid[i]  = '0'
+      packed   = Killbill::Plugin::ActiveMerchant::Utils.compact_uuid(uuid)
       unpacked = Killbill::Plugin::ActiveMerchant::Utils.unpack_uuid(packed)
       unpacked.should == uuid
     end
   end
+
+  it 'should implement a thread-safe LRU cache' do
+    require 'benchmark'
+
+    runs            = 2
+    cache_size      = 50
+    nb_threads      = 200
+    keys_per_thread = 1000
+
+    cache = nil
+    bm    = Benchmark.bm do |x|
+      runs.times do |n|
+        x.report("run ##{n}:") do
+          cache = ::Killbill::Plugin::ActiveMerchant::Utils::BoundedLRUCache.new(Proc.new { |value| -1 }, cache_size)
+
+          threads = (0..nb_threads).map do |i|
+            Thread.new do
+              (0..keys_per_thread).each do |j|
+                key        = 1001 * i + j
+                value      = rand(2000)
+                cache[key] = value
+                cache[key].should satisfy { |cache_value| cache_value == -1 or cache_value == value }
+              end
+            end
+          end
+
+          threads.each { |thread| thread.join }
+        end
+      end
+    end
+
+    last_keys   = cache.keys_to_a
+    last_values = cache.values_to_a
+    0.upto(cache_size - 1) do |i|
+      # No overlap with test keys or values above
+      cache[-1 * i - 1] = -2
+
+      new_keys   = cache.keys_to_a
+      new_values = cache.values_to_a
+
+      # Verify the changes we made
+      0.upto(i) do |j|
+        idx            = cache_size - j - 1
+        expected_key   = -1 * (i - j) - 1
+        expected_value = -2
+
+        new_keys[idx].should eq(expected_key), "i=#{i}, j=#{j}, idx=#{idx}, expected_key=#{expected_key}, new_keys=#{new_keys.inspect}, last_keys=#{last_keys}"
+        new_values[idx].should eq(expected_value), "i=#{i}, j=#{j}, idx=#{idx}, expected_value=#{expected_value}, new_values=#{new_values.inspect}, last_values=#{last_values.inspect}"
+      end
+
+      # Check we didn't override older entries
+      new_keys.slice(0, cache_size - i - 1).should eq(last_keys.slice(i + 1, cache_size)), "i=#{i}, new_keys=#{new_keys.inspect}, last_keys=#{last_keys.inspect}"
+      new_values.slice(0, cache_size - i - 1).should eq(last_values.slice(i + 1, cache_size)), "i=#{i}, new_values=#{new_values.inspect}, last_values=#{last_values.inspect}"
+
+      # Check there is no change in cache size
+      cache.size.should == cache_size
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: killbill
 version: !ruby/object:Gem::Version
-  version: 3.1.9
+  version: 3.1.10
 platform: ruby
 authors:
 - Kill Bill core team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-09-16 00:00:00.000000000 Z
+date: 2014-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -255,6 +255,7 @@ files:
 - lib/killbill.rb
 - lib/killbill/creator.rb
 - lib/killbill/currency.rb
+- lib/killbill/ext/active_merchant/jdbc_connection.rb
 - lib/killbill/ext/active_merchant/typhoeus_connection.rb
 - lib/killbill/gen/api/account.rb
 - lib/killbill/gen/api/account_api_exception.rb
@@ -404,6 +405,7 @@ files:
 - spec/killbill/base_plugin_spec.rb
 - spec/killbill/config_test.ru
 - spec/killbill/gen_conversions_spec.rb
+- spec/killbill/helpers/configuration_spec.rb
 - spec/killbill/helpers/connection_spec.rb
 - spec/killbill/helpers/payment_method_spec.rb
 - spec/killbill/helpers/payment_plugin_spec.rb
@@ -455,6 +457,7 @@ test_files:
 - spec/killbill/base_plugin_spec.rb
 - spec/killbill/config_test.ru
 - spec/killbill/gen_conversions_spec.rb
+- spec/killbill/helpers/configuration_spec.rb
 - spec/killbill/helpers/connection_spec.rb
 - spec/killbill/helpers/payment_method_spec.rb
 - spec/killbill/helpers/payment_plugin_spec.rb