killbill 3.2.4 → 4.0.0

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

@@ -87,7 +87,7 @@ module Killbill
 
         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?
+          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/properties.rb

@@ -1,3 +1,6 @@
+require 'erb'
+require 'yaml'
+
 module Killbill
   module Plugin
     module ActiveMerchant
@@ -8,13 +11,17 @@ module Killbill
 
         def parse!
           raise "#{@config_file} is not a valid file" unless @config_file.file?
-          @config = YAML.load_file(@config_file.to_s)
+          @config = YAML.load(ERB.new(File.read(@config_file.to_s)).result)
         end
 
         def [](key)
           @config[key]
         end
+
+        def to_hash
+          @config.dup
+        end
       end
     end
   end
-end
+end

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

@@ -5,10 +5,11 @@ module Killbill
         enable :sessions
 
         include ::ActionView::Helpers::FormTagHelper
+        include ::Killbill::Plugin::ActiveMerchant::ActiveRecordHelper
 
         helpers do
-          def config
-            ::Killbill::Plugin::ActiveMerchant.config
+          def config(kb_tenant_id=nil)
+            ::Killbill::Plugin::ActiveMerchant.config(kb_tenant_id)
           end
 
           def logger
@@ -22,12 +23,7 @@ module Killbill
 
         after do
           # return DB connections to the Pool if required
-          pool = ::ActiveRecord::Base.connection_pool
-          if pool.active_connection?
-            connection = ::ActiveRecord::Base.connection
-            pool.remove(connection)
-            connection.disconnect!
-          end
+          close_connection(logger)
         end
       end
     end

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

@@ -31,6 +31,33 @@ module Killbill
           Socket.ip_address_list.detect { |intf| intf.ipv4? and !intf.ipv4_loopback? and !intf.ipv4_multicast? and !intf.ipv4_private? }
         end
 
+        # Note: we assume options only contains keys as symbols
+        def self.normalized(options, key)
+          if !options.has_key?(key)
+            # Be friendly with Java-style conventions
+            camelized_key = key.to_s.camelize(false).to_sym
+            options.has_key?(camelized_key) ? normalize(options[camelized_key]) : nil
+          else
+            normalize(options[key])
+          end
+        end
+
+        def self.normalize(value)
+          case value.respond_to?(:strip) ? value.strip : value
+            when 'true' then true
+            when :true then true
+            when 'yes' then true
+            when :yes then true
+            when 'false' then false
+            when :false then false
+            when 'no' then false
+            when :no then false
+            when '' then nil
+            when 'null' then nil
+            else value
+          end
+        end
+
         class KBWiredumpDevice < IO
 
           # Required for compatibility, but unused
@@ -48,6 +75,23 @@ module Killbill
           end
         end
 
+        class LazyEvaluator
+
+          def initialize(&instantiator)
+            @instantiator = instantiator
+          end
+
+          def method_missing(method, *args)
+            __instance_object__.send(method, *args)
+          end
+
+          private
+
+          def __instance_object__
+            @__instance_object__ ||= @instantiator.call
+          end
+        end
+
         class BoundedLRUCache
           include ThreadSafe::Util::CheapLockable
 

data/lib/killbill/helpers/properties_helper.rb

@@ -0,0 +1,41 @@
+module Killbill
+  module Plugin
+    module PropertiesHelper
+
+      def find_value_from_properties(properties, key = nil)
+        return nil if key.nil?
+        prop = (properties.find { |kv| kv.key.to_s == key.to_s })
+        prop.nil? ? nil : prop.value
+      end
+
+      def hash_to_properties(options = {})
+        merge_properties([], options)
+      end
+
+      def properties_to_hash(properties, options = {})
+        merged = {}
+        (properties || []).each do |p|
+          merged[p.key.to_sym] = p.value
+        end
+        merged.merge(options)
+      end
+
+      def merge_properties(properties, options = {})
+        merged = properties_to_hash(properties, options)
+
+        properties = []
+        merged.each do |k, v|
+          properties << build_property(k, v)
+        end
+        properties
+      end
+
+      def build_property(key, value = nil)
+        prop = ::Killbill::Plugin::Model::PluginProperty.new
+        prop.key = key
+        prop.value = value
+        prop
+      end
+    end
+  end
+end

data/lib/killbill/http_servlet.rb

@@ -55,7 +55,14 @@ module Killbill
           headers[name] = servlet_request.get_headers(name).to_a
         end
 
-        response_status, response_headers, response_body = rack_service(request_uri, method, query_string, input, scheme, server_name, server_port, content_type, content_length, headers)
+        # Pass original attributes (e.g. to get access to killbill_tenant)
+        attributes = {}
+        servlet_request.attribute_names.each do |name|
+          value = servlet_request.get_attribute(name)
+          attributes[name] = value
+        end
+
+        response_status, response_headers, response_body = rack_service(request_uri, method, query_string, input, scheme, server_name, server_port, content_type, content_length, headers, attributes)
 
         # Set status
         servlet_response.status = response_status
@@ -80,10 +87,10 @@ module Killbill
         response_body.close if response_body.respond_to? :close
       end
 
-      def rack_service(request_uri = '/', method = 'GET', query_string = '', input = '', scheme = 'http', server_name = 'localhost', server_port = 4567, content_type = 'text/plain', content_length = 0, headers = {})
+      def rack_service(request_uri = '/', method = 'GET', query_string = '', input = '', scheme = 'http', server_name = 'localhost', server_port = 4567, content_type = 'text/plain', content_length = 0, headers = {}, attributes = {})
         return 503, {}, [] if @app.nil?
 
-        rack_env = {
+        rack_env = attributes.merge({
                 'rack.version' => Rack::VERSION,
                 'rack.multithread' => true,
                 'rack.multiprocess' => false,
@@ -99,7 +106,7 @@ module Killbill
                 'QUERY_STRING' => (query_string || ""),
                 'SERVER_NAME' => server_name,
                 'SERVER_PORT' => server_port.to_s
-        }
+        })
 
         rack_env['CONTENT_TYPE'] = content_type unless content_type.nil?
         rack_env['CONTENT_LENGTH']  = content_length unless content_length.nil?

data/lib/killbill/killbill_api.rb

@@ -8,10 +8,14 @@ module Killbill
     #
     class KillbillApi
 
-      def initialize(plugin_name, java_service_map)
+      # @VisibleForTesting
+      attr_reader :proxied_services
+
+      def initialize(plugin_name, proxied_services)
         @plugin_name = plugin_name
+        @proxied_services = proxied_services
         @services = {}
-        java_service_map.each do |k,v|
+        proxied_services.each do |k,v|
           @services[k.to_sym] = create_proxy_api(k, v)
         end
       end
@@ -24,7 +28,6 @@ module Killbill
         raise NoMethodError.new("undefined method `#{m}' for #{self}")
       end
 
-
       def create_context(tenant_id=nil, user_token=nil, reason_code=nil, comments=nil)
         context = Killbill::Plugin::Model::CallContext.new
         context.tenant_id= tenant_id
@@ -45,7 +48,6 @@ module Killbill
         proxy_class_name = "Killbill::Plugin::Api::#{api_name.to_s.split('_').map{|e| e.capitalize}.join}"
         proxy_class_name.to_class.new(java_api)
       end
-
     end
   end
 end

data/lib/killbill/rake_task.rb

@@ -1,8 +1,8 @@
 require 'bundler'
 require 'logger'
 require 'pathname'
+require 'tmpdir'
 require 'rake'
-require 'rake/packagetask'
 require 'rubygems/installer'
 
 module Killbill
@@ -11,12 +11,13 @@ module Killbill
 
     class << self
       def install_tasks(opts = {})
-        new(opts[:base_name] || Dir.pwd,                # Path to the plugin root directory (where the gempec and/or Gemfile should be)
-            opts[:plugin_name],                         # Plugin name, e.g. 'klogger'
-            opts[:gem_name],                            # Gem file name, e.g. 'klogger-1.0.0.gem'
-            opts[:gemfile_name] || "Gemfile",           # Gemfile name
-            opts[:gemfile_lock_name] || "Gemfile.lock", # Gemfile.lock name
-            opts[:verbose] || false)
+        gemfile_name = ENV['BUNDLE_GEMFILE'] || 'Gemfile'
+        new(opts[:base_name] || Dir.pwd,          # Path to the plugin root directory (where the gempec and/or Gemfile should be)
+            opts[:plugin_name],                   # Plugin name, e.g. 'klogger'
+            opts[:gem_name],                      # Gem file name, e.g. 'klogger-1.0.0.gem'
+            opts[:gemfile_name] || gemfile_name,  # Gemfile name
+            opts[:gemfile_lock_name] || "#{gemfile_name}.lock",
+            opts.key?(:verbose) ? opts[:verbose] : ENV['VERBOSE'] == 'true')
         .install
       end
     end
@@ -25,6 +26,14 @@ module Killbill
       @verbose = verbose
 
       @logger = Logger.new(STDOUT)
+      @logger.formatter = proc do |severity, datetime, _, msg|
+        date_format = datetime.strftime('%Y-%m-%d %H:%M:%S.%L')
+        if severity == "INFO" || severity == "WARN"
+          "KillBill [#{date_format}] #{severity}  : #{msg}\n"
+        else
+          "KillBill [#{date_format}] #{severity} : #{msg}\n"
+        end
+      end
       @logger.level = @verbose ? Logger::DEBUG : Logger::INFO
 
       @base_name = base_name
@@ -37,27 +46,70 @@ module Killbill
       @base = Pathname.new(@base_name).expand_path
 
       # Find the gemspec to determine name and version
-      @plugin_gemspec = find_plugin_gemspec
+      @plugin_gemspec = load_plugin_gemspec
 
+      @package_dir = Pathname.new('pkg').expand_path
+      FileUtils.mkdir_p @package_dir
       # Temporary build directory
-      # Don't use 'pkg' as it is used by Rake::PackageTask already: it will
-      # hard link all files from @package_dir to pkg to avoid tar'ing up symbolic links
-      @package_dir = Pathname.new(name).expand_path
+      # will hard link all files from @package_tmp_dir to pkg to avoid tar'ing
+      # up symbolic links (similar to how Rake::PackageTask does prepare files)
+      @package_tmp_dir = Pathname.new(File.join('tmp', name)).expand_path
+
+      @root_dir_path = 'ROOT' # plugin's ROOT directory
+      @gems_dir_path = File.join(@root_dir_path, 'gems')
+      # Staging area to install the killbill.properties and config.ru files
+      @plugin_target_dir = @package_tmp_dir.join("#{version}").expand_path
+      @plugin_root_target_dir = @plugin_target_dir.join(@root_dir_path)
 
       # Staging area to install gem dependencies
       # Note the Killbill friendly structure (which we will keep in the tarball)
-      @target_dir = @package_dir.join("#{version}/gems").expand_path
+      @plugin_gem_target_dir = @plugin_target_dir.join(@gems_dir_path)
+    end
 
-      # Staging area to install the killbill.properties and config.ru files
-      @plugin_root_target_dir = @package_dir.join("#{version}").expand_path
+    attr_reader :base
+
+    def name
+      @plugin_gemspec.name
+    end
+
+    def version
+      @plugin_gemspec.version
     end
 
     def specs
       # Rely on the Gemfile definition, if it exists, to get all dependencies
       # (we assume the Gemfile includes the plugin gemspec, as it should).
-      # Otherwise, use only the plugin gemspec.
-      # When using the Gemfile definition, don't include the :development group -- should this be configurable?
-      @specs ||= @gemfile_definition ? @gemfile_definition.specs_for([:default]) : [@plugin_gemspec]
+      # Otherwise, use recursively retrieve the plugin gemspec' runtime dependencies
+      # ... resolves all gems as they are currently installed with RubyGems
+      @specs ||=
+        if @gemfile_definition
+          # don't include the :development group
+          @gemfile_definition.specs_for([:default])
+        else
+          get_dependencies = lambda do |spec|
+            deps = ( spec.runtime_dependencies || [] ).map(&:to_spec)
+            deps.dup.each { |spec| deps += get_dependencies.call(spec) }
+            deps.uniq
+          end
+          all_dependencies = get_dependencies.call(@plugin_gemspec)
+          all_dependencies.dup.each do |spec|
+            next unless all_dependencies.include?(spec) # removed previously
+
+            # duplicate gemspec of same name might get included since we did
+            # not really do through the gem activation hustle, lowest version
+            # should win since those tend to be matched by strict requirements
+            if other_spec = all_dependencies.find { |s| s.name == spec.name && s != spec }
+              if other_spec.version > spec.version
+                @logger.debug "Discarding matched gem '#{spec.name}' version #{other_spec.version} in favor of #{spec.version}"
+                all_dependencies.delete(other_spec)
+              else # other_spec.version < spec.version
+                @logger.debug "Discarding matched gem '#{spec.name}' version #{spec.version} in favor of #{other_spec.version}"
+                all_dependencies.delete(spec)
+              end
+            end
+          end
+          [ @plugin_gemspec ] + all_dependencies
+        end
     end
 
     def install
@@ -69,64 +121,175 @@ module Killbill
           validate
         end
 
-        # Build the .tar.gz and .zip packages
-        task :package, [:verbose] => :stage
-        package_task = Rake::PackageTask.new(name, version) do |p|
-          p.need_tar_gz = true
-          p.need_zip = true
+        desc "Build all package files for #{name} plugin #{version}"
+        task :package, [:verbose] => :stage # builds .tar.gz & .zip packages
+
+        package_name = "#{name}-#{version}"
+        package_dir = @package_dir.realpath # pkg
+        package_dir_path = File.join(package_dir, package_name) # pkg/killbill-xxx-0.1.2
+
+        task :package => [ tar_gz_file = File.join(package_dir, "#{package_name}.tar.gz") ]
+        file tar_gz_file => [ package_dir_path, 'package:files' ] do
+          chdir(package_dir) do
+            tar_command = 'tar'
+            sh tar_command, "zcvf", tar_gz_file, package_name
+          end
+        end
+
+        task :package => [ zip_file = File.join(package_dir, "#{package_name}.zip") ]
+        file zip_file => [ package_dir_path, 'package:files' ] do
+          chdir(package_dir) do
+            zip_command = 'zip'
+            sh zip_command, "-r", zip_file, package_name
+          end
+        end
+
+        directory package_dir_path
+        task 'package:files' do
+          # move files from tmp directory to pkg (based on how rake does)
+          basename = Regexp.escape(@package_tmp_dir.basename.to_s)
+          tmp_path = @package_tmp_dir.realpath.to_s
+          realpath_tmp_prefix = tmp_path.sub(/\/#{basename}$/, '')
+          package_files = Rake::FileList.new("#{tmp_path}/**/*")
+
+          package_files.each do |fn|
+            f = File.join(package_dir_path, fn.sub(realpath_tmp_prefix, ''))
+            fdir = File.dirname(f)
+            mkdir_p(fdir) unless File.exist?(fdir)
+            if File.directory?(fn)
+              mkdir_p(f)
+            else
+              rm_f f
+              safe_ln(fn, f)
+            end
+          end
         end
 
-        desc "Stage all dependencies"
-        task :stage, [:verbose] => :validate do |t, args|
+        desc "Force a rebuild of package files for #{name} plugin #{version}"
+        task :repackage => [:clobber_package, :package]
+
+        task :clobber_tmp do
+          rm_f @package_tmp_dir rescue nil
+        end
+
+        desc "Remove package files from #{@package_dir}"
+        task :clobber_package do
+          rm_f tar_gz_file if File.exist?(tar_gz_file)
+          rm_f zip_file if File.exist?(zip_file)
+          rm_r package_dir_path rescue nil
+        end
+        task :clobber => [:clobber_tmp, :clobber_package]
+
+        task 'stage:init' do
+          # NOOP task for plugins to hook up if they need some sort of initialization
+          #  (task will be run in the context of the Killbill::PluginHelper instance)
+          # NOTE: no need for post (stage:done) hook since it's easy using Rake :
+          #  Rake::Task["killbill:package"].enhance { ... }
+        end
+
+        desc "Stage dependencies for #{name} plugin #{version}"
+        task :stage, [:verbose] => [ :validate, 'stage:init' ] do |t, args|
           set_verbosity(args)
 
+          mkdir_p @plugin_target_dir.to_s, :verbose => @verbose
+
           stage_dependencies
           stage_extra_files
-
-          # Small hack! Update the list of files to package (Rake::FileList is evaluated too early above)
-          package_task.package_files = Rake::FileList.new("#{@package_dir.basename}/**/*")
         end
 
-        desc "Deploy the plugin to Kill Bill"
+        desc "Deploy #{name} plugin #{version} to KillBill server"
         task :deploy, [:force, :plugin_dir, :verbose] => :stage do |t, args|
-          set_verbosity(args)
+          plugins_dir = prepare_deploy(t, args)
 
-          plugins_dir = Pathname.new("#{args.plugin_dir || '/var/tmp/bundles/plugins/ruby'}").expand_path
-          mkdir_p plugins_dir, :verbose => @verbose
+          cp_r @package_tmp_dir, plugins_dir, :verbose => @verbose
 
-          plugin_path = Pathname.new("#{plugins_dir}/#{name}")
-          if plugin_path.exist?
-            if args.force == "true"
-              @logger.info "Deleting previous plugin deployment #{plugin_path}"
-              rm_rf plugin_path, :verbose => @verbose
-            else
-              raise "Cowardly not deleting previous plugin deployment #{plugin_path} - override with rake killbill:deploy[true]"
-            end
-          end
+          deploy_config_files plugin_path(plugins_dir) # .../[name]/[version]
+        end
+
+        desc "Deploy plugin in development mode (without staging)"
+        task 'deploy:dev', [:force, :plugin_dir, :verbose] => :validate do |t, args|
+          raise 'development deployment only works with Bundler' unless bundler?
+
+          plugins_dir = prepare_deploy(t, args)
 
-          cp_r @package_dir, plugins_dir, :verbose => @verbose
+          # prepare "temporary" deployment at tmp/deploy:dev
+          package_tmp_dir = Pathname.new(File.join('tmp', 'deploy:dev')).expand_path
+          rm_r package_tmp_dir if File.exist?(package_tmp_dir)
+          mkdir_p package_tmp_dir.to_s, :verbose => @verbose
 
-          Rake::FileList.new("#{@base}/*.yml").each do |config_file|
-            config_file_path = Pathname.new("#{plugin_path}/#{version}/#{File.basename(config_file)}").expand_path
-            @logger.info "Deploying #{config_file} to #{config_file_path}"
-            cp config_file, config_file_path, :verbose => @verbose
+          mkdir target_dir = package_tmp_dir.join(version.to_s)
+
+          # NOTE: although same _boot.rb_ as with regular deploys might not work
+          stage_extra_files target_dir
+          if boot_rb_file.nil?
+            generate_dev_boot_rb target_dir
+          else
+            @logger.info "Make sure the suplied #{boot_rb_file} is removed/adjusted before doing a regular killbill:deploy (same boot.rb won't likely work)"
           end
+
+          # here we assume Gemfile declares gemspec and we link ROOT to base :
+          ln_s @base, target_dir.join(@root_dir_path), :verbose => @verbose
+
+          # ln -s /var/tmp/bundles/plugins/ruby/killbill-xxx -> tmp/deploy:dev
+          ln_s package_tmp_dir, plugins_dir.join(name), :verbose => @verbose
+
+          deploy_config_files target_dir
         end
 
         desc "List all dependencies"
-        task :dependency => :validate do
+        task :dependencies => :validate do
           print_dependencies
         end
+        task :dependency => :dependencies
 
         desc "Delete #{@package_dir}"
-        task :clean => :clobber_package do
-          rm_rf @package_dir
+        task :clean => :clobber do
+          rm_r @package_dir if File.exist?(@package_dir)
         end
       end
     end
 
     private
 
+    def plugin_path(plugins_dir, versioned = true)
+      plugin_path = plugins_dir.join(name)
+      versioned ? plugin_path.join(version.to_s) : plugin_path
+    end
+
+    # (shared) deploy task(s) helper
+    # @return _plugins_ directory
+    def prepare_deploy(t, args)
+      set_verbosity(args)
+
+      plugins_dir = Pathname.new("#{args.plugin_dir || '/var/tmp/bundles/plugins/ruby'}").expand_path
+      mkdir_p plugins_dir, :verbose => @verbose
+
+      plugin_path = plugin_path(plugins_dir, false) # "#{plugins_dir}/#{name}"
+      if plugin_path.exist?
+        if args.force == "true"
+          safe_unlink plugin_path # if link (deploy:dev) just remove the link
+          if plugin_path.exist?
+            @logger.info "Deleting previous plugin deployment #{plugin_path}"
+            rm_rf plugin_path, :verbose => @verbose if plugin_path.exist?
+          else
+            @logger.info "Unlinked previous plugin deployment #{plugin_path}"
+          end
+        else
+          raise "Cowardly not deleting previous plugin deployment #{plugin_path} - override with rake #{t.name}[true]"
+        end
+      end
+      plugins_dir
+    end
+
+    # (shared) deploy task(s) helper
+    def deploy_config_files(path, config_files = Rake::FileList.new("#{@base}/*.yml"))
+      config_files.each do |config_file|
+        config_file_path = File.join(path, File.basename(config_file))
+        @logger.info "Deploying #{config_file} to #{config_file_path}"
+        cp config_file, config_file_path, :verbose => @verbose
+      end
+    end
+
     def set_verbosity(args)
       return unless args.verbose == 'true'
       @verbose = true
@@ -134,106 +297,257 @@ module Killbill
     end
 
     def validate
-      @gemfile_definition = find_gemfile
+      if @gemfile_definition = build_gemfile
+        @gemfile_definition.resolve
+      end
+      true
     end
 
+    def bundler?; !! @gemfile_definition end
+
     def print_dependencies
-      puts "Gems to be staged:"
+      # NOTE: can be improved to include :git info and warn on gem :path
       specs.each { |spec| puts "  #{spec.name} (#{spec.version})" }
     end
 
-    def name
-      @plugin_gemspec.name
-    end
-
-    def version
-      @plugin_gemspec.version
-    end
-
     # Parse the <plugin_name>.gemspec file
-    def find_plugin_gemspec
+    def load_plugin_gemspec
       gemspecs = @plugin_name ? [File.join(@base, "#{@plugin_name}.gemspec")] : Dir[File.join(@base, "{,*}.gemspec")]
-      raise "Unable to find your plugin gemspec in #{@base}" unless gemspecs.size == 1
+      raise "Unable to find your plugin gemspec in #{@base}" if gemspecs.size == 0
+      raise "Found multiple plugin gemspec in #{@base} : #{gemspecs.inspect}" if gemspecs.size > 1
       spec_path = gemspecs.first
-      @logger.debug "Parsing #{spec_path}"
-      Bundler.load_gemspec(spec_path)
+      @logger.debug "Loading #{spec_path}"
+      Gem::Specification.load(spec_path)
     end
 
     def find_plugin_gem(spec)
-      gem_name        = spec.file_name
-      # spec.loaded_from is the path to the gemspec file
-      base            = Pathname.new(File.dirname(spec.loaded_from)).expand_path
+      gem_name = spec.file_name
 
       # Try in the base directory first
       plugin_gem_file = Pathname.new(gem_name).expand_path
-      plugin_gem_file = base.join(gem_name).expand_path unless plugin_gem_file.file?
+      unless plugin_gem_file.file? # `rake build` (./pkg)
+        plugin_gem_file = Pathname.new(File.join('pkg', gem_name))
+      end
 
-      # Try in subdirectories next
       unless plugin_gem_file.file?
-        plugin_gem_files = Dir[File.join(base, "**/#{spec.file_name}")]
-        @logger.debug "Gem candidates found: #{plugin_gem_files}"
-        # Take the first one, assume the other ones are from build directories (e.g. pkg)
-        plugin_gem_file = Pathname.new(plugin_gem_files.first).expand_path unless plugin_gem_files.empty?
+        raise "Unable to find #{gem_name}. Did you build it? (`rake build')"
       end
 
-      raise "Unable to find #{gem_name} in #{base}. Did you build it? (`rake build')" unless plugin_gem_file.file?
-
       @logger.debug "Found #{plugin_gem_file}"
-      Pathname.new(plugin_gem_file).expand_path
+      plugin_gem_file.expand_path
+    end
+
+    def find_missing_gem(spec, silent = nil)
+      base = nil
+      if spec.loaded_from
+        # spec.loaded_from is (usually) the path to the gemspec file
+        base = Pathname.new(File.dirname(spec.loaded_from)).expand_path
+        if ! base.file?
+          base = nil unless base.directory?
+        end
+      end
+      unless base
+        base = spec.gems_dir if spec.respond_to?(:gems_dir)
+        base = spec.base_dir if spec.respond_to?(:base_dir)
+      end
+      # might end-up with a slightly incorrect resolution (due Bundler) :
+      # e.g. .../rvm/gems/jruby-1.7.19@global/gems/bundler-1.7.9/lib/bundler/gems
+      if base
+        parent = base
+        parent = parent.parent while ! parent.join('cache').directory?
+        base = parent if parent && parent.join('gems').directory? # RGs layout
+      end
+
+      gem_file = nil
+      gem_name = spec.file_name
+      gem_paths = Gem.paths.path.dup; gem_paths.unshift(base) if base
+      gem_paths.each do |gem_path| # e.g. /opt/rvm/gems/jruby-1.7.16@global
+        if File.directory? cache_dir = File.join(gem_path, 'cache')
+          if File.file? gem_file = File.join(cache_dir, gem_name)
+            gem_file = Pathname.new(gem_file); break
+          else
+            gem_file = nil
+          end
+        else
+          gem_files = Dir[File.join(gem_path, "**/#{gem_name}")]
+          unless gem_files.empty?
+            @logger.debug "Gem candidates found: #{gem_files.inspect}"
+            gem_file = Pathname.new(gem_files.first); break
+          end
+        end
+      end
+
+      if gem_file.nil? || ! gem_file.file?
+        return nil if silent
+        raise "Unable to find #{gem_name} under #{gem_paths.inspect}"
+      end
+
+      @logger.debug "Found #{gem_file}"
+      gem_file.expand_path
     end
 
     # Parse the existing Gemfile and Gemfile.lock files
-    def find_gemfile
-      gemfile = @base.join(@gemfile_name).expand_path
+    def build_gemfile
+      gemfile = gemfile_path
       # Don't make the Gemfile a requirement, a gemspec should be enough
       return nil unless gemfile.file?
 
       # Make sure the developer ran `bundle install' first. We could probably run
-      #   Bundler::Installer::install(@target_dir, @definition, {})
+      #   Bundler::Installer::install(@plugin_gem_target_dir, @definition, {})
       # but it may be better to make sure all dependencies are resolved first,
       # before attempting to build the plugin
-      gemfile_lock = @base.join(@gemfile_lock_name).expand_path
-      raise "Unable to find the Gemfile.lock at #{gemfile_lock} for your plugin. Please run `bundle install' first" unless gemfile_lock.file?
+      gemfile_lock = gemfile_lock_path
+      raise "Unable to find the bundle .lock at #{gemfile_lock} for your plugin. Please run `bundle install' first" unless gemfile_lock.file?
 
       @logger.debug "Parsing #{gemfile} and #{gemfile_lock}"
       Bundler::Definition.build(gemfile, gemfile_lock, nil)
     end
 
+    def gemfile_path
+      @base.join(@gemfile_name).expand_path
+    end
+
+    def gemfile_lock_path
+      @base.join(@gemfile_lock_name).expand_path
+    end
+
     def stage_dependencies
       # Create the target directory
-      mkdir_p @target_dir.to_s, :verbose => @verbose
+      mkdir_p @plugin_gem_target_dir.to_s, :verbose => @verbose
 
-      @logger.debug "Installing all gem dependencies to #{@target_dir}"
+      @logger.debug "Installing all gem dependencies to #{@plugin_gem_target_dir}"
       # We can't simply use Bundler::Installer unfortunately, because we can't tell it to copy the gems for cached ones
       # (it will default to using Bundler::Source::Path references to the gemspecs on "install").
+
+      generate_boot_rb if boot_rb_file.nil?
+      # else user-suplied boot.rb will be copied into the package
+
+      # part of copying the dependencies is getting Gemfile/Gemfile.lock in
+      # otherwise :git => gem dependencies would need work-arounds to work
+      copy_gemfile if bundler? # plugin gem build might re-copy, that's fine!
+
       specs.each do |spec|
-        plugin_gem_file = Pathname.new(spec.cache_file).expand_path
-        if plugin_gem_file.file?
-          @logger.debug "Staging #{spec.name} (#{spec.version}) from #{plugin_gem_file}"
+        if ! gem_path = valid_gem_path(spec)
+          if gem_path == false # spec.name == name
+            # Gemfile very likely declares gemspec ... so we need to get that in
+            # yet the current way (the plugin gem must be built first) we can
+            # not simply copy spec.loaded_from into the package's root directory
+            # (the actual [PLUGIN_ROOT]/killbill-plugin.gemspec) as that depends
+            # on `git' binary on PATH (to get the actual gem.files)
+            @logger.info "Building #{spec.name} gem from #{spec.loaded_from}"
+            Dir.mktmpdir do |dir|
+              plugin_gem = Gem::Package.new(File.join(dir, spec.file_name))
+              plugin_gem.spec = spec
+              plugin_gem.build(true) # skip_validation
+              gemspec_name = File.basename(spec.loaded_from)
+              puts_to_root plugin_gem.spec.to_ruby, gemspec_name
+              # NOTE: further the unpacked gemspec will be read by Bundler and assumes
+              # the unpacked gem structure to be found on the file-system, extract :
+              plugin_gem.extract_files @plugin_root_target_dir
+            end
+            next
+          end
+          if bundler?
+            # gem not under gem cache_dir (default gem or multiple gem paths)
+            gem_path = find_missing_gem(spec)
+            @logger.debug "Staging #{spec.name} (#{spec.version}) from #{gem_path}"
+            do_install_gem(gem_path, spec)
+          else # mostly Bunder-less backwards-compatibility
+            gem_path = find_missing_gem(spec, :silent) || find_plugin_gem(spec)
+            @logger.info "Staging #{spec.full_name} from #{gem_path}"
+            do_install_gem(gem_path, spec)
+          end
+        elsif gem_path.file?
+          @logger.debug "Staging #{spec.name} (#{spec.version}) from #{gem_path}"
+          do_install_gem(gem_path, spec)
+        elsif gem_path.directory?
+          @logger.debug "Staging #{spec.name} (#{spec.version}) from #{gem_path}"
+          do_install_bundler(gem_path, spec)
         else
-          plugin_gem_file = find_plugin_gem(spec)
-          @logger.info "Staging custom gem #{spec.full_name} from #{plugin_gem_file}"
+          raise "#{spec.name} gem path #{gem_path.inspect} does not exist"
         end
+      end
+    end
 
-        do_install_gem(plugin_gem_file, spec.name, spec.version)
+    def valid_gem_path(spec)
+      cache_file = File.join(spec.cache_dir, "#{spec.full_name}.gem")
+      cache_path = Pathname.new(cache_file).expand_path
+      return cache_path if cache_path.file?
+      return false if spec.name == name # it's the plugin gem itself
+
+      if spec.source && bundler? && spec.source.is_a?(Bundler::Source)
+        # Path < Source and Git < Path :
+        case spec.source
+        when Bundler::Source::Git
+          # NOTE cache_path only works with `bundle cache --all`
+          # when bundle cached install path points to cache
+          #  e.g. ./vendor/cache/killbill-plugin-framework-ruby-ce5e19f45bc9
+          # otherwise it's the path from under RG (as usual for Bundler)
+          #  e.g. [RVM]/gems/jruby-1.7.19@kb/bundler/gems/killbill-plugin-framework-ruby-ce5e19f45bc9
+          return spec.source.install_path
+        when Bundler::Source::Path
+          @logger.warn "gem '#{spec.name}' declares :path => '#{spec.source.path}' packaging will only work locally (while the path exists) !"
+          return spec.source.path
+        end
       end
+      nil
+    end
+
+    def do_install_bundler(path, spec)
+      #full_gem_path = Pathname.new(spec.full_gem_path)
+
+      #gem_relative_path = full_gem_path.relative_path_from(Bundler.install_path)
+      #filenames = []; gem_relative_path.each_filename { |f| filenames << f }
+
+      #exclude_gems = true
+      #unless filenames.empty?
+      #  full_gem_path = Pathname.new(Bundler.install_path) + filenames.first
+      #  exclude_gems = false
+      #end
+
+      FileUtils.mkdir_p target_dir = File.join(@plugin_gem_target_dir, "bundler/gems")
+
+      if spec.groups.include?(:killbill_excluded)
+        Dir.glob("#{path}/**/#{spec.name}.gemspec").each do |file|
+          gem_target_file = File.join(target_dir, File.basename(file))
+          FileUtils.rm(gem_target_file) if File.exist?(gem_target_file)
+          FileUtils.cp(file, target_dir) # gemspec only to avert Bundler error
+        end
+      else
+        gem_target_dir = File.join(target_dir, File.basename(path))
+        FileUtils.rm_r(gem_target_dir) if File.exist?(gem_target_dir)
+        FileUtils.cp_r(path, target_dir)
+        # the copied .git directory is not needed (might be large) :
+        git_target_dir = File.join(gem_target_dir, '.git')
+        FileUtils.rm_r(git_target_dir) if File.exist?(git_target_dir)
+      end
+    rescue => e
+      @logger.warn "Unable to stage #{spec.name} from #{path}: #{e}"
+      raise e
     end
 
-    def do_install_gem(path, name, version)
-      gem_installer                       = Gem::Installer.new(path.to_s,
-                                                               {
-                                                                   :force       => true,
-                                                                   :install_dir => @target_dir,
-                                                                   # Should be redundant with the tweaks below
-                                                                   :development => false,
-                                                                   :wrappers    => true
-                                                               })
+    def do_install_gem(path, spec)
+      name, version = spec.name, spec.version
+      options = {
+          :force       => true,
+          :install_dir => @plugin_gem_target_dir,
+          #:only_install_dir => true,
+          # Should be redundant with the tweaks below
+          :development => false,
+          :wrappers    => true
+      }
+      if Gem::Installer.respond_to?(:at)
+        gem_installer = Gem::Installer.at(path.to_s, options)
+      else # constructing an Installer object with a string is deprecated
+        gem_installer = Gem::Installer.new(path.to_s, options)
+      end
 
       # Tweak the spec file as there are a lot of things we don't care about
       gem_installer.spec.executables      = nil
-      gem_installer.spec.extensions       = nil
       gem_installer.spec.extra_rdoc_files = nil
       gem_installer.spec.test_files       = nil
+      # avoid the annoying post_install_message from money gem (and others)
+      gem_installer.spec.post_install_message = nil
 
       gem_installer.install
     rescue => e
@@ -241,17 +555,143 @@ module Killbill
       raise e
     end
 
-    def stage_extra_files
+    def generate_boot_rb(target_dir = @plugin_target_dir)
+      @logger.debug "Generating boot.rb into #{target_dir}"
+      # NOTE: previously the same WD was used dependent on server startup
+      puts_to target_dir, <<-END, 'boot.rb'
+Dir.chdir File.expand_path('#{@root_dir_path}', File.dirname(__FILE__))
+
+ENV["GEM_HOME"] = File.join(File.dirname(__FILE__), '#{@gems_dir_path}')
+ENV["GEM_PATH"] = ENV["GEM_HOME"]
+# environment is set statically, as soon as Sinatra is loaded
+ENV["RACK_ENV"] = 'production'
+# prepare to boot using Bundler :
+ENV["BUNDLE_WITHOUT"] = "#{ENV["BUNDLE_WITHOUT"] || 'development:test'}"
+ENV["BUNDLE_GEMFILE"] = File.expand_path('Gemfile')
+ENV["JBUNDLE_SKIP"] = 'true' # we only use JBundler for development/testing
+
+require 'rubygems' unless defined? Gem
+if File.exists?(ENV["BUNDLE_GEMFILE"])
+  require 'bundler'; Bundler.setup
+else
+  #{adjust_plugin_load_path}
+end
+
+# try loading killbill (Bunler-less deploys or in case plugin forgot to require)
+begin
+  require 'killbill'
+rescue LoadError => e # not fatal for un-usual cases where plugins vendor the gem
+  warn "WARN: failed to load killbill gem: \#\{e.inspect\}"
+end
+
+#{plugin_require_line}
+
+END
+    end
+
+    def generate_dev_boot_rb(target_dir, env = 'production')
+      @logger.debug "Generating (dev) boot.rb into #{target_dir}"
+      puts_to target_dir, <<-END, 'boot.rb'
+Dir.chdir File.expand_path('#{@root_dir_path}', File.dirname(__FILE__))
+
+ENV["GEM_HOME"] = '#{Gem.paths.home}'
+ENV["GEM_PATH"] = '#{Gem.paths.path.join(':')}'
+# environment is set statically, as soon as Sinatra is loaded
+ENV["RACK_ENV"] = '#{env}'
+# prepare to boot using Bundler :
+ENV["BUNDLE_WITHOUT"] = "#{ENV["BUNDLE_WITHOUT"] || ''}"
+ENV["BUNDLE_GEMFILE"] = File.expand_path('Gemfile')
+
+require 'rubygems' unless defined? Gem
+require 'bundler'; Bundler.setup
+
+# require 'killbill'
+
+#{plugin_require_line}
+
+END
+    end
+
+    def plugin_require_line
+      files = @plugin_gemspec.files; require_path = "#{@plugin_gemspec.require_path}/"
+      files = files.select { |file| file.start_with?(require_path) && file[-3..-1] == '.rb' }
+      # [ "lib/stripe.rb", "lib/stripe/api.rb", "lib/stripe/application.rb", ... ]
+      files.map! { |file| file.sub(require_path, '') }
+      # [ "stripe.rb", "stripe/api.rb", "stripe/application.rb", ... ]
+
+      # 0. if killbill-stripe gem name has a killbill-stripe.rb use it
+      return "require '#{name}'" if files.include?("#{name}.rb")
+
+      # 1. RG convention: killbill-stripe -> require 'killbill/stripe'
+      filename = "#{name.sub('-', '/')}"
+      return "require '#{filename}'" if files.include?("#{filename}.rb")
+
+      # 2. killbill-paypal-express -> require 'paypal-express' (not used)
+      filename = "#{name.sub(/^killbill\-/, '')}"
+      return "require '#{filename}'" if files.include?("#{filename}.rb")
+
+      # 3. killbill-paypal-express -> require 'paypal_express'
+      filename = filename.sub('-', '_')
+      return "require '#{filename}'" if files.include?("#{filename}.rb")
+
+      # not likely to happen - fallback to root file (warn when multiple) :
+      files = files.select { |file| file.index('/').nil? }
+      return "require '#{files[0]}'" if files.size == 1
+
+      raise "could not resolve main require file from gemspec,\n please follow our naming convention for the bootstrap require e.g. \"#{name.sub('-', '/')}.rb\""
+    end
+
+    def adjust_plugin_load_path
+      # NOTE: assuming Dir.chdir [ROOT]
+      @plugin_gemspec.require_paths.map do |path|
+        "$LOAD_PATH << File.expand_path('#{path}')" # $LOAD_PATH << 'lib'
+      end.join('; ')
+    end
+
+    def copy_gemfile(target_dir = @plugin_root_target_dir)
+      copy_to target_dir, gemfile_path, 'Gemfile'
+      copy_to target_dir, gemfile_lock_path, 'Gemfile.lock'
+    end
+
+    def stage_extra_files(target_dir = @plugin_target_dir)
+      unless boot_rb_file.nil?
+        @logger.info "Staging (user-suplied) #{boot_rb_file}"
+        copy_to target_dir, boot_rb_file
+      end
       unless killbill_properties_file.nil?
-        @logger.debug "Staging #{killbill_properties_file} to #{@plugin_root_target_dir}"
-        cp killbill_properties_file, @plugin_root_target_dir, :verbose => @verbose
+        @logger.debug "Staging #{killbill_properties_file}"
+        copy_to target_dir, killbill_properties_file
       end
       unless config_ru_file.nil?
-        @logger.debug "Staging #{config_ru_file} to #{@plugin_root_target_dir}"
-        cp config_ru_file, @plugin_root_target_dir, :verbose => @verbose
+        @logger.debug "Staging #{config_ru_file}"
+        copy_to target_dir, config_ru_file
       end
     end
 
+    def copy_to(target_dir, file_path, base_name = File.basename(file_path))
+      target_file = File.join(target_dir, base_name)
+      cp file_path, target_file, :verbose => @verbose
+    end
+
+    def puts_to(target_dir, content, base_name)
+      target_file = File.join(target_dir, base_name)
+      File.open(target_file, 'w') { |file| file << content }
+    end
+
+    def puts_to_base(content, base_name)
+      target_file = File.join(@plugin_target_dir, base_name)
+      File.open(target_file, 'w') { |file| file << content }
+    end
+
+    def puts_to_root(content, base_name)
+      target_file = File.join(@plugin_root_target_dir, base_name)
+      File.open(target_file, 'w') { |file| file << content }
+    end
+
+    def boot_rb_file
+      path_to_string @base.join("boot.rb").expand_path
+    end
+
     def killbill_properties_file
       path_to_string @base.join("killbill.properties").expand_path
     end