killbill 3.2.2 → 3.2.3

data/lib/killbill/gen/plugin-api/require_gen.rb

@@ -28,10 +28,13 @@
 require 'killbill/gen/plugin-api/payment_method_info_plugin'
 require 'killbill/gen/plugin-api/payment_plugin_api'
 require 'killbill/gen/plugin-api/payment_plugin_api_exception'
+require 'killbill/gen/plugin-api/payment_plugin_with_events_api'
 require 'killbill/gen/plugin-api/ext_bus_event'
 require 'killbill/gen/plugin-api/notification_plugin_api'
 require 'killbill/gen/plugin-api/invoice_plugin_api'
+require 'killbill/gen/plugin-api/invoice_plugin_with_events_api'
 require 'killbill/gen/plugin-api/currency_plugin_api'
+require 'killbill/gen/plugin-api/currency_plugin_with_events_api'
 require 'killbill/gen/plugin-api/gateway_notification'
 require 'killbill/gen/plugin-api/hosted_payment_page_form_descriptor'
 require 'killbill/gen/plugin-api/payment_transaction_info_plugin'

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

@@ -1,73 +1,143 @@
 require 'logger'
+require 'thread_safe'
 
 module Killbill
   module Plugin
     module ActiveMerchant
-      mattr_reader :config
-      mattr_reader :currency_conversions
-      mattr_reader :gateways
+
+      mattr_reader :glob_config
+      mattr_reader :glob_currency_conversions
+
       mattr_reader :initialized
       mattr_reader :kb_apis
+      mattr_reader :gateway_name
+      mattr_reader :gateway_builder
       mattr_reader :logger
+      mattr_reader :config_key_name
+      mattr_reader :per_tenant_config_cache
 
-      def self.initialize!(gateway_builder, gateway_name, logger, config_file, kb_apis)
-        @@config = Properties.new(config_file)
-        @@config.parse!
 
-        @@logger           = logger
-        @@logger.log_level = Logger::DEBUG if (@@config[:logger] || {})[:debug]
+      class << self
 
-        @@currency_conversions = @@config[:currency_conversions]
-        @@kb_apis              = kb_apis
+        def initialize!(gateway_builder, gateway_name, logger, config_key_name, config_file, kb_apis)
 
-        @@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
+          @@logger = logger
+          @@kb_apis = kb_apis
+          @@gateway_name = gateway_name
+          @@gateway_builder = gateway_builder
+          @@config_key_name = config_key_name
+          @@per_tenant_config_cache = ThreadSafe::Cache.new
+
+          if defined?(JRUBY_VERSION)
+            begin
+              # See https://github.com/jruby/activerecord-jdbc-adapter/issues/302
+              require 'jdbc/mysql'
+              ::Jdbc::MySQL.load_driver(:require) if ::Jdbc::MySQL.respond_to?(:load_driver)
+            rescue => e
+              @@logger.warn "Unable to load the JDBC driver: #{e}"
             end
           end
-          @@gateways[:default] = default_gateway if @@gateways[:default].nil?
-        else
-          @@gateways[:default] = Gateway.wrap(gateway_builder, logger, gateway_configs)
+
+          initialize_from_global_config!(gateway_builder, gateway_name, logger, config_file)
         end
 
-        if defined?(JRUBY_VERSION)
-          begin
-            # See https://github.com/jruby/activerecord-jdbc-adapter/issues/302
-            require 'jdbc/mysql'
-            ::Jdbc::MySQL.load_driver(:require) if ::Jdbc::MySQL.respond_to?(:load_driver)
-          rescue => e
-            @@logger.warn "Unable to load the JDBC driver: #{e}"
+
+        def gateways(kb_tenant_id=nil)
+          tenant_config = get_tenant_config(kb_tenant_id)
+          extract_gateway_config(tenant_config)
+        end
+
+        def currency_conversions(kb_tenant_id=nil)
+          tenant_config = get_tenant_config(kb_tenant_id)
+          if tenant_config
+            tenant_config[:currency_conversions]
+          else
+            @@glob_currency_conversions
           end
         end
 
-        begin
-          require 'active_record'
-          ::ActiveRecord::Base.establish_connection(@@config[:database])
-          ::ActiveRecord::Base.logger = @@logger
-        rescue => e
-          @@logger.warn "Unable to establish a database connection: #{e}"
+        def config(kb_tenant_id=nil)
+          get_tenant_config(kb_tenant_id)
         end
 
-        # Configure the ActiveMerchant HTTP backend
-        connection_type = (@@config[:active_merchant] || {})[:connection_type]
-        if connection_type == :typhoeus
-          require 'killbill/ext/active_merchant/typhoeus_connection'
+        def converted_currency(currency, kb_tenant_id=nil)
+          currency_sym = currency.to_s.upcase.to_sym
+          tmp = currency_conversions(kb_tenant_id)
+          tmp && tmp[currency_sym]
         end
 
-        @@initialized = true
-      end
+        def invalidate_tenant_config!(kb_tenant_id)
+          @@logger.info("Invalidate plugin key #{@@config_key_name}, tenant = #{kb_tenant_id}")
+          @@per_tenant_config_cache[kb_tenant_id] = nil
+        end
+
+        private
+
+        def extract_gateway_config(config)
+          gateways_config = {}
+          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_config[gateway_account_id.to_sym] = Gateway.wrap(gateway_builder, logger, gateway_config)
+                default_gateway = gateways_config[gateway_account_id.to_sym] if idx == 0
+              end
+            end
+            gateways_config[:default] = default_gateway if gateways_config[:default].nil?
+          else
+            gateways_config[:default] = Gateway.wrap(@@gateway_builder, logger, gateway_configs)
+          end
+          gateways_config
+        end
 
-      def self.converted_currency(currency)
-        currency_sym = currency.to_s.upcase.to_sym
-        @@currency_conversions && @@currency_conversions[currency_sym]
+        def get_tenant_config(kb_tenant_id)
+
+          if @@per_tenant_config_cache[kb_tenant_id].nil?
+            # Make the api api to verify if there is a per tenant value
+            context = @@kb_apis.create_context(kb_tenant_id) if kb_tenant_id
+            values = @@kb_apis.tenant_user_api.get_tenant_values_for_key(@@config_key_name, context) if context
+            # If we have a per tenant value, insert it into the cache
+            if values && values[0]
+              parsed_config = YAML.load(values[0])
+              @@per_tenant_config_cache[kb_tenant_id] = parsed_config
+              # Otherwise, add global config so we don't have to make the tenant call on each operation
+            else
+              @@per_tenant_config_cache[kb_tenant_id] = @@glob_config
+            end
+          end
+          # Return value from cache in any case
+          @@per_tenant_config_cache[kb_tenant_id]
+        end
+
+        def initialize_from_global_config!(gateway_builder, gateway_name, logger, config_file)
+          # Look for global config
+          @@glob_config = Properties.new(config_file)
+          @@glob_config.parse!
+
+          @@logger.log_level = Logger::DEBUG if (@@glob_config[:logger] || {})[:debug]
+
+          @@glob_currency_conversions = @@glob_config[:currency_conversions]
+
+          begin
+            require 'active_record'
+            ::ActiveRecord::Base.establish_connection(@@glob_config[:database])
+            ::ActiveRecord::Base.logger = @@logger
+          rescue => e
+            @@logger.warn "Unable to establish a database connection: #{e}"
+          end
+
+          # Configure the ActiveMerchant HTTP backend
+          connection_type = (@@glob_config[:active_merchant] || {})[:connection_type]
+          if connection_type == :typhoeus
+            require 'killbill/ext/active_merchant/typhoeus_connection'
+          end
+
+          @@initialized = true
+        end
       end
     end
   end

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

@@ -13,18 +13,18 @@ module Killbill
             create_kb_account kb_account_id
           end
 
-          context       = @plugin.kb_apis.create_context(kb_tenant_id)
-          account       = @plugin.kb_apis.account_user_api.get_account_by_id(kb_account_id, context)
+          context = @plugin.kb_apis.create_context(kb_tenant_id)
+          account = @plugin.kb_apis.account_user_api.get_account_by_id(kb_account_id, context)
 
           # The rest is pure Ruby
-          context       = context.to_ruby(context)
+          context = context.to_ruby(context)
 
           # Generate a token
           pm_properties = build_pm_properties(account, options)
 
-          info            = Killbill::Plugin::Model::PaymentMethodPlugin.new
+          info = Killbill::Plugin::Model::PaymentMethodPlugin.new
           info.properties = pm_properties
-          payment_method  = @plugin.add_payment_method(kb_account_id, kb_payment_method_id, info, true, properties, context)
+          payment_method = @plugin.add_payment_method(kb_account_id, kb_payment_method_id, info, true, properties, context)
 
           pm = payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
           pm.should == payment_method
@@ -35,19 +35,19 @@ module Killbill
         end
 
         def build_pm_properties(account = nil, overrides = {})
-          cc_number             = (overrides.delete(:cc_number) || '4242424242424242')
-          cc_first_name         = (overrides.delete(:cc_first_name) || 'John')
-          cc_last_name          = (overrides.delete(:cc_last_name) || 'Doe')
-          cc_type               = (overrides.delete(:cc_type) || 'Visa')
-          cc_exp_month          = (overrides.delete(:cc_exp_month) || 12)
-          cc_exp_year           = (overrides.delete(:cc_exp_year) || 2017)
-          cc_last_4             = (overrides.delete(:cc_last_4) || 4242)
-          address1              = (overrides.delete(:address1) || '5, oakriu road')
-          address2              = (overrides.delete(:address2) || 'apt. 298')
-          city                  = (overrides.delete(:city) || 'Gdio Foia')
-          state                 = (overrides.delete(:state) || 'FL')
-          zip                   = (overrides.delete(:zip) || 49302)
-          country               = (overrides.delete(:country) || 'US')
+          cc_number = (overrides.delete(:cc_number) || '4242424242424242')
+          cc_first_name = (overrides.delete(:cc_first_name) || 'John')
+          cc_last_name = (overrides.delete(:cc_last_name) || 'Doe')
+          cc_type = (overrides.delete(:cc_type) || 'Visa')
+          cc_exp_month = (overrides.delete(:cc_exp_month) || 12)
+          cc_exp_year = (overrides.delete(:cc_exp_year) || 2017)
+          cc_last_4 = (overrides.delete(:cc_last_4) || 4242)
+          address1 = (overrides.delete(:address1) || '5, oakriu road')
+          address2 = (overrides.delete(:address2) || 'apt. 298')
+          city = (overrides.delete(:city) || 'Gdio Foia')
+          state = (overrides.delete(:state) || 'FL')
+          zip = (overrides.delete(:zip) || 49302)
+          country = (overrides.delete(:country) || 'US')
           cc_verification_value = (overrides.delete(:cc_verification_value) || 1234)
 
           properties = []
@@ -76,14 +76,14 @@ module Killbill
 
         def create_kb_account(kb_account_id)
           external_key = Time.now.to_i.to_s + '-test'
-          email        = external_key + '@tester.com'
+          email = external_key + '@tester.com'
 
-          account              = ::Killbill::Plugin::Model::Account.new
-          account.id           = kb_account_id
+          account = ::Killbill::Plugin::Model::Account.new
+          account.id = kb_account_id
           account.external_key = external_key
-          account.email        = email
-          account.name         = 'Integration spec'
-          account.currency     = :USD
+          account.email = email
+          account.name = 'Integration spec'
+          account.currency = :USD
 
           @account_api.accounts << account
 
@@ -91,8 +91,8 @@ module Killbill
         end
 
         def create_pm_kv_info(key, value)
-          prop       = ::Killbill::Plugin::Model::PluginProperty.new
-          prop.key   = key
+          prop = ::Killbill::Plugin::Model::PluginProperty.new
+          prop.key = key
           prop.value = value
           prop
         end
@@ -124,17 +124,17 @@ module Killbill
           def add_payment(kb_payment_id=SecureRandom.uuid, kb_payment_transaction_id=SecureRandom.uuid, kb_payment_transaction_external_key=SecureRandom.uuid, transaction_type=:PURCHASE)
             kb_payment = get_payment kb_payment_id
             if kb_payment.nil?
-              kb_payment              = ::Killbill::Plugin::Model::Payment.new
-              kb_payment.id           = kb_payment_id
+              kb_payment = ::Killbill::Plugin::Model::Payment.new
+              kb_payment.id = kb_payment_id
               kb_payment.transactions = []
               @payments << kb_payment
             end
 
-            kb_payment_transaction                  = ::Killbill::Plugin::Model::PaymentTransaction.new
-            kb_payment_transaction.id               = kb_payment_transaction_id
+            kb_payment_transaction = ::Killbill::Plugin::Model::PaymentTransaction.new
+            kb_payment_transaction.id = kb_payment_transaction_id
             kb_payment_transaction.transaction_type = transaction_type
-            kb_payment_transaction.external_key     = kb_payment_transaction_external_key
-            kb_payment_transaction.created_date     = Java::org.joda.time.DateTime.new(Java::org.joda.time.DateTimeZone::UTC)
+            kb_payment_transaction.external_key = kb_payment_transaction_external_key
+            kb_payment_transaction.created_date = Java::org.joda.time.DateTime.new(Java::org.joda.time.DateTimeZone::UTC)
             kb_payment.transactions << kb_payment_transaction
 
             kb_payment
@@ -144,6 +144,23 @@ module Killbill
             @payments.find { |payment| payment.id == id.to_s }
           end
         end
+
+        class FakeJavaTenantUserApi
+
+          attr_accessor :per_tenant_config
+
+          def initialize(per_tenant_config)
+            @per_tenant_config = per_tenant_config
+          end
+
+          def get_tenant_values_for_key(key, context)
+            result = @per_tenant_config[context.tenant_id.to_s]
+            if result
+              return [result]
+            end
+            nil
+          end
+        end
       end
     end
   end

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

@@ -17,14 +17,18 @@ module Killbill
           @payment_method_model = payment_method_model
           @transaction_model    = transaction_model
           @response_model       = response_model
+
         end
 
         def start_plugin
+
           @logger.progname = "#{@identifier.to_s}-plugin"
 
+          @config_key_name = "PLUGIN_CONFIG_#{@plugin_name}".to_sym
           ::Killbill::Plugin::ActiveMerchant.initialize! @gateway_builder,
                                                          @identifier.to_sym,
                                                          @logger,
+                                                         @config_key_name,
                                                          "#{@conf_dir}/#{@identifier.to_s}.yml",
                                                          @kb_apis
 
@@ -45,6 +49,14 @@ module Killbill
           @logger.debug { "after_request: pool.active_connection? = #{pool.active_connection?}, connection.active? = #{connection.active?}, pool.connections.size = #{pool.connections.size}, connections = #{pool.connections.inspect}" }
         end
 
+
+        def on_event(event)
+          if (event.event_type == :TENANT_CONFIG_CHANGE || event.event_type == :TENANT_CONFIG_DELETION) &&
+              event.meta_data.to_sym == @config_key_name
+            ::Killbill::Plugin::ActiveMerchant.invalidate_tenant_config!(event.tenant_id)
+          end
+        end
+
         def authorize_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
           gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
             gateway.authorize(amount_in_cents, payment_source, options)
@@ -161,7 +173,7 @@ module Killbill
 
           # Go to the gateway
           payment_processor_account_id = options[:payment_processor_account_id] || :default
-          gateway                      = lookup_gateway(payment_processor_account_id)
+          gateway                      = lookup_gateway(payment_processor_account_id, context.tenant_id)
           gw_response                  = gateway.store(payment_source, options)
           response, transaction        = save_response_and_transaction(gw_response, :add_payment_method, kb_account_id, context.tenant_id, payment_processor_account_id)
 
@@ -189,7 +201,7 @@ module Killbill
 
           # Delete the card
           payment_processor_account_id = options[:payment_processor_account_id] || :default
-          gateway                      = lookup_gateway(payment_processor_account_id)
+          gateway                      = lookup_gateway(payment_processor_account_id, context.tenant_id)
           if options[:customer_id]
             gw_response = gateway.unstore(options[:customer_id], pm.token, options)
           else
@@ -395,7 +407,7 @@ module Killbill
           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)
+            gateway = lookup_gateway(payment_processor_account_id, context.tenant_id)
 
             # Filter before each gateway call
             before_gateway(gateway, kb_transaction, last_transaction, payment_source, amount_in_cents, currency, options)
@@ -523,9 +535,9 @@ module Killbill
           return response, transaction
         end
 
-        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?
+        def lookup_gateway(payment_processor_account_id=:default, kb_tenant_id=nil)
+          gateway = ::Killbill::Plugin::ActiveMerchant.gateways(kb_tenant_id)[payment_processor_account_id.to_sym]
+          raise "Unable to lookup gateway for payment_processor_account_id #{payment_processor_account_id}, kb_tenant_id = #{kb_tenant_id}, gateways: #{::Killbill::Plugin::ActiveMerchant.gateways(kb_tenant_id)}" if gateway.nil?
           gateway
         end
 

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

@@ -85,9 +85,9 @@ module Killbill
           ::Killbill::Plugin::ActiveMerchant.kb_apis
         end
 
-        def 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?
+        def gateway(payment_processor_account_id=:default, kb_tenant_id=nil)
+          gateway = ::Killbill::Plugin::ActiveMerchant.gateways(kb_tenant_id)[payment_processor_account_id.to_sym]
+          raise "Unable to lookup gateway for payment_processor_account_id #{payment_processor_account_id}, , kb_tenant_id = #{kb_tenant_id}, gateways: #{::Killbill::Plugin::ActiveMerchant.gateways(kb_tenant_id)}" if gateway.nil?
           gateway
         end
 

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

@@ -1,3 +1,5 @@
+require 'thread_safe'
+
 module Killbill
   module Plugin
     module ActiveMerchant
@@ -46,100 +48,65 @@ module Killbill
           end
         end
 
-        # Relies on the fact that hashes enumerate their values in the order that the corresponding keys were inserted (Ruby 1.9+)
         class BoundedLRUCache
+          include ThreadSafe::Util::CheapLockable
 
-          def initialize(proc, max_size=10000)
-            @proc     = proc
+          def initialize(proc, max_size = 10000)
             @max_size = max_size
-
-            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      = {}
+            @data = ThreadSafe::Cache.new do |hash, key|
+              # mapping key -> value is constant for our purposes
+              set_value = hash.fetch_or_store key, value = proc.call(key)
+              store_key(key) if value.equal?(set_value) # very same object
+              set_value
             end
+            @keys = []
           end
 
-          def [](key)
-            @is_jruby ? jruby_get(key) : ruby_get(key)
-          end
+          def [](key); @data[key] end
 
           def []=(key, val)
-            @is_jruby ? jruby_set(key, val) : ruby_set(key, val)
+            prev_val = @data.get_and_set(key, val)
+            prev_val.nil? ? store_key(key) : update_key(key)
+            val
           end
 
-          # For testing
+          # @private for testing
+          def size; @data.size end
 
-          def size
-            @data.size
+          # @private for testing
+          def keys
+            cheap_synchronize { @keys.dup }
           end
 
-          def keys_to_a
-            @is_jruby ? @data.key_set.to_a : @data.keys
+          # @private for testing
+          def values
+            cheap_synchronize { @keys.map { |key| self[key] } }
           end
 
-          def values_to_a
-            @is_jruby ? @data.values.to_a : @data.values
-          end
+          protected
 
-          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)
+          def store_key(key)
+            cheap_synchronize do
+              @keys << key
+              remove_eldest_key_if_full
             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 }
-              if found
-                @data[key] = value
-              else
-                value      = @proc.call(key)
-                @data[key] = value
-                value
-              end
+          def update_key(key)
+            cheap_synchronize do
+              @keys.delete(key); @keys << key
+              remove_eldest_key_if_full
             end
           end
 
-          def ruby_set(key, val)
-            @semaphore.synchronize do
-              @data.delete(key)
-              @data[key] = val
-              if @data.length > @max_size
-                @data.delete(@data.first[0])
-              end
-              val
-            end
+          private
+
+          def remove_eldest_key_if_full
+            @data.delete @keys.shift if @data.size > @max_size
           end
+
         end
+
       end
     end
   end