kpm 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af4823a1ad26ca690e372df3596841ae7fa54ee9
-  data.tar.gz: ade7725741e69b929bfa0fd9d47d6fa6326f4695
+  metadata.gz: 14627c006a8ca097ba3574e2a06329ee1c71b3d4
+  data.tar.gz: 790ba80f029ff28d86d0e91088a0327653cf39cc
 SHA512:
-  metadata.gz: 92361d67b9abc0bd2da406fc460481aa8b74176cddf5d4b5b11381428750fe1b417ac0b5bb2796512e52e65963427793cd293dfbf56d53f02672f82b6b0430d2
-  data.tar.gz: b9f1727cdd593dfb48fb4b5c6ef16e2caf272141253100b8566ee7a808b9c74577e652f5742863deb3804bfacb13ff793a37927f151b4bccbbaa895d0ca9f1b1
+  metadata.gz: 45c071a90801caf7a6ec2e8a83d6edd0d1567fc63a2017bf5b7f9be91ec8834ab4cf1b3cc345ddeb8d219281d5697c927367af88367d856b09d14c77aa8e2e1a
+  data.tar.gz: 94dffb5a06040e48f83f70f27cc8d509798848c30b76a5672dbdda12641a4e1fc72ed819b905a8735af44d107da5b72cb85627ddcc70ffea8e1fcba6da08bb9a

data/lib/kpm.rb

@@ -1,6 +1,9 @@
 module KPM
   autoload :Utils, 'kpm/utils'
   autoload :BaseArtifact, 'kpm/base_artifact'
+  autoload :Coordinates, 'kpm/coordinates'
+  autoload :Formatter, 'kpm/formatter'
+  autoload :Inspector, 'kpm/inspector'
   autoload :Sha1Checker, 'kpm/sha1_checker'
   autoload :TomcatManager, 'kpm/tomcat_manager'
   autoload :KillbillServerArtifact, 'kpm/killbill_server_artifact'
@@ -9,9 +12,11 @@ module KPM
   autoload :PluginsManager, 'kpm/plugins_manager'
   autoload :BaseInstaller, 'kpm/base_installer'
   autoload :Installer, 'kpm/installer'
+  autoload :Uninstaller, 'kpm/uninstaller'
   autoload :Tasks, 'kpm/tasks'
   autoload :Cli, 'kpm/cli'
   autoload :PluginsDirectory, 'kpm/plugins_directory'
+  autoload :Migrations, 'kpm/migrations'
 
   class << self
     def root

data/lib/kpm/base_artifact.rb

@@ -65,7 +65,7 @@ module KPM
 
         # Update with resolved version in case 'LATEST' was passed
         coordinate_map[:version] = artifact_info[:version]
-        coordinates = build_coordinates(coordinate_map)
+        coordinates = KPM::Coordinates.build_coordinates(coordinate_map)
 
         # Return early if there's nothing to do
         if !force_download && skip_if_exists(artifact_info, coordinates, sha1_file)
@@ -178,7 +178,7 @@ module KPM
             :skipped => false
         }
 
-        coordinates = build_coordinates(coordinate_map)
+        coordinates = KPM::Coordinates.build_coordinates(coordinate_map)
         begin
           nexus_info = nexus_remote(overrides, ssl_verify).get_artifact_info(coordinates)
         rescue NexusCli::ArtifactMalformedException => e
@@ -256,27 +256,6 @@ module KPM
         res
       end
 
-      def build_coordinates(coordinate_map)
-        group_id = coordinate_map[:group_id]
-        artifact_id = coordinate_map[:artifact_id]
-        packaging = coordinate_map[:packaging]
-        classifier = coordinate_map[:classifier]
-        version = coordinate_map[:version]
-
-        if classifier.nil?
-          if version.nil?
-            "#{group_id}:#{artifact_id}:#{packaging}"
-          else
-            "#{group_id}:#{artifact_id}:#{packaging}:#{version}"
-          end
-        else
-          if version.nil?
-            "#{group_id}:#{artifact_id}:#{packaging}:#{classifier}"
-          else
-            "#{group_id}:#{artifact_id}:#{packaging}:#{classifier}:#{version}"
-          end
-        end
-      end
 
       # Magic methods...
 

data/lib/kpm/coordinates.rb

@@ -0,0 +1,40 @@
+module KPM
+
+  class Coordinates
+
+    class << self
+
+      def build_coordinates(coordinate_map)
+        group_id = coordinate_map[:group_id]
+        artifact_id = coordinate_map[:artifact_id]
+        packaging = coordinate_map[:packaging]
+        classifier = coordinate_map[:classifier]
+        version = coordinate_map[:version]
+
+        if classifier.nil?
+          if version.nil?
+            "#{group_id}:#{artifact_id}:#{packaging}"
+          else
+            "#{group_id}:#{artifact_id}:#{packaging}:#{version}"
+          end
+        else
+          "#{group_id}:#{artifact_id}:#{packaging}:#{classifier}:#{version}"
+        end
+      end
+
+      def get_coordinate_map(entry)
+        parts = entry.split(':')
+        length = parts.size
+        if length == 3
+          {:group_id => parts[0], :artifact_id => parts[1], :packaging => parts[2]}
+        elsif length == 4
+          {:group_id => parts[0], :artifact_id => parts[1], :packaging => parts[2], :version => parts[3]}
+        elsif length == 5
+          {:group_id => parts[0], :artifact_id => parts[1], :packaging => parts[2],  :classifier => parts[3], :version => parts[4]}
+        end
+      end
+
+    end
+
+  end
+end

data/lib/kpm/formatter.rb

@@ -0,0 +1,123 @@
+# Extend String to be able to instantiate a object based on its classname
+class String
+  def to_class
+    self.split('::').inject(Kernel) do |mod, class_name|
+      mod.const_get(class_name)
+    end
+  end
+end
+
+module KPM
+
+  class Formatter
+
+    def initialize
+    end
+
+    # Used for normal types where to_s is enough
+    class DefaultFormatter
+
+      def initialize(label, input)
+        @label = label
+        @input = input
+      end
+
+      def size
+        to_s.size
+      end
+
+      def to_s
+        @input.to_s
+      end
+
+      def label
+        @label.to_s.upcase.gsub(/_/, ' ')
+      end
+    end
+
+    # Used for the version map
+    class VersionFormatter
+
+      def initialize(label, versions)
+        @label = label
+        @versions = versions
+      end
+
+      def size
+        to_s.size
+      end
+
+      def to_s
+        @versions.map { |q| sha1=format_sha(q[:sha1]); disabled=""; disabled="(x)" if q[:is_disabled]; default=""; default="(*)" if q[:is_default]; "#{q[:version]}#{sha1}#{default}#{disabled}" }.join(", ")
+      end
+
+      def label
+        "#{@label.to_s.upcase.gsub(/_/, ' ')} sha1=[], def=(*), del=(x)"
+      end
+
+      def format_sha(sha)
+        return "[???]" if sha.nil?
+        "[#{sha[0..5]}..]"
+      end
+    end
+
+
+    def format(all_plugins)
+      if all_plugins.size == 0
+        return
+      end
+
+      # What we want to output
+      labels = [{:label => :plugin_name},
+                {:label => :plugin_key},
+                {:label => :type},
+                {:label => :group_id},
+                {:label => :artifact_id},
+                {:label => :packaging},
+                {:label => :versions, :formatter => VersionFormatter.name}]
+
+      # Compute label to print along with max size for each label
+      labels_format_argument = []
+      all_plugins.keys.each do |key|
+        v = all_plugins[key]
+        labels.each do |e|
+          # sanitize entry at the same time
+          v[e[:label]] = v[e[:label]] || "???"
+
+          formatter = e[:formatter].nil? ? DefaultFormatter.new(e[:label], v[e[:label]]) : e[:formatter].to_class.new(e[:label], v[e[:label]])
+          prev_size = e.key?(:size) ? e[:size] : formatter.label.size
+          cur_size = formatter.size
+          e[:size] = prev_size < cur_size ? cur_size : prev_size
+          labels_format_argument << formatter.label
+        end
+      end
+
+
+
+      border = "_"
+      border = (0...labels.size).inject(border) { |res, i| res="#{res}_"; res }
+      border = labels.inject(border) { |res, lbl| (0...lbl[:size] + 2).each { |s| res="#{res}_" }; res }
+      format = "|"
+      format = labels.inject(format) { |res, lbl| res="#{res} %#{lbl[:size]}s |"; res }
+
+
+
+      puts "\n#{border}\n"
+      puts "#{format}\n" % labels_format_argument
+      puts "#{border}\n"
+
+      all_plugins.keys.each do |key|
+        v = all_plugins[key]
+
+        arguments = []
+        labels.inject(arguments) do |res, e|
+          formatter = e[:formatter].nil? ? DefaultFormatter.new(e[:label], v[e[:label]]) : e[:formatter].to_class.new(e[:label], v[e[:label]])
+          res << formatter.to_s
+        end
+        puts "#{format}\n" % arguments
+      end
+      puts "#{border}\n\n"
+
+    end
+  end
+end

data/lib/kpm/inspector.rb

@@ -0,0 +1,108 @@
+module KPM
+
+  class Inspector
+
+    def initialize
+    end
+
+    def inspect(bundles_dir)
+      bundles_dir = Pathname.new(bundles_dir || KPM::BaseInstaller::DEFAULT_BUNDLES_DIR).expand_path
+      plugins= bundles_dir.join('plugins')
+      ruby_plugins_path=bundles_dir.join('plugins/ruby')
+      java_plugins_path=bundles_dir.join('plugins/java')
+
+      all_plugins = {}
+      build_plugins_for_type(ruby_plugins_path, 'ruby', all_plugins)
+      build_plugins_for_type(java_plugins_path, 'java', all_plugins)
+
+      add_plugin_identifier_info(plugins, all_plugins)
+
+      add_sha1_info(bundles_dir, all_plugins)
+
+      all_plugins
+    end
+
+    def format(all_plugins)
+      formatter = KPM::Formatter.new
+      formatter.format(all_plugins)
+    end
+
+
+    private
+
+    def add_sha1_info(bundles_dir, all_plugins)
+
+      sha1_filename = KPM::BaseInstaller::SHA1_FILENAME
+      sha1_file = "#{bundles_dir}/#{sha1_filename}"
+      sha1_checker = Sha1Checker.from_file(sha1_file)
+
+      all_plugins.keys.each do |cur_plugin_name|
+        cur = all_plugins[cur_plugin_name]
+
+        sha1_checker.all_sha1.each do |e|
+          coord, sha1 = e
+          coordinate_map = KPM::Coordinates.get_coordinate_map(coord)
+
+          if coordinate_map[:group_id] == cur[:group_id] &&
+              coordinate_map[:artifact_id] == cur[:artifact_id] &&
+              coordinate_map[:packaging] == cur[:packaging]
+
+            found_version = cur[:versions].select { |v| v[:version] == coordinate_map[:version] }[0]
+            found_version[:sha1] = sha1 if found_version
+          end
+
+        end
+      end
+    end
+
+    def add_plugin_identifier_info(plugins, all_plugins)
+      plugins_manager = PluginsManager.new(plugins, @logger)
+      all_plugins.keys.each do |cur|
+        plugin_key, entry = plugins_manager.get_identifier_key_and_entry(cur)
+        all_plugins[cur][:plugin_key] = plugin_key
+        all_plugins[cur][:group_id] = entry ? entry['group_id'] : nil
+        all_plugins[cur][:artifact_id] = entry ? entry['artifact_id'] : nil
+        all_plugins[cur][:packaging] = entry ? entry['packaging'] : nil
+        all_plugins[cur][:classifier] = entry ? entry['classifier'] : nil
+      end
+    end
+
+
+    def build_plugins_for_type(plugins_path, type, res)
+      if !File.exists?(plugins_path)
+        return []
+      end
+      get_entries(plugins_path).inject(res) do |out, e|
+        plugin_map = build_plugin_map(e, plugins_path.join(e), type)
+        out[e] = plugin_map
+        out
+      end
+    end
+
+    def build_plugin_map(plugin_name, plugin_path, type)
+
+      plugin_map = {:plugin_name => plugin_name, :plugin_path => plugin_path.to_s, :type => type}
+      entries = get_entries(plugin_path)
+      set_default = entries.select { |e| e == "SET_DEFAULT" }[0]
+      default_version = File.basename(File.readlink(plugin_path.join(set_default))) if set_default
+
+      versions = entries.select do |e|
+        e != "SET_DEFAULT"
+      end.inject([]) do |out, e|
+        is_disabled = File.exists?(plugin_path.join(e).join('tmp').join('disabled.txt'))
+        out << {:version => e, :is_default => default_version == e, :is_disabled => is_disabled, :sha1 => nil};
+        out
+      end
+
+      versions.sort! { |a, b| a[:version] <=> b[:version] }
+      plugin_map[:versions] = versions || []
+
+      plugin_map
+    end
+
+    def get_entries(path)
+      Dir.entries(path).select { |entry| entry != '.' && entry != '..' && File.directory?(File.join(path, entry)) }
+    end
+
+  end
+end

data/lib/kpm/installer.rb

@@ -39,6 +39,7 @@ module KPM
         unless @config['default_bundles'] == false
           install_default_bundles(@config['plugins_dir'], @config['default_bundles_version'], @config['version'], force_download, verify_sha1)
         end
+        clean_up_descriptors
       end
 
       unless @kaui_config.nil?
@@ -99,5 +100,43 @@ module KPM
 
       infos
     end
+
+    def clean_up_descriptors
+      removed_plugins = clean_up_plugin_identifiers
+      clean_up_sha1s(removed_plugins)
+    end
+
+    def clean_up_plugin_identifiers
+      inspector = KPM::Inspector.new
+      installed_plugins = inspector.inspect(@config['plugins_dir'])
+
+      plugins_installation_path = File.join(@config['plugins_dir'], 'plugins')
+      plugins_manager = KPM::PluginsManager.new(plugins_installation_path, @logger)
+
+      plugin_identifiers = plugins_manager.read_plugin_identifiers
+      removed_identifiers = []
+      plugin_identifiers.each do |plugin_key, plugin|
+        if !installed_plugins.has_key?(plugin['plugin_name'])
+          _, plugin_entry = plugins_manager.get_identifier_key_and_entry(plugin_key)
+          plugins_manager.remove_plugin_identifier_key(plugin_key)
+          removed_identifiers << plugin_entry
+        end
+      end
+
+      removed_identifiers
+    end
+
+    def clean_up_sha1s(removed_plugins)
+      sha1checker = KPM::Sha1Checker.from_file(File.join(@config['plugins_dir'], KPM::BaseInstaller::SHA1_FILENAME))
+      removed_plugins.each do |removed|
+        coordinates = KPM::Coordinates.build_coordinates(group_id: removed['group_id'],
+                                                         artifact_id: removed['artifact_id'],
+                                                         packaging: removed['packaging'],
+                                                         classifier: removed['classifier'],
+                                                         version: removed['version'])
+        sha1checker.remove_entry!(coordinates)
+      end
+    end
+
   end
 end

data/lib/kpm/kaui_artifact.rb

@@ -8,7 +8,7 @@ module KPM
 
         coordinate_map = {:group_id => KPM::BaseArtifact::KAUI_GROUP_ID, :artifact_id => KPM::BaseArtifact::KAUI_ARTIFACT_ID, :packaging => KPM::BaseArtifact::KAUI_PACKAGING, :classifier => KPM::BaseArtifact::KAUI_CLASSIFIER}
 
-        coordinates = build_coordinates(coordinate_map)
+        coordinates = KPM::Coordinates.build_coordinates(coordinate_map)
         response    = REXML::Document.new nexus_remote(overrides, ssl_verify).search_for_artifacts(coordinates)
         versions    = SortedSet.new
         response.elements.each('search-results/data/artifact/version') { |element| versions << element.text }

data/lib/kpm/killbill_server_artifact.rb

@@ -6,7 +6,7 @@ module KPM
     class << self
       def versions(artifact_id, packaging=KPM::BaseArtifact::KILLBILL_PACKAGING, classifier=KPM::BaseArtifact::KILLBILL_CLASSIFIER, overrides={}, ssl_verify=true)
         coordinate_map = {:group_id => KPM::BaseArtifact::KILLBILL_GROUP_ID, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier}
-        coordinates = build_coordinates(coordinate_map)
+        coordinates = KPM::Coordinates.build_coordinates(coordinate_map)
         response    = REXML::Document.new nexus_remote(overrides, ssl_verify).search_for_artifacts(coordinates)
         versions    = SortedSet.new
         response.elements.each('search-results/data/artifact/version') { |element| versions << element.text }

data/lib/kpm/migrations.rb

@@ -0,0 +1,94 @@
+require 'base64'
+require 'json'
+require 'logger'
+require 'open-uri'
+require 'pathname'
+
+module KPM
+  class Migrations
+
+    KILLBILL_MIGRATION_PATH = /src\/main\/resources\/org\/killbill\/billing\/[a-z]+\/migration\/(V[0-9a-zA-Z_]+.sql)/
+    JAVA_PLUGIN_MIGRATION_PATH = /src\/main\/resources\/migration\/(V[0-9a-zA-Z_]+.sql)/
+    RUBY_PLUGIN_MIGRATION_PATH = /db\/migrate\/([0-9a-zA-Z_]+.rb)/
+
+    # Go to https://github.com/settings/tokens to generate a token
+    def initialize(from_version, to_version = nil, repository = 'killbill/killbill', oauth_token = nil, logger = Logger.new(STDOUT))
+      @from_version = from_version
+      @to_version = to_version
+      @repository = repository
+      @oauth_token = oauth_token
+      @logger = logger
+    end
+
+    def migrations
+      @migrations ||= begin
+        if @to_version.nil?
+          for_version(@from_version)
+        else
+          migrations_to_skip = Set.new
+          for_version(@from_version, true).each { |migration| migrations_to_skip << migration[:name] }
+
+          for_version(@to_version, false, migrations_to_skip)
+        end
+      end
+    end
+
+    def save(dir = nil)
+      return nil if migrations.size == 0
+
+      dir ||= Dir.mktmpdir
+      @logger.debug("Storing migrations to #{dir}")
+      migrations.each do |migration|
+        migration_path = Pathname.new(dir).join(migration[:name])
+        File.open(migration_path, 'w') do |file|
+          @logger.debug("Storing migration #{migration_path}")
+          file.write(migration[:sql])
+        end
+      end
+      dir
+    end
+
+    private
+
+    def for_version(version = @from_version, name_only = false, migrations_to_skip = Set.new)
+      @logger.info("Looking for migrations repository=#{@repository}, version=#{version}")
+      metadata = get_as_json("https://api.github.com/repos/#{@repository}/git/trees/#{version}?recursive=1&access_token=#{@oauth_token}")
+
+      migrations = []
+      metadata['tree'].each do |entry|
+        match_data = KILLBILL_MIGRATION_PATH.match(entry['path']) || JAVA_PLUGIN_MIGRATION_PATH.match(entry['path']) || RUBY_PLUGIN_MIGRATION_PATH.match(entry['path'])
+        next unless match_data
+
+        migration_name = match_data[1]
+        @logger.info("Found migration #{migration_name}")
+        next if migrations_to_skip.include?(migration_name)
+
+        sql = nil
+        unless name_only
+          blob_metadata = get_as_json("#{entry['url']}?access_token=#{@oauth_token}")
+          sql = decode(blob_metadata['content'], blob_metadata['encoding'])
+        end
+
+        migrations << {
+            :name => migration_name,
+            :sql => sql
+        }
+      end
+
+      migrations
+    end
+
+    def get_as_json(url)
+      raw = URI.parse(url).read
+      JSON.parse(raw)
+    end
+
+    def decode(content, encoding)
+      if encoding == 'base64'
+        Base64.decode64(content)
+      else
+        content
+      end
+    end
+  end
+end

data/lib/kpm/plugins_directory.yml

@@ -119,7 +119,7 @@
   :versions:
     :0.14: 2.0.0
     :0.15: 3.0.0
-    :0.16: 4.1.0
+    :0.16: 4.1.1
   :stable_version: 2.0.0
   :require:
   - :signature

data/lib/kpm/plugins_manager.rb

@@ -111,6 +111,14 @@ module KPM
       end
     end
 
+    def get_identifier_key_and_entry(plugin_name_or_key)
+      identifiers = read_plugin_identifiers
+      identifiers.each_pair do |key, value|
+        return [key, value] if key == plugin_name_or_key || value['plugin_name'] == plugin_name_or_key
+      end
+      nil
+    end
+
     def guess_plugin_name(artifact_id)
       return nil if artifact_id.nil?
       captures = artifact_id.scan(/(.*)-plugin/)
@@ -132,6 +140,18 @@ module KPM
       nil
     end
 
+    def read_plugin_identifiers
+      path = Pathname.new(@plugins_dir).join('plugin_identifiers.json')
+      identifiers = {}
+      begin
+        identifiers = File.open(path, 'r') do |f|
+          JSON.parse(f.read)
+        end
+      rescue Errno::ENOENT
+      end
+      identifiers
+    end
+
     private
 
     def validate_plugin_identifier_key_value(plugin_key, value_type, entry_value, coordinate_value)
@@ -145,18 +165,6 @@ module KPM
       true
     end
 
-    def read_plugin_identifiers
-      path = Pathname.new(@plugins_dir).join('plugin_identifiers.json')
-      identifiers = {}
-      begin
-        identifiers = File.open(path, 'r') do |f|
-          JSON.parse(f.read)
-        end
-      rescue Errno::ENOENT
-      end
-      identifiers
-    end
-
     def write_plugin_identifiers(identifiers)
 
       path = Pathname.new(@plugins_dir).join('plugin_identifiers.json')

data/lib/kpm/sha1_checker.rb

@@ -33,6 +33,11 @@ module KPM
       save!
     end
 
+    def remove_entry!(coordinates)
+      @sha1_config['sha1'].delete(coordinates)
+      save!
+    end
+
     private
 
     def save!
@@ -62,4 +67,4 @@ module KPM
     end
 
   end
-end
+end

data/lib/kpm/tasks.rb

@@ -1,6 +1,7 @@
 require 'highline'
 require 'logger'
 require 'thor'
+require 'pathname'
 
 module KPM
   module Tasks
@@ -32,6 +33,19 @@ module KPM
           say help, :green unless help.nil?
         end
 
+        method_option :destination,
+                      :type    => :string,
+                      :default => nil,
+                      :desc    => 'A different folder other than the default bundles directory.'
+        method_option :force,
+                      :type    => :boolean,
+                      :default => nil,
+                      :desc    => 'Don\'t ask for confirmation while deleting multiple versions of a plugin.'
+        desc 'uninstall plugin', 'Uninstall the specified plugin, identified by its name or key, from current deployment'
+        def uninstall(plugin)
+          say 'Done!' if Uninstaller.new(options[:destination]).uninstall_plugin(plugin, options[:force])
+        end
+
         method_option :destination,
                       :type    => :string,
                       :default => nil,
@@ -324,6 +338,33 @@ module KPM
           say "Known plugin for KB version #{options[:version]}\n  " + (plugins_info.map {|k,v| "#{k} #{v}"}).join("\n  "), :green
         end
 
+        method_option :destination,
+                      :type    => :string,
+                      :default => nil,
+                      :desc    => 'Folder where to download migration files.'
+        method_option :token,
+                      :type => :string,
+                      :default => nil,
+                      :desc => 'GitHub OAuth token.'
+        desc 'migrations repository from to', 'Download migration files for Kill Bill or a plugin'
+        def migrations(repository, from, to = nil)
+          full_repo = repository.include?('/') ? repository : "killbill/#{repository}"
+          dir = KPM::Migrations.new(from, to, full_repo, options[:token], logger).save(options[:destination])
+          say (dir.nil? ? 'No migration required' : "Migrations can be found at #{dir}"), :green
+        end
+
+        method_option :destination,
+                      :type    => :string,
+                      :default => nil,
+                      :desc    => 'A different folder other than the default bundles directory.'
+        desc 'inspect', 'Inspect current deployment'
+        def inspect
+          inspector = KPM::Inspector.new
+          all_plugins = inspector.inspect(options[:destination])
+          #puts all_plugins.to_json
+          inspector.format(all_plugins)
+        end
+
         private
 
         def logger

data/lib/kpm/uninstaller.rb

@@ -0,0 +1,69 @@
+module KPM
+  class Uninstaller
+    def initialize(destination, logger = nil)
+      @logger = logger
+      if @logger.nil?
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::INFO
+      end
+
+      destination ||= KPM::BaseInstaller::DEFAULT_BUNDLES_DIR
+      @installed_plugins = Inspector.new.inspect(destination)
+
+      plugins_installation_path = File.join(destination, 'plugins')
+      @plugins_manager = PluginsManager.new(plugins_installation_path, @logger)
+
+      sha1_file_path = File.join(destination, KPM::BaseInstaller::SHA1_FILENAME)
+      @sha1checker = KPM::Sha1Checker.from_file(sha1_file_path, @logger)
+    end
+
+    def uninstall_plugin(plugin, force = false)
+      plugin_info = find_plugin(plugin)
+      raise "No plugin with key/name '#{plugin}' found installed. Try running 'kpm inspect' for more info" unless plugin_info
+
+      remove_all_plugin_versions(plugin_info, force)
+    end
+
+    private
+
+    def find_plugin(plugin)
+      plugin_info = @installed_plugins[plugin]
+      if plugin_info.nil?
+        @installed_plugins.each do |_, info|
+          if info[:plugin_key] == plugin
+            plugin_info = info
+            break
+          end
+        end
+      end
+
+      plugin_info
+    end
+
+    def remove_all_plugin_versions(plugin_info, force = false)
+      versions = plugin_info[:versions].map { |artifact| artifact[:version] }
+      KPM.ui.say "Removing the following versions of the #{plugin_info[:plugin_name]} plugin: #{versions.join(', ')}"
+      if !force && versions.length > 1
+        return false unless 'y' == KPM.ui.ask('Are you sure you want to continue?', limited_to: %w(y n))
+      end
+
+      FileUtils.rmtree(plugin_info[:plugin_path])
+
+      @plugins_manager.remove_plugin_identifier_key(plugin_info[:plugin_key])
+      versions.each do |version|
+        remove_sha1_entry(plugin_info, version)
+      end
+
+      true
+    end
+
+    def remove_sha1_entry(plugin_info, version)
+      coordinates = KPM::Coordinates.build_coordinates(group_id: plugin_info[:group_id],
+                                                       artifact_id: plugin_info[:artifact_id],
+                                                       packaging: plugin_info[:packaging],
+                                                       classifier: plugin_info[:classifier],
+                                                       version: version)
+      @sha1checker.remove_entry!(coordinates)
+    end
+  end
+end

data/lib/kpm/version.rb

@@ -1,3 +1,3 @@
 module KPM
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/spec/kpm/remote/migrations_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe KPM::Migrations do
+
+  context 'plugins' do
+    it 'should be able to find migrations for a java plugin' do
+      migrations = KPM::Migrations.new('master', nil, 'killbill/killbill-analytics-plugin', ENV['TOKEN']).migrations
+      # No migration yet
+      migrations.size.should == 0
+    end
+
+    it 'should be able to find migrations for a ruby plugin' do
+      migrations = KPM::Migrations.new('master', nil, 'killbill/killbill-cybersource-plugin', ENV['TOKEN']).migrations
+      # No migration yet
+      migrations.size.should == 0
+    end
+  end
+
+  context 'killbill' do
+    it 'should be able to find migrations between two versions' do
+      migrations = KPM::Migrations.new('master', 'work-for-release-0.16.4', 'killbill/killbill', ENV['TOKEN']).migrations
+
+      migrations.size.should == 1
+      migrations.first[:name].should == 'V20160324060345__revisit_payment_methods_indexes_509.sql'
+      migrations.first[:sql].should == "drop index payment_methods_active_accnt on payment_methods;\n"
+
+      KPM::Migrations.new('master', 'master', 'killbill/killbill', ENV['TOKEN']).migrations.size.should == 0
+    end
+
+    it 'should be able to find migrations for a given version' do
+      migrations = KPM::Migrations.new('work-for-release-0.16.4', nil, 'killbill/killbill', ENV['TOKEN']).migrations
+
+      migrations.size.should == 1
+      migrations.first[:name].should == 'V20160324060345__revisit_payment_methods_indexes_509.sql'
+      migrations.first[:sql].should == "drop index payment_methods_active_accnt on payment_methods;\n"
+    end
+  end
+end

data/spec/kpm/unit/inspector_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe KPM::Inspector do
+
+  before(:each) do
+    @logger = Logger.new(STDOUT)
+    @logger.level = Logger::INFO
+
+    tmp_bundles_dir = Dir.mktmpdir
+    @bundles_dir = Pathname.new(tmp_bundles_dir).expand_path
+    @plugins_dir = @bundles_dir.join('plugins')
+
+    FileUtils.mkdir_p(@plugins_dir)
+
+    @ruby_plugins_dir = @plugins_dir.join('ruby')
+    FileUtils.mkdir_p(@ruby_plugins_dir)
+
+    @java_plugins_dir = @plugins_dir.join('java')
+    FileUtils.mkdir_p(@java_plugins_dir)
+
+    @manager = KPM::PluginsManager.new(@plugins_dir, @logger)
+
+    @sha1_file = @bundles_dir.join("sha1.yml")
+    @sha1_checker = KPM::Sha1Checker.from_file(@sha1_file)
+
+  end
+
+
+  it 'should parse a correctly setup env' do
+
+    add_plugin('foo', 'plugin_foo', ['1.2.3', '2.0.0', '2.0.1'], 'ruby', 'com.foo', 'foo', 'tar.gz', nil, ['12345', '23456', '34567'], '2.0.1', ['1.2.3'])
+    add_plugin('bar', 'plugin_bar', ['1.0.0'], 'java', 'com.bar', 'bar', 'jar', nil, ['98765'], nil, [])
+
+    inspector = KPM::Inspector.new
+    all_plugins = inspector.inspect(@bundles_dir)
+    all_plugins.size == 2
+
+    all_plugins['plugin_bar']['plugin_key'] == 'bar'
+    all_plugins['plugin_bar']['plugin_path'] == @java_plugins_dir.join('plugin_bar').to_s
+    all_plugins['plugin_bar'][:versions].size == 1
+    all_plugins['plugin_bar'][:versions][0][:version] == '1.0.0'
+    all_plugins['plugin_bar'][:versions][0][:is_default] == true
+    all_plugins['plugin_bar'][:versions][0][:is_disabled] == false
+    all_plugins['plugin_bar'][:versions][0][:sha1] == '98765'
+
+    all_plugins['plugin_foo']['plugin_key'] == 'foo'
+    all_plugins['plugin_foo']['plugin_path'] == @ruby_plugins_dir.join('plugin_foo').to_s
+    all_plugins['plugin_foo'][:versions].size == 3
+
+    all_plugins['plugin_foo'][:versions][0][:version] == '1.2.3'
+    all_plugins['plugin_foo'][:versions][0][:is_default] == false
+    all_plugins['plugin_foo'][:versions][0][:is_disabled] == true
+    all_plugins['plugin_foo'][:versions][0][:sha1] == '12345'
+
+    all_plugins['plugin_foo'][:versions][1][:version] == '2.0.0'
+    all_plugins['plugin_foo'][:versions][1][:is_default] == false
+    all_plugins['plugin_foo'][:versions][1][:is_disabled] == false
+    all_plugins['plugin_foo'][:versions][1][:sha1] == '23456'
+
+    all_plugins['plugin_foo'][:versions][2][:version] == '2.0.1'
+    all_plugins['plugin_foo'][:versions][2][:is_default] == true
+    all_plugins['plugin_foo'][:versions][2][:is_disabled] == false
+    all_plugins['plugin_foo'][:versions][2][:sha1] == '34567'
+
+  end
+
+
+  private
+
+  def add_plugin(plugin_key, plugin_name, versions, language, group_id, artifact_id, packaging, classifier, sha1, active_version, disabled_versions)
+
+    plugin_dir = language == 'ruby' ? @ruby_plugins_dir.join(plugin_name) : @java_plugins_dir.join(plugin_name)
+
+    versions.each_with_index do |v, idx|
+
+      coordinate_map = {:group_id => group_id, :artifact_id => artifact_id, :version => v, :packaging => packaging, :classifier => classifier}
+      coordinates = KPM::Coordinates.build_coordinates(coordinate_map)
+
+      @manager.add_plugin_identifier_key(plugin_key, plugin_name, language, coordinate_map)
+      @sha1_checker.add_or_modify_entry!(coordinates, sha1[idx])
+
+
+      plugin_dir_version = plugin_dir.join(v)
+
+      FileUtils.mkdir_p(plugin_dir_version)
+
+      # Create some entry to look real
+      some_file = 'ruby' ? 'ROOT' : '#{plugin_name}.jar'
+      FileUtils.touch(plugin_dir_version.join(some_file))
+    end
+
+    @manager.set_active(plugin_dir, active_version) if active_version
+
+    disabled_versions.each do |v|
+      @manager.uninstall(plugin_dir, v)
+    end
+  end
+
+end

data/spec/kpm/unit/sha1_checker_spec.rb

@@ -65,6 +65,22 @@ describe KPM::Sha1Checker do
     existing.should == 'bbb068c3fd5f95646ce0d09852f43ff67f06fccc'
   end
 
+  context 'when removing an entry' do
+    let(:identifier) { 'killbill-plugin-match-1.0.0.tar.gz' }
+    before do
+      @sha1_checker.remove_entry!(identifier)
+    end
+
+    it 'does not find the entry' do
+      @sha1_checker.sha1(identifier).should be_nil
+    end
+
+    let(:reloaded_checker) { KPM::Sha1Checker.from_file(@tmp_config) }
+    it 'does not find entry in file system' do
+      reloaded_checker.sha1(identifier).should be_nil
+    end
+  end
+
   it 'should work with empty config' do
 
     tmp_destination_dir = Dir.tmpdir()

data/spec/kpm/unit/uninstaller_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe KPM::Uninstaller do
+
+  let(:uninstaller) { KPM::Uninstaller.new(destination) }
+  let(:destination) { 'somedir' }
+
+  let(:plugins_manager_mock) { double(KPM::PluginsManager) }
+  let(:sha1_checker_mock) { double(KPM::Sha1Checker) }
+  before do
+    KPM::Inspector.stub_chain(:new, :inspect).and_return(installed_plugins)
+    KPM::PluginsManager.stub(:new).and_return(plugins_manager_mock)
+    KPM::Sha1Checker.stub(:from_file).and_return(sha1_checker_mock)
+  end
+
+  context 'when plugin is not installed' do
+    let(:installed_plugins) { {} }
+
+    it 'raises a plugin not found error' do
+      expect {
+        uninstaller.uninstall_plugin('adyen')
+      }.to raise_error(StandardError, "No plugin with key/name 'adyen' found installed. Try running 'kpm inspect' for more info")
+    end
+  end
+
+  context 'when plugin is installed' do
+    let(:installed_plugins) do
+      {
+          plugin_name => {
+              plugin_key: plugin_key,
+              plugin_path: plugin_path,
+              versions: [{version: version}],
+              group_id: 'group',
+              artifact_id: 'artifact',
+              packaging: 'jar'
+          }
+      }
+    end
+
+    let(:plugin_name) { 'plugin-name' }
+    let(:plugin_key) { 'plugin-key' }
+    let(:plugin_path) { 'plugin-path' }
+    let(:version) { '1.0' }
+
+    it 'uninstalls a plugin by name' do
+      FileUtils.should_receive(:rmtree).with(plugin_path)
+      plugins_manager_mock.should_receive(:remove_plugin_identifier_key).with(plugin_key)
+      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version}")
+
+      uninstaller.uninstall_plugin(plugin_name).should be_true
+    end
+
+    it 'uninstalls a plugin by key' do
+      FileUtils.should_receive(:rmtree).with(plugin_path)
+      plugins_manager_mock.should_receive(:remove_plugin_identifier_key).with(plugin_key)
+      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version}")
+
+      uninstaller.uninstall_plugin(plugin_key).should be_true
+    end
+  end
+
+  context 'when plugin is installed' do
+    let(:installed_plugins) do
+      {
+          plugin_name => {
+              plugin_key: plugin_key,
+              plugin_path: plugin_path,
+              versions: [{version: version1},{version: version2}],
+              group_id: 'group',
+              artifact_id: 'artifact',
+              packaging: 'jar'
+          }
+      }
+    end
+
+    let(:plugin_name) { 'plugin-name' }
+    let(:plugin_key) { 'plugin-key' }
+    let(:plugin_path) { 'plugin-path' }
+    let(:version1) { '1.0' }
+    let(:version2) { '2.0' }
+
+    it 'uninstalls if user confirms action' do
+      KPM.ui.should_receive(:ask).and_return('y')
+
+      FileUtils.should_receive(:rmtree).with(plugin_path)
+      plugins_manager_mock.should_receive(:remove_plugin_identifier_key).with(plugin_key)
+      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version1}")
+      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version2}")
+
+      uninstaller.uninstall_plugin(plugin_name).should be_true
+    end
+
+    it 'does nothing if user cancels' do
+      KPM.ui.should_receive(:ask).and_return('n')
+
+      uninstaller.uninstall_plugin(plugin_name).should be_false
+    end
+
+    it 'uninstalls without confirmation if the force option is given' do
+      FileUtils.should_receive(:rmtree).with(plugin_path)
+      plugins_manager_mock.should_receive(:remove_plugin_identifier_key).with(plugin_key)
+      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version1}")
+      sha1_checker_mock.should_receive(:remove_entry!).with("group:artifact:jar:#{version2}")
+
+      uninstaller.uninstall_plugin(plugin_name, true).should be_true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require 'tmpdir'
+require 'thor'
 require 'kpm'
 require 'logger'
 require 'rspec'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kpm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Kill Bill core team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-26 00:00:00.000000000 Z
+date: 2016-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -119,16 +119,21 @@ files:
 - lib/kpm/base_artifact.rb
 - lib/kpm/base_installer.rb
 - lib/kpm/cli.rb
+- lib/kpm/coordinates.rb
+- lib/kpm/formatter.rb
+- lib/kpm/inspector.rb
 - lib/kpm/installer.rb
 - lib/kpm/kaui_artifact.rb
 - lib/kpm/killbill_plugin_artifact.rb
 - lib/kpm/killbill_server_artifact.rb
+- lib/kpm/migrations.rb
 - lib/kpm/plugins_directory.rb
 - lib/kpm/plugins_directory.yml
 - lib/kpm/plugins_manager.rb
 - lib/kpm/sha1_checker.rb
 - lib/kpm/tasks.rb
 - lib/kpm/tomcat_manager.rb
+- lib/kpm/uninstaller.rb
 - lib/kpm/utils.rb
 - lib/kpm/version.rb
 - spec/kpm/remote/base_artifact_spec.rb
@@ -137,12 +142,15 @@ files:
 - spec/kpm/remote/kaui_artifact_spec.rb
 - spec/kpm/remote/killbill_plugin_artifact_spec.rb
 - spec/kpm/remote/killbill_server_artifact_spec.rb
+- spec/kpm/remote/migrations_spec.rb
 - spec/kpm/remote/tomcat_manager_spec.rb
 - spec/kpm/unit/base_artifact_spec.rb
+- spec/kpm/unit/inspector_spec.rb
 - spec/kpm/unit/plugins_directory_spec.rb
 - spec/kpm/unit/plugins_manager_spec.rb
 - spec/kpm/unit/sha1_checker_spec.rb
 - spec/kpm/unit/sha1_test.yml
+- spec/kpm/unit/uninstaller_spec.rb
 - spec/spec_helper.rb
 homepage: http://kill-bill.org
 licenses:
@@ -177,10 +185,13 @@ test_files:
 - spec/kpm/remote/kaui_artifact_spec.rb
 - spec/kpm/remote/killbill_plugin_artifact_spec.rb
 - spec/kpm/remote/killbill_server_artifact_spec.rb
+- spec/kpm/remote/migrations_spec.rb
 - spec/kpm/remote/tomcat_manager_spec.rb
 - spec/kpm/unit/base_artifact_spec.rb
+- spec/kpm/unit/inspector_spec.rb
 - spec/kpm/unit/plugins_directory_spec.rb
 - spec/kpm/unit/plugins_manager_spec.rb
 - spec/kpm/unit/sha1_checker_spec.rb
 - spec/kpm/unit/sha1_test.yml
+- spec/kpm/unit/uninstaller_spec.rb
 - spec/spec_helper.rb