logstash-core 1.5.0.rc3.snapshot1-java → 1.5.0.rc3.snapshot2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ccb8f6feb74845cf8d8edc1560b620889bc64e32
-  data.tar.gz: 7a9557a4e3ce4d677d76b0a000712a535284ce00
+  metadata.gz: 9ec518211d023c5f4499757aed7d6e3cfdf7c2fa
+  data.tar.gz: 8434ea102ecd49a99ddbf66f9c1730028087f661
 SHA512:
-  metadata.gz: 3abbaebd57fc5378d3c4a94e24cbea76c16f5618d219e8048d5c14b900cb3613cf2f96aa6987d5d758094296257f96578aea7064b3ba7b44992a77a6a01d36d5
-  data.tar.gz: a64b9710d36d5614a9cf5279f02bdee89f799aca9d7bdf6710cd8d19f1959321a1053ec07116400cb5bfabdc462075e91735bd61b2fbc83c785d301ab03843c8
+  metadata.gz: a2312511be9d28f1a5d0b07fc66bfba8a50dcdb3299c15b6ee9bc803356f2fc4ee668b9c38047b64cfc4532117f4c43e9fa6fd20236cb20abd391001c75177ba
+  data.tar.gz: 44784d222a78ba4cfe8ee0a9b84b342d780280fcc62fbb3b0823bb1c0f110b08ca941e3e2c204e8f31bcd3c245b390170e012e35b030d41fd6e9ae9603a8a8ee

data/lib/logstash/agent.rb

@@ -172,7 +172,6 @@ class LogStash::Agent < Clamp::Command
 
       if RUBY_PLATFORM == "java"
         show_version_java
-        show_version_elasticsearch
       end
 
       if [:debug].include?(verbosity?) || debug?
@@ -190,13 +189,6 @@ class LogStash::Agent < Clamp::Command
     puts RUBY_DESCRIPTION
   end # def show_version_ruby
 
-  def show_version_elasticsearch
-    LogStash::Environment.load_elasticsearch_jars!
-
-    $stdout.write("Elasticsearch: ");
-    org.elasticsearch.Version::main([])
-  end # def show_version_elasticsearch
-
   def show_version_java
     properties = java.lang.System.getProperties
     puts "java #{properties["java.version"]} (#{properties["java.vendor"]})"

data/lib/logstash/bundler.rb

@@ -23,6 +23,28 @@ end
 
 module LogStash
   module Bundler
+    # Take a gem package and extract it to a specific target
+    # @param [String] Gem file, this must be a path
+    # @param [String, String] Return a Gem::Package and the installed path
+    def self.unpack(file, path)
+      require "rubygems/package"
+      require "securerandom"
+
+      # We are creating a random directory per extract,
+      # if we dont do this bundler will not trigger download of the dependencies.
+      # Use case is:
+      # - User build his own gem with a fix
+      # - User doesnt increment the version
+      # - User install the same version but different code or dependencies multiple times..
+      basename  = ::File.basename(file, '.gem') 
+      unique = SecureRandom.hex(4)
+      target_path = ::File.expand_path(::File.join(path, unique, basename))
+      
+      package = ::Gem::Package.new(file)
+      package.extract_files(target_path)
+
+      return [package, target_path]
+    end
 
     # capture any $stdout from the passed block. also trap any exception in that block, in which case the trapped exception will be returned
     # @param [Proc] the code block to execute
@@ -53,6 +75,9 @@ module LogStash
 
       ENV["GEM_PATH"] = LogStash::Environment.logstash_gem_home
 
+      # force Rubygems sources to our Gemfile sources
+      ::Gem.sources = options[:rubygems_source] if options[:rubygems_source]
+
       ::Bundler.settings[:path] = LogStash::Environment::BUNDLE_DIR
       ::Bundler.settings[:gemfile] = LogStash::Environment::GEMFILE_PATH
       ::Bundler.settings[:without] = options[:without].join(":")
@@ -60,7 +85,7 @@ module LogStash
       try = 0
 
       # capture_stdout also traps any raised exception and pass them back as the function return [output, exception]
-      capture_stdout do
+      output, exception = capture_stdout do
         loop do
           begin
             ::Bundler.reset!
@@ -81,11 +106,15 @@ module LogStash
 
             try += 1
             $stderr.puts("Error #{e.class}, retrying #{try}/#{options[:max_tries]}")
-            $stderr.puts(e.message) if ENV["DEBUG"]
+            $stderr.puts(e.message)
             sleep(0.5)
           end
         end
       end
+
+      raise exception if exception
+
+      return output
     end
 
     # build Bundler::CLI.start arguments array from the given options hash
@@ -107,4 +136,4 @@ module LogStash
       arguments.flatten
     end
   end
-end
+end

data/lib/logstash/environment.rb

@@ -1,5 +1,5 @@
 require "logstash/errors"
-require 'logstash/version'
+require "logstash/version"
 
 # monkey patch RubyGems to silence ffi warnings:
 #
@@ -44,32 +44,14 @@ module LogStash
     extend self
 
     LOGSTASH_HOME = ::File.expand_path(::File.join(::File.dirname(__FILE__), "..", ".."))
-    JAR_DIR = ::File.join(LOGSTASH_HOME, "vendor", "jar")
-    ELASTICSEARCH_DIR = ::File.join(LOGSTASH_HOME, "vendor", "elasticsearch")
     BUNDLE_DIR = ::File.join(LOGSTASH_HOME, "vendor", "bundle")
     GEMFILE_PATH = ::File.join(LOGSTASH_HOME, "Gemfile")
     BUNDLE_CONFIG_PATH = ::File.join(LOGSTASH_HOME, ".bundle", "config")
     BOOTSTRAP_GEM_PATH = ::File.join(LOGSTASH_HOME, 'build', 'bootstrap')
+    LOCAL_GEM_PATH = ::File.join(LOGSTASH_HOME, 'vendor', 'local_gems')
 
     LOGSTASH_ENV = (ENV["LS_ENV"] || 'production').to_s.freeze
 
-    # loads currently embedded elasticsearch jars
-    # @raise LogStash::EnvironmentError if not running under JRuby or if no jar files are found
-    def load_elasticsearch_jars!
-      raise(LogStash::EnvironmentError, "JRuby is required") unless jruby?
-
-      require "java"
-      jars_path = ::File.join(ELASTICSEARCH_DIR, "**", "*.jar")
-      jar_files = Dir.glob(jars_path)
-
-      raise(LogStash::EnvironmentError, "Could not find Elasticsearch jar files under #{ELASTICSEARCH_DIR}") if jar_files.empty?
-
-      jar_files.each do |jar|
-        loaded = require jar
-        puts("Loaded #{jar}") if $DEBUG && loaded
-      end
-    end
-
     def logstash_gem_home
       ::File.join(BUNDLE_DIR, ruby_engine, gem_ruby_version)
     end
@@ -113,6 +95,43 @@ module LogStash
       ::Bundler.setup
     end
 
+    def runtime_jars_root(dir_name, package)
+      ::File.join(dir_name, package, "runtime-jars")
+    end
+
+    def test_jars_root(dir_name, package)
+      ::File.join(dir_name, package, "test-jars")
+    end
+
+    def load_runtime_jars!(dir_name="vendor", package="jar-dependencies")
+      load_jars!(::File.join(runtime_jars_root(dir_name, package), "*.jar"))
+    end
+
+    def load_test_jars!(dir_name="vendor", package="jar-dependencies")
+      load_jars!(::File.join(test_jars_root(dir_name, package), "*.jar"))
+    end
+
+    def load_jars!(pattern)
+      raise(LogStash::EnvironmentError, I18n.t("logstash.environment.jruby-required")) unless LogStash::Environment.jruby?
+
+      jar_files = find_jars(pattern)
+      require_jars! jar_files
+    end
+
+    def find_jars(pattern)
+      require 'java'
+      jar_files = Dir.glob(pattern)
+      raise(LogStash::EnvironmentError, I18n.t("logstash.environment.missing-jars", :pattern => pattern)) if jar_files.empty?
+      jar_files
+    end
+
+    def require_jars!(files)
+      files.each do |jar_file|
+        loaded = require jar_file
+        puts("Loaded #{jar_file}") if $DEBUG && loaded
+      end
+    end
+
     def ruby_bin
       ENV["USE_RUBY"] == "1" ? "ruby" : File.join("vendor", "jruby", "bin", "jruby")
     end

data/lib/logstash/event.rb

@@ -176,8 +176,14 @@ class LogStash::Event
   end
 
   public
-  def include?(key)
-    return !self[key].nil?
+  def include?(fieldref)
+    if fieldref.start_with?(METADATA_BRACKETS)
+      @metadata_accessors.include?(fieldref[METADATA_BRACKETS.length .. -1])
+    elsif fieldref == METADATA
+      true
+    else
+      @accessors.include?(fieldref)
+    end
   end # def include?
 
   # Append an event to this one.

data/lib/logstash/gemfile.rb

@@ -1,3 +1,4 @@
+require "logstash/util"
 module LogStash
 
   class GemfileError < StandardError; end
@@ -17,6 +18,7 @@ module LogStash
 
     def load
       @gemset ||= DSL.parse(@io.read)
+      backup
       self
     end
 
@@ -51,6 +53,23 @@ module LogStash
     def remove(name)
       @gemset.remove_gem(name)
     end
+
+    def backup
+      @original_backup = @gemset.copy
+    end
+
+    def restore
+      @gemset = @original_backup
+    end
+
+    def restore!
+      restore
+      save
+    end
+
+    def locally_installed_gems
+      @gemset.gems.select { |gem| gem.options.include?(:path) }
+    end
   end
 
   class Gemset
@@ -101,7 +120,6 @@ module LogStash
     def copy
       Marshal.load(Marshal.dump(self))
     end
-
     private
 
     def sources_to_s

data/lib/logstash/pluginmanager/command.rb

@@ -0,0 +1,37 @@
+class LogStash::PluginManager::Command < Clamp::Command
+  def gemfile
+    @gemfile ||= LogStash::Gemfile.new(File.new(LogStash::Environment::GEMFILE_PATH, 'r+')).load
+  end
+
+  # If set in debug mode we will raise an exception and display the stacktrace
+  def report_exception(readable_message, exception)
+    if ENV["DEBUG"]
+      raise exception
+    else
+      signal_error("#{readable_message}, message: #{exception.message}")
+    end
+  end
+
+  def display_bundler_output(output)
+    if ENV['DEBUG'] && output
+      # Display what bundler did in the last run
+      $stderr.puts("Bundler output")
+      $stderr.puts(output)
+    end
+  end
+
+
+  # Each plugin install for a gemfile create a path with a unique id.
+  # we must clear what is not currently used in the 
+  def remove_unused_locally_installed_gems!
+    used_path = gemfile.locally_installed_gems.collect { |gem| gem.options[:path] }
+
+    Dir.glob(File.join(LogStash::Environment::LOCAL_GEM_PATH, '*')) do |path|
+      FileUtils.rm_rf(relative_path(path)) if used_path.none? { |p| p.start_with?(relative_path(path)) }
+    end
+  end
+
+  def relative_path(path)
+    Pathname.new(path).relative_path_from(Pathname.new(LogStash::Environment::LOGSTASH_HOME)).to_s
+  end
+end

data/lib/logstash/pluginmanager/install.rb

@@ -1,16 +1,17 @@
-require 'clamp'
-require 'logstash/namespace'
-require 'logstash/environment'
-require 'logstash/pluginmanager/util'
-require 'jar-dependencies'
-require 'jar_install_post_install_hook'
-require 'file-dependencies/gem'
-
+require "clamp"
+require "logstash/namespace"
+require "logstash/environment"
+require "logstash/pluginmanager/util"
+require "logstash/pluginmanager/command"
+require "jar-dependencies"
+require "jar_install_post_install_hook"
+require "file-dependencies/gem"
 require "logstash/gemfile"
 require "logstash/bundler"
+require "fileutils"
 
-class LogStash::PluginManager::Install < Clamp::Command
-  parameter "[PLUGIN] ...", "plugin name(s) or file"
+class LogStash::PluginManager::Install < LogStash::PluginManager::Command
+  parameter "[PLUGIN] ...", "plugin name(s) or file", :attribute_name => :plugins_arg
   option "--version", "VERSION", "version of the plugin to install"
   option "--[no-]verify", :flag, "verify plugin validity before installation", :default => true
   option "--development", :flag, "install all development dependencies of currently installed plugins", :default => false
@@ -18,95 +19,123 @@ class LogStash::PluginManager::Install < Clamp::Command
   # the install logic below support installing multiple plugins with each a version specification
   # but the argument parsing does not support it for now so currently if specifying --version only
   # one plugin name can be also specified.
-  #
-  # TODO: find right syntax to allow specifying list of plugins with optional version specification for each
-
   def execute
-    if development?
-      raise(LogStash::PluginManager::Error, "Cannot specify plugin(s) with --development, it will add the development dependencies of the currently installed plugins") unless plugin_list.empty?
+    validate_cli_options!
+    
+    if local_gems?
+      gems = extract_local_gems_plugins
+    elsif development?
+      gems = plugins_development_gems
     else
-      raise(LogStash::PluginManager::Error, "No plugin specified") if plugin_list.empty? && verify?
-
-      # temporary until we fullfil TODO ^^
-      raise(LogStash::PluginManager::Error, "Only 1 plugin name can be specified with --version") if version && plugin_list.size > 1
+      gems = plugins_gems
+      verify_remote!(gems) if verify?
     end
-    raise(LogStash::PluginManager::Error, "File #{LogStash::Environment::GEMFILE_PATH} does not exist or is not writable, aborting") unless File.writable?(LogStash::Environment::GEMFILE_PATH)
-
-    gemfile = LogStash::Gemfile.new(File.new(LogStash::Environment::GEMFILE_PATH, "r+")).load
-    # keep a copy of the gemset to revert on error
-    original_gemset = gemfile.gemset.copy
 
-    # force Rubygems sources to our Gemfile sources
-    Gem.sources = gemfile.gemset.sources
-
-    # install_list will be an array of [plugin name, version] tuples, version can be nil
-    install_list = []
+    install_gems_list!(gems)
+    remove_unused_locally_installed_gems! 
+  end
 
+  private
+  def validate_cli_options!
     if development?
-      specs = LogStash::PluginManager.all_installed_plugins_gem_specs(gemfile)
-      install_list = specs.inject([]) do |result, spec|
-        result = result + spec.dependencies.select{|dep| dep.type == :development}.map{|dep| [dep.name] + dep.requirement.as_list + [{:group => :development}]}
-      end
+      signal_usage_error("Cannot specify plugin(s) with --development, it will add the development dependencies of the currently installed plugins") unless plugins_arg.empty?
     else
-      # at this point we know that plugin_list is not empty and if the --version is specified there is only one plugin in plugin_list
+      signal_usage_error("No plugin specified") if plugins_arg.empty? && verify?
+      # TODO: find right syntax to allow specifying list of plugins with optional version specification for each
+      signal_usage_error("Only 1 plugin name can be specified with --version") if version && plugins_arg.size > 1
+    end
+    signal_error("File #{LogStash::Environment::GEMFILE_PATH} does not exist or is not writable, aborting") unless ::File.writable?(LogStash::Environment::GEMFILE_PATH)
+  end
 
-      install_list = version ? [plugin_list << version] : plugin_list.map{|plugin| [plugin, nil]}
+  # Check if the specified gems contains
+  # the logstash `metadata`
+  def verify_remote!(gems)
+    gems.each do |plugin, version|
+      puts("Validating #{[plugin, version].compact.join("-")}")
+      signal_error("Installation aborted, verification failed for #{plugin} #{version}") unless LogStash::PluginManager.logstash_plugin?(plugin, version)
+    end 
+  end
 
-      install_list.each do |plugin, version|
-        puts("Validating #{[plugin, version].compact.join("-")}")
-        raise(LogStash::PluginManager::Error, "Installation aborted") unless LogStash::PluginManager.logstash_plugin?(plugin, version)
-      end if verify?
+  def plugins_development_gems
+    # Get currently defined gems and their dev dependencies
+    specs = []
 
-      # at this point we know that we either have a valid gem name & version or a valid .gem file path
+    specs = LogStash::PluginManager.all_installed_plugins_gem_specs(gemfile)
 
-      # if LogStash::PluginManager.plugin_file?(plugin)
-      #   raise(LogStash::PluginManager::Error) unless cache_gem_file(plugin)
-      #   spec = LogStash::PluginManager.plugin_file_spec(plugin)
-      #   gemfile.update(spec.name, spec.version.to_s)
-      # else
-      #   plugins.each{|tuple| gemfile.update(*tuple)}
-      # end
+    # Construct the list of dependencies to add to the current gemfile
+    specs.each_with_object([]) do |spec, install_list|
+      dependencies = spec.dependencies 
+        .select { |dep| dep.type == :development }
+        .map { |dep| [dep.name] + dep.requirement.as_list }
+
+      install_list.concat(dependencies)
     end
+  end
 
+  def plugins_gems
+    version ? [plugins_arg << version] : plugins_arg.map { |plugin| [plugin, nil] }
+  end
 
+  # install_list will be an array of [plugin name, version, options] tuples, version it
+  # can be nil at this point we know that plugins_arg is not empty and if the
+  # --version is specified there is only one plugin in plugins_arg
+  #
+  def install_gems_list!(install_list)
+    # If something goes wrong during the installation `LogStash::Gemfile` will restore a backup version.
     install_list = LogStash::PluginManager.merge_duplicates(install_list)
-    install_list.each{|plugin, version| gemfile.update(plugin, version)}
-    gemfile.save
 
-    puts("Installing" + (install_list.empty? ? "..." : " " + install_list.map{|plugin, version| plugin}.join(", ")))
+    # Add plugins/gems to the current gemfile
+    puts("Installing" + (install_list.empty? ? "..." : " " + install_list.collect(&:first).join(", ")))
+    install_list.each { |plugin, version, options| gemfile.update(plugin, version, options) }
+
+    # Sync gemfiles changes to disk to make them available to the `bundler install`'s API
+    gemfile.save
 
     bundler_options = {:install => true}
     bundler_options[:without] = [] if development?
+    bundler_options[:rubygems_source] = gemfile.gemset.sources
 
-    # any errors will be logged to $stderr by invoke_bundler!
-    output, exception = LogStash::Bundler.invoke_bundler!(bundler_options)
+    output = LogStash::Bundler.invoke_bundler!(bundler_options)
 
-    if ENV["DEBUG"]
-      $stderr.puts(output)
-      $stderr.puts("Error: #{exception.class}, #{exception.message}") if exception
-    end
+    puts("Installation successful")
+  rescue => exception
+    gemfile.restore!
+    report_exception("Installation Aborted", exception)
+  ensure
+    display_bundler_output(output)
+  end
 
-    if exception
-      # revert to original Gemfile content
-      gemfile.gemset = original_gemset
-      gemfile.save
-      raise(LogStash::PluginManager::Error, "Installation aborted")
-    end
+  # Extract the specified local gems in a predefined local path 
+  # Update the gemfile to use a relative path to this plugin and run
+  # Bundler, this will mark the gem not updatable by `bin/plugin update`
+  # This is the most reliable way to make it work in bundler without 
+  # hacking with `how bundler works`
+  #
+  # Bundler 2.0, will have support for plugins source we could create a .gem source
+  # to support it.
+  def extract_local_gems_plugins
+    plugins_arg.collect do |plugin| 
+      # We do the verify before extracting the gem so we dont have to deal with unused path
+      if verify?
+        puts("Validating #{plugin}")
+        signal_error("Installation aborted, verification failed for #{plugin}") unless LogStash::PluginManager.logstash_plugin?(plugin, version)
+      end
 
-    puts("Installation successful")
+      package, path = LogStash::Bundler.unpack(plugin, LogStash::Environment::LOCAL_GEM_PATH)
+      [package.spec.name, package.spec.version, { :path => relative_path(path) }]
+    end
   end
 
-  # copy .gem file into bundler cache directory, log any error to $stderr
-  # @param path [String] the source .gem file to copy
-  # @return [Boolean] true if successful
-  def cache_gem_file(path)
-    dest = ::File.join(LogStash::Environment.logstash_gem_home, "cache")
-    begin
-      FileUtils.cp(path, dest)
-    rescue => e
-      $stderr.puts("Error copying #{plugin} to #{dest}, caused by #{e.class}")
-      return false
+  # We cannot install both .gem and normal plugin in one call of `plugin install`
+  def local_gems?
+    return false if plugins_arg.empty?
+
+    local_gem = plugins_arg.collect { |plugin| ::File.extname(plugin) == ".gem" }.uniq
+
+    if local_gem.size == 1
+      return local_gem.first
+    else
+      signal_usage_error("Mixed source of plugins, you can't mix local `.gem` and remote gems")
     end
-    true
   end
 end # class Logstash::PluginManager

data/lib/logstash/pluginmanager/list.rb

@@ -1,9 +1,10 @@
 require 'clamp'
 require 'logstash/namespace'
 require 'logstash/pluginmanager/util'
+require 'logstash/pluginmanager/command'
 require 'rubygems/spec_fetcher'
 
-class LogStash::PluginManager::List < Clamp::Command
+class LogStash::PluginManager::List < LogStash::PluginManager::Command
 
   parameter "[PLUGIN]", "Part of plugin name to search for, leave empty for all plugins"
 
@@ -18,24 +19,26 @@ class LogStash::PluginManager::List < Clamp::Command
     require 'logstash/environment'
     LogStash::Environment.bundler_setup!
 
-    Gem.configuration.verbose = false
+    signal_error("No plugins found") if filtered_specs.empty?
 
-    gemfile = LogStash::Gemfile.new(File.new(LogStash::Environment::GEMFILE_PATH, "r+")).load
-
-    # start with all locally installed plugin gems regardless of the Gemfile content
-    specs = LogStash::PluginManager.find_plugins_gem_specs
-
-    # apply filters
-    specs = specs.select{|spec| gemfile.find(spec.name)} if installed?
-    specs = specs.select{|spec| spec.name =~ /#{plugin}/i} if plugin
-    specs = specs.select{|spec| spec.metadata['logstash_group'] == group} if group
-
-    raise(LogStash::PluginManager::Error, "No plugins found") if specs.empty?
-
-    specs.sort_by{|spec| spec.name}.each do |spec|
+    filtered_specs.sort_by{|spec| spec.name}.each do |spec|
       line = "#{spec.name}"
       line += " (#{spec.version})" if verbose?
       puts(line)
     end
   end
+
+  def filtered_specs
+    @filtered_specs ||= begin
+                          # start with all locally installed plugin gems regardless of the Gemfile content
+                          specs = LogStash::PluginManager.find_plugins_gem_specs
+
+                          # apply filters
+                          specs = specs.select{|spec| gemfile.find(spec.name)} if installed?
+                          specs = specs.select{|spec| spec.name =~ /#{plugin}/i} if plugin
+                          specs = specs.select{|spec| spec.metadata['logstash_group'] == group} if group
+
+                          specs
+                        end
+  end
 end # class Logstash::PluginManager

data/lib/logstash/pluginmanager/main.rb

@@ -5,7 +5,6 @@ require "logstash/pluginmanager/uninstall"
 require "logstash/pluginmanager/list"
 require "logstash/pluginmanager/update"
 require "logstash/pluginmanager/util"
-require "logstash/pluginmanager/maven_tools_patch"
 require "clamp"
 
 module LogStash

data/lib/logstash/pluginmanager/uninstall.rb

@@ -3,25 +3,23 @@ require "logstash/logging"
 require "logstash/errors"
 require "logstash/environment"
 require "logstash/pluginmanager/util"
+require "logstash/pluginmanager/command"
 require "clamp"
 
 require "logstash/gemfile"
 require "logstash/bundler"
 
-class LogStash::PluginManager::Uninstall < Clamp::Command
+class LogStash::PluginManager::Uninstall < LogStash::PluginManager::Command
   parameter "PLUGIN", "plugin name"
 
-
   def execute
-    raise(LogStash::PluginManager::Error, "File #{LogStash::Environment::GEMFILE_PATH} does not exist or is not writable, aborting") unless File.writable?(LogStash::Environment::GEMFILE_PATH)
+    LogStash::Environment.bundler_setup!
 
-    gemfile = LogStash::Gemfile.new(File.new(LogStash::Environment::GEMFILE_PATH, "r+")).load
-    # keep a copy of the gemset to revert on error
-    original_gemset = gemfile.gemset.copy
+    signal_error("File #{LogStash::Environment::GEMFILE_PATH} does not exist or is not writable, aborting") unless File.writable?(LogStash::Environment::GEMFILE_PATH)
 
     # make sure this is an installed plugin and present in Gemfile.
     # it is not possible to uninstall a dependency not listed in the Gemfile, for example a dependent codec
-    raise(LogStash::PluginManager::Error, "This plugin has not been previously installed, aborting") unless LogStash::PluginManager.installed_plugin?(plugin, gemfile)
+    signal_error("This plugin has not been previously installed, aborting") unless LogStash::PluginManager.installed_plugin?(plugin, gemfile)
 
     # since we previously did a gemfile.find(plugin) there is no reason why
     # remove would not work (return nil) here
@@ -31,19 +29,15 @@ class LogStash::PluginManager::Uninstall < Clamp::Command
       puts("Uninstalling #{plugin}")
 
       # any errors will be logged to $stderr by invoke_bundler!
-      output, exception = LogStash::Bundler.invoke_bundler!(:install => true, :clean => true)
-
-      if ENV["DEBUG"]
-        $stderr.puts(output)
-        $stderr.puts("Error: #{exception.class}, #{exception.message}") if exception
-      end
-
-      if exception
-        # revert to original Gemfile content
-        gemfile.gemset = original_gemset
-        gemfile.save
-        raise(LogStash::PluginManager::Error, "Uninstall aborted")
-      end
+      # output, exception = LogStash::Bundler.invoke_bundler!(:install => true, :clean => true)
+      output = LogStash::Bundler.invoke_bundler!(:install => true)
+      
+      remove_unused_locally_installed_gems!
     end
+  rescue => exception
+    gemfile.restore!
+    report_exception("Uninstall Aborted", exception)
+  ensure
+    display_bundler_output(output)
   end
 end

data/lib/logstash/pluginmanager/update.rb

@@ -1,51 +1,80 @@
-require 'clamp'
-require 'logstash/namespace'
-require 'logstash/pluginmanager/util'
-require 'jar-dependencies'
-require 'jar_install_post_install_hook'
-require 'file-dependencies/gem'
-
+require "clamp"
+require "logstash/namespace"
+require "logstash/pluginmanager/util"
+require "logstash/pluginmanager/command"
+require "jar-dependencies"
+require "jar_install_post_install_hook"
+require "file-dependencies/gem"
 require "logstash/gemfile"
 require "logstash/bundler"
 
-class LogStash::PluginManager::Update < Clamp::Command
-  parameter "[PLUGIN] ...", "Plugin name(s) to upgrade to latest version"
+class LogStash::PluginManager::Update < LogStash::PluginManager::Command
+  parameter "[PLUGIN] ...", "Plugin name(s) to upgrade to latest version", :attribute_name => :plugins_arg
 
   def execute
-    gemfile = LogStash::Gemfile.new(File.new(LogStash::Environment::GEMFILE_PATH, "r+")).load
-    # keep a copy of the gemset to revert on error
-    original_gemset = gemfile.gemset.copy
-
-    previous_gem_specs_map = find_latest_gem_specs
+    local_gems = gemfile.locally_installed_gems
 
-    # create list of plugins to update
-    plugins = unless plugin_list.empty?
-      not_installed = plugin_list.select{|plugin| !previous_gem_specs_map.has_key?(plugin.downcase)}
-      raise(LogStash::PluginManager::Error, "Plugin #{not_installed.join(', ')} is not installed so it cannot be updated, aborting") unless not_installed.empty?
-      plugin_list
+    if update_all? || !local_gems.empty?
+      error_plugin_that_use_path!(local_gems)
     else
-      previous_gem_specs_map.values.map{|spec| spec.name}
+      plugins_with_path = plugins_arg & local_gems
+      error_plugin_that_use_path!(plugins_with_path) if plugins_with_path.size > 0 
     end
 
+    update_gems!
+  end
+
+  private
+  def error_plugin_that_use_path!(plugins)
+    signal_error("Update is not supported for manually defined plugins or local .gem plugin installations: #{plugins.collect(&:name).join(",")}")
+  end
+
+  def update_all?
+    plugins_arg.size == 0
+  end
+
+  def update_gems!
+    # If any error is raise inside the block the Gemfile will restore a backup of the Gemfile
+    previous_gem_specs_map = find_latest_gem_specs
+
     # remove any version constrain from the Gemfile so the plugin(s) can be updated to latest version
     # calling update without requiremend will remove any previous requirements
-    plugins.select{|plugin| gemfile.find(plugin)}.each{|plugin| gemfile.update(plugin)}
+    plugins = plugins_to_update(previous_gem_specs_map)
+    plugins
+      .select { |plugin| gemfile.find(plugin) }
+      .each { |plugin| gemfile.update(plugin) }
+
+    # force a disk sync before running bundler
     gemfile.save
 
     puts("Updating " + plugins.join(", "))
 
     # any errors will be logged to $stderr by invoke_bundler!
-    output, exception = LogStash::Bundler.invoke_bundler!(:update => plugins)
-    output, exception = LogStash::Bundler.invoke_bundler!(:clean => true) unless exception
+    # Bundler cannot update and clean gems in one operation so we have to call the CLI twice.
+    output = LogStash::Bundler.invoke_bundler!(:update => plugins)
+    output = LogStash::Bundler.invoke_bundler!(:clean => true) 
 
-    if exception
-      # revert to original Gemfile content
-      gemfile.gemset = original_gemset
-      gemfile.save
+    display_updated_plugins(previous_gem_specs_map)
+  rescue => exception
+    gemfile.restore!
+    report_exception("Updated Aborted", exception)
+  ensure
+    display_bundler_output(output)
+  end
 
-      report_exception(output, exception)
+  # create list of plugins to update
+  def plugins_to_update(previous_gem_specs_map)
+    if update_all?
+      previous_gem_specs_map.values.map{|spec| spec.name}
+    else
+      not_installed = plugins_arg.select{|plugin| !previous_gem_specs_map.has_key?(plugin.downcase)}
+      signal_error("Plugin #{not_installed.join(', ')} is not installed so it cannot be updated, aborting") unless not_installed.empty?
+      plugins_arg
     end
+  end
 
+  # We compare the before the update and after the update
+  def display_updated_plugins(previous_gem_specs_map)
     update_count = 0
     find_latest_gem_specs.values.each do |spec|
       name = spec.name.downcase
@@ -59,11 +88,10 @@ class LogStash::PluginManager::Update < Clamp::Command
         update_count += 1
       end
     end
+
     puts("No plugin updated") if update_count.zero?
   end
 
-  private
-
   # retrieve only the latest spec for all locally installed plugins
   # @return [Hash] result hash {plugin_name.downcase => plugin_spec}
   def find_latest_gem_specs
@@ -73,13 +101,4 @@ class LogStash::PluginManager::Update < Clamp::Command
       result
     end
   end
-
-  def report_exception(output, exception)
-    if ENV["DEBUG"]
-      $stderr.puts(output)
-      $stderr.puts("Error: #{exception.class}, #{exception.message}") if exception
-    end
-
-    raise(LogStash::PluginManager::Error, "Update aborted")
-  end
 end

data/lib/logstash/pluginmanager/util.rb

@@ -1,5 +1,6 @@
-module LogStash::PluginManager
+require "rubygems/package"
 
+module LogStash::PluginManager
   # check for valid logstash plugin gem name & version or .gem file, logs errors to $stdout
   # uses Rubygems API and will remotely validated agains the current Gem.sources
   # @param plugin [String] plugin name or .gem file path
@@ -85,4 +86,4 @@ module LogStash::PluginManager
     # TODO: properly merge versions requirements
     plugin_list.uniq(&:first)
   end
-end
+end

data/lib/logstash/util.rb

@@ -148,5 +148,4 @@ module LogStash::Util
       o
     end
   end
-
 end # module LogStash::Util

data/lib/logstash/util/accessors.rb

@@ -53,6 +53,11 @@ module LogStash::Util
       end
     end
 
+    def include?(accessor)
+      target, key = lookup_path(accessor)
+      return target.include?(key)
+    end
+
     private
 
     def lookup(accessor)

data/lib/logstash/version.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 # The version of logstash.
-LOGSTASH_VERSION = "1.5.0-rc3.snapshot1"
+LOGSTASH_VERSION = "1.5.0-rc3.snapshot2"
 
 # Note to authors: this should not include dashes because 'gem' barfs if
 # you include a dash in the version string.

data/locales/en.yml

@@ -7,6 +7,11 @@ en:
     The error reported is: 
       %{error}
   logstash:
+    environment:
+      jruby-required:  >-
+        JRuby is required
+      missing-jars: >-
+        Could not find jar files under %{pattern}
     pipeline:
       worker-error: |-
         A plugin had an unrecoverable error. Will restart this plugin.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logstash-core
 version: !ruby/object:Gem::Version
-  version: 1.5.0.rc3.snapshot1
+  version: 1.5.0.rc3.snapshot2
 platform: java
 authors:
 - Jordan Sissel
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-04-08 00:00:00.000000000 Z
+date: 2015-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cabin
@@ -166,48 +166,6 @@ dependencies:
         version: '0'
   prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: jar-dependencies
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.1.7
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.1.7
-  prerelease: false
-  type: :runtime
-- !ruby/object:Gem::Dependency
-  name: ruby-maven
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.1.1.0.8
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.1.1.0.8
-  prerelease: false
-  type: :runtime
-- !ruby/object:Gem::Dependency
-  name: maven-tools
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.0.7
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.0.7
-  prerelease: false
-  type: :runtime
 - !ruby/object:Gem::Dependency
   name: minitar
   version_requirements: !ruby/object:Gem::Requirement
@@ -236,20 +194,6 @@ dependencies:
         version: 0.1.6
   prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: jruby-httpclient
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  prerelease: false
-  type: :runtime
 - !ruby/object:Gem::Dependency
   name: jrjackson
   version_requirements: !ruby/object:Gem::Requirement
@@ -373,10 +317,10 @@ files:
 - lib/logstash/pipeline.rb
 - lib/logstash/plugin.rb
 - lib/logstash/pluginmanager.rb
+- lib/logstash/pluginmanager/command.rb
 - lib/logstash/pluginmanager/install.rb
 - lib/logstash/pluginmanager/list.rb
 - lib/logstash/pluginmanager/main.rb
-- lib/logstash/pluginmanager/maven_tools_patch.rb
 - lib/logstash/pluginmanager/uninstall.rb
 - lib/logstash/pluginmanager/update.rb
 - lib/logstash/pluginmanager/util.rb
@@ -399,7 +343,7 @@ files:
 - lib/logstash/util/socket_peer.rb
 - lib/logstash/version.rb
 - locales/en.yml
-homepage: http://logstash.net/
+homepage: http://www.elastic.co/guide/en/logstash/current/index.html
 licenses:
 - Apache License (2.0)
 metadata: {}

data/lib/logstash/pluginmanager/maven_tools_patch.rb

@@ -1,12 +0,0 @@
-# This adds the "repo" element to the jar-dependencies DSL
-# allowing a gemspec to require a jar that exists in a custom
-# maven repository
-# Example:
-#   gemspec.requirements << "repo http://localhosty/repo"
-require 'maven/tools/dsl/project_gemspec'
-class Maven::Tools::DSL::ProjectGemspec
-  def repo(url)
-    @parent.repository(:id => url, :url => url)
-  end
-end
-