killbill-kpm 0.3.0 → 1.0.0

data/README.md

@@ -1,31 +1,74 @@
-Overview
-========
+# killbill-kpm-plugin
 
-Rails mountable engine to manage the KPM plugin.
+Plugin to enable plugin management at runtime.
 
-See [killbill-admin-ui-standalone](https://github.com/killbill/killbill-admin-ui-standalone) to get started with the Kill Bill Admin UI.
+Release builds are available on [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.kill-bill.billing.plugin.ruby%22%20AND%20a%3A%22kpm-plugin%22) with coordinates `org.kill-bill.billing.plugin.ruby:kpm-plugin`.
 
 Kill Bill compatibility
 -----------------------
 
-| KPM UI version | Kill Bill version |
-| -------------: | ----------------: |
-| 0.1.y          | 0.16.z            |
-| 0.2.y          | 0.18.z (Rails 4)  |
-| 0.3.y          | 0.18.z (Rails 5)  |
+| Plugin version | Kill Bill version  |
+| -------------: | -----------------: |
+| 0.0.y          | 0.16.z             |
+| -------------: | -----------------: |
+| 1.x.y          | 0.18.x (and 0.17.x)|
 
-Testing
--------
+Usage
+-----
 
-To run the dummy app:
+* The plugin is indirectly integrated with [Kill Bill APIs](https://github.com/killbill/killbill-docs/blob/v3/userguide/tutorials/plugin_management.adoc)
+* [killbill-kpm-ui](https://github.com/killbill/killbill-kpm-ui) offers a front-end for Kaui
+
+The plugin also offers private APIs:
+
+### Lookup plugins
+
+All plugins:
 
 ```
-rails s
+curl -v \
+     -u admin:password \
+     http://127.0.0.1:8080/plugins/killbill-kpm/plugins
 ```
 
+Specific plugin:
+
+```
+curl -v \
+     -u admin:password \
+     http://127.0.0.1:8080/plugins/killbill-kpm/plugins?name=stripe
+```
+
+### Plugin Management
+
+Note that in a multi-nodes deployment, these commands would have to be run on each node. We also provide [Kill Bill apis to manage plugins](http://docs.killbill.io/0.16/plugin_management.html) that work across multi-nodes installation, but they do not allow uploading a plugin binary (e.g: jarfile), so those commands are still very useful in the context of doing plugin development.
+
+
+Upload a plugin:
+
+```
+curl -v \
+     -X POST \
+     -u admin:password \
+     -H 'Content-Type: application/json' \
+     -d @/path/to/myplugin.jar \
+     'http://127.0.0.1:8080/plugins/killbill-kpm/plugins?filename=myplugin.jar&key=myplugin&version=0.2.5'
+```
+
+### Uninstall a plugin
+
+```
+curl -v \
+     -X DELETE \
+     -u admin:password \
+     'http://127.0.0.1:8080/plugins/killbill-kpm/plugins?key=myplugin&version=0.2.5'
+```
 
-To run tests:
+### Restart a plugin
 
 ```
-rails t
+curl -v \
+     -X PUT \
+     -u admin:password \
+     'http://127.0.0.1:8080/plugins/killbill-kpm/plugins?key=myplugin&version=0.2.5'
 ```

data/Rakefile

@@ -1,37 +1,22 @@
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+#!/usr/bin/env rake
+
+# Install tasks to build and release the plugin
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+# Install test tasks
+require 'rspec/core/rake_task'
+namespace :test do
+  desc 'Run RSpec tests'
+  RSpec::Core::RakeTask.new do |task|
+    task.name = 'spec'
+    task.pattern = './spec/*/*_spec.rb'
+  end
 end
 
-require 'rdoc/task'
+# Install tasks to package the plugin for Killbill
+require 'killbill/rake_task'
+Killbill::PluginHelper.install_tasks
 
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'KPM'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
-load 'rails/tasks/engine.rake'
-
-
-load 'rails/tasks/statistics.rake'
-
-
-
-require 'bundler/gem_tasks'
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
-
-
-task default: :test
+# Run tests by default
+task :default => 'test:spec'

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/config.ru

@@ -0,0 +1,4 @@
+require 'kpm_plugin'
+require 'kpm/application'
+
+run Sinatra::Application

data/killbill-kpm.gemspec

@@ -0,0 +1,31 @@
+version = File.read(File.expand_path('../VERSION', __FILE__)).strip
+
+Gem::Specification.new do |s|
+  s.name        = 'killbill-kpm'
+  s.version     = version
+  s.summary     = 'Kill Bill KPM plugin'
+  s.description = 'Plugin to manage installed plugins'
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.license = 'Apache License (2.0)'
+
+  s.author   = 'Killbill core team'
+  s.email    = 'killbilling-users@googlegroups.com'
+  s.homepage = 'http://killbill.io'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.bindir        = 'bin'
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.rdoc_options << '--exclude' << '.'
+
+  s.add_dependency 'killbill', '~> 8.0.1'
+  s.add_dependency 'kpm', '~> 0.1.4'
+
+  s.add_development_dependency 'jbundler', '~> 0.9.2'
+  s.add_development_dependency 'rake', '>= 10.0.0'
+  s.add_development_dependency 'rspec', '~> 2.12.0'
+end

data/killbill.properties

@@ -0,0 +1,3 @@
+mainClass=KPM::Listener
+require=kpm_plugin
+pluginType=NOTIFICATION

data/lib/kpm/application.rb

@@ -0,0 +1,92 @@
+configure do
+  # Usage: bundle exec rackup -Ilib -E test
+  if development? or test?
+    require 'logger'
+    ::KPM::PluginsInstaller.instance.initialize!('/var/tmp/bundles/plugins/ruby/kpm/0.0.1',
+                                                 File.expand_path(File.dirname(__FILE__) + '../../../'),
+                                                 nil,
+                                                 Logger.new(STDOUT))
+  end
+end
+
+# Lookup plugins
+get '/plugins/killbill-kpm/plugins', :provides => 'json' do
+  artifact_id = params[:artifact_id] || params[:name]
+  latest = params[:latest] == 'false' ? false : true
+
+  if artifact_id.nil?
+    ::KPM::PluginsInstaller.instance.all(latest).to_json
+  else
+    group_id, artifact_id, packaging, classifier, version, type = ::KPM::PluginsInstaller.instance.lookup artifact_id, latest
+
+    if artifact_id.nil?
+      status 404
+    else
+      {
+          :group_id => group_id,
+          :artifact_id => artifact_id,
+          :packaging => packaging,
+          :classifier => classifier,
+          :version => version,
+          :type => type
+      }.to_json
+    end
+  end
+end
+
+# Install a plugin
+post '/plugins/killbill-kpm/plugins', :provides => 'json' do
+  if !request.body.nil?
+    type = (params[:type] || 'java').downcase
+
+    info = Dir.mktmpdir do |dir|
+      plugin_path = File.join(dir, params[:filename] || "#{params[:name]}.#{type == 'java' ? 'jar' : 'tar.gz'}")
+      File.open(plugin_path, 'w') do |file|
+        file.write(request.body.read)
+      end
+      ::KPM::PluginsInstaller.instance.install_from_fs params[:key],
+                                                       plugin_path,
+                                                       params[:version],
+                                                       type
+    end
+  else
+    info = ::KPM::PluginsInstaller.instance.install params[:key],
+                                                    params[:artifact_id],
+                                                    params[:version],
+                                                    params[:group_id],
+                                                    params[:packaging],
+                                                    params[:classifier],
+                                                    params[:type],
+                                                    params[:force_download]
+  end
+
+  if info.nil?
+    status 400
+  else
+    info.to_json
+  end
+end
+
+# Uninstall a plugin
+delete '/plugins/killbill-kpm/plugins', :provides => 'json' do
+  modified = ::KPM::PluginsInstaller.instance.uninstall params[:key],
+                                                        params[:version]
+
+  if modified.empty?
+    status 404
+  else
+    modified.to_json
+  end
+end
+
+# Restart a plugin
+put '/plugins/killbill-kpm/plugins', :provides => 'json' do
+  modified = ::KPM::PluginsInstaller.instance.restart params[:key],
+                                                      params[:version]
+
+  if modified.empty?
+    status 404
+  else
+    modified.to_json
+  end
+end

data/lib/kpm/listener.rb

@@ -0,0 +1,95 @@
+require 'nexus_cli'
+
+module KPM
+  class Listener < Killbill::Plugin::Notification
+
+
+    def start_plugin
+      super
+      ::KPM::PluginsInstaller.instance.initialize!(@root, @conf_dir, @kb_apis, @logger)
+      # We don't know yet
+      @kb_version = nil
+    end
+
+    def on_event(event)
+
+      return unless [:BROADCAST_SERVICE].include?(event.event_type)
+
+      unless ::KPM::PluginsInstaller.instance.initialized?
+        @logger.warn "KPM plugin wasn't started properly - check logs"
+        return
+      end
+
+      broadcast_metadata = event.meta_data.nil? ? {} : JSON.parse(event.meta_data)
+      command = broadcast_metadata['commandType']
+      return if command != 'INSTALL_PLUGIN' && command != 'UNINSTALL_PLUGIN'
+
+      service = broadcast_metadata['service']
+      event_json = broadcast_metadata['eventJson'].nil? ? {} : JSON.parse(broadcast_metadata['eventJson'])
+
+      properties = properties_to_hash(event_json['properties'])
+
+      @logger.info "Received #{event.event_type} event: service=#{service} command=#{command} event=#{event_json}"
+
+      # pluginKey is the only mandatory property
+      if event_json['pluginKey'].nil?
+        @logger.info("Cannot run #{command}: missing pluginKey property")
+        return false
+      end
+
+      handle_event(command,
+                   event_json['pluginKey'],
+                   properties['pluginArtifactId'],
+                   event_json['pluginVersion'],
+                   properties['pluginGroupId'],
+                   properties['pluginPackaging'],
+                   properties['pluginClassifier'],
+                   properties['pluginType'],
+                   properties['forceDownload'] == 'true')
+    end
+
+    private
+
+    def get_kb_version
+      return @kb_version if @kb_version
+
+      nodes_info = @kb_apis.killbill_nodes_api.get_nodes_info
+      if nodes_info.nil? || nodes_info.empty?
+        @logger.warn("Unable to retrieve node info")
+        return nil
+      end
+
+      # This is incorrect, we need to find the entry for our node, but we don't seem to know who we are -:(
+      # (The will break in rolling upgrade scenario)
+      @kb_version = nodes_info[0].killbill_version
+
+      @logger.info("KPM plugin extracted killbill version #{@kb_version}")
+
+      @kb_version
+    end
+
+    def handle_event(command, plugin_key, artifact_id, version=nil, group_id=nil, packaging=nil, classifier=nil, type=nil, force_download=false)
+      @logger.info "handle_event command=#{command}, plugin_key=#{plugin_key}, artifact_id=#{artifact_id}, version=#{version}, group_id=#{group_id}, packaging=#{packaging}, classifier=#{classifier}, type=#{type}, force_download=#{force_download}"
+
+      if command == 'INSTALL_PLUGIN'
+        ::KPM::PluginsInstaller.instance.install(plugin_key, get_kb_version, artifact_id, version, group_id, packaging, classifier, type, force_download)
+      elsif command == 'UNINSTALL_PLUGIN'
+        ::KPM::PluginsInstaller.instance.uninstall(plugin_key, version)
+      else
+        @logger.warn("Ignoring unsupported command #{command}")
+      end
+    rescue NexusCli::ArtifactNotFoundException
+      @logger.warn("Unable to #{command} for plugin_key=#{plugin_key}: artifact was not found in Nexus")
+    end
+
+    def properties_to_hash(properties)
+      return {} if properties.nil?
+
+      h = {}
+      properties.each do |prop|
+        h[prop['key']] = prop['value']
+      end
+      h
+    end
+  end
+end

data/lib/kpm/plugins_installer.rb

@@ -0,0 +1,112 @@
+module KPM
+  class PluginsInstaller
+    include Singleton
+
+    attr_reader :initialized
+    alias_method :initialized?, :initialized
+
+    def initialize!(root_dir, conf_dir, kb_apis, logger)
+      @kb_apis = kb_apis
+      @logger = logger
+
+      configure!(Pathname.new(conf_dir).expand_path.join('kpm.yml'))
+
+      @bundles_dir = Pathname.new(root_dir).join('..').join('..').join('..').join('..').expand_path
+      plugins_dir = @bundles_dir.join('plugins')
+
+      @installer = ::KPM::BaseInstaller.new(@logger, @glob_config[:kpm][:nexus], @glob_config[:kpm][:ssl_verify])
+      @manager = ::KPM::PluginsManager.new(plugins_dir, @logger)
+
+      @initialized = true
+    end
+
+    # If an earlier version of the plugin is installed, Kill Bill will only start the latest one (see org.killbill.billing.osgi.FileInstall)
+    def install(plugin_key, kb_version, specified_artifact_id, specified_version=nil, specified_group_id=nil, specified_packaging=nil, specified_classifier=nil, specified_type=nil, force_download=false)
+      @logger.info("Instructed to install plugin_key=#{plugin_key} artifact_id=#{specified_artifact_id} version=#{specified_version} group_id=#{specified_group_id} packaging=#{specified_packaging} classifier=#{specified_classifier} type=#{specified_type} force_download=#{force_download}")
+      info = @installer.install_plugin(plugin_key, kb_version, specified_group_id, specified_artifact_id, specified_packaging, specified_classifier, specified_version, @bundles_dir, specified_type, force_download, @glob_config[:kpm][:verify_sha1])
+      if info.nil?
+        @logger.warn("Error during installation of plugin #{specified_artifact_id}")
+      else
+        path = info[:bundle_dir]
+        notify_fs_change(plugin_key, path, :NEW_VERSION)
+      end
+      info
+    end
+
+    def install_from_fs(plugin_key, file_path, version, type)
+      @logger.info("Instructed to install file_path=#{file_path} plugin_key=#{plugin_key} version=#{version} type=#{type}")
+      info = @installer.install_plugin_from_fs(plugin_key, file_path, plugin_key, version, @bundles_dir, type)
+      if info.nil?
+        @logger.warn("Error during installation of plugin #{plugin_key}")
+      else
+        path = info[:bundle_dir] || info[:dir_name]
+        notify_fs_change(plugin_key, path, :NEW_VERSION)
+      end
+      info
+    end
+
+    def uninstall(plugin_key, version=nil)
+      modified = @installer.uninstall_plugin(plugin_key, version || :all, @bundles_dir)
+      modified.each do |path|
+        notify_fs_change(plugin_key, path, :DISABLED)
+      end
+    end
+
+    def restart(plugin_name, version=nil)
+      @manager.restart(plugin_name, version || :all)
+    end
+
+    def lookup(artifact_id, latest=true)
+      KPM::PluginsDirectory.lookup(artifact_id, latest)
+    end
+
+    def all(latest=true)
+      KPM::PluginsDirectory.all(latest)
+    end
+
+    private
+
+    def notify_fs_change(plugin_key, path, state)
+      return if path.nil?
+
+      @logger.info("notify_fs_change: plugin_key = #{plugin_key}, path=#{path}, state=#{state}")
+
+      # Plugin name should be the directory name (path is something like /var/tmp/bundles/plugins/ruby/killbill-stripe/2.0.0 or /var/tmp/bundles/plugins/ruby)
+      fs_info = path.to_s.split('/')
+      plugin_type = fs_info[-3].upcase
+      plugin_name = fs_info[-2]
+      plugin_version = fs_info[-1]
+
+
+      if @kb_apis.nil?
+        @logger.warn("APIs not configured: Kill Bill won't be notified of new state #{state}")
+        return
+      end
+
+      @logger.info("Notifying Kill Bill: state=#{state} plugin_key=#{plugin_key} plugin_name=#{plugin_name} plugin_version=#{plugin_version} plugin_type=#{plugin_type}")
+      @kb_apis.plugins_info_api.notify_of_state_changed(state, plugin_key, plugin_name, plugin_version, plugin_type)
+    end
+
+    def configure!(config_file)
+      @glob_config = {}
+
+      # Look for global config
+      if !config_file.blank? && Pathname.new(config_file).file?
+        @glob_config = ::Killbill::Plugin::ActiveMerchant::Properties.new(config_file)
+        @glob_config.parse!
+        @glob_config = @glob_config.to_hash
+      end
+
+      @glob_config[:kpm] ||= {}
+
+      @glob_config[:kpm][:nexus] ||= {}
+      @glob_config[:kpm][:nexus][:url] ||= 'https://oss.sonatype.org'
+      @glob_config[:kpm][:nexus][:repository] ||= 'releases'
+
+      @glob_config[:kpm][:ssl_verify] = true if @glob_config[:kpm][:ssl_verify].nil?
+      @glob_config[:kpm][:verify_sha1] = true if @glob_config[:kpm][:verify_sha1].nil?
+
+      @logger.level = Logger::DEBUG if (@glob_config[:logger] || {})[:debug]
+    end
+  end
+end