logstash-core 1.5.0.rc3.snapshot6-java → 1.5.0.rc4-java

data/lib/logstash/pluginmanager/list.rb

@@ -1,44 +0,0 @@
-require 'clamp'
-require 'logstash/namespace'
-require 'logstash/pluginmanager/util'
-require 'logstash/pluginmanager/command'
-require "logstash/bundler"
-require 'rubygems/spec_fetcher'
-
-class LogStash::PluginManager::List < LogStash::PluginManager::Command
-
-  parameter "[PLUGIN]", "Part of plugin name to search for, leave empty for all plugins"
-
-  option "--installed", :flag, "List only explicitly installed plugins using bin/plugin install ...", :default => false
-  option "--verbose", :flag, "Also show plugin version number", :default => false
-  option "--group", "NAME", "Filter plugins per group: input, output, filter or codec" do |arg|
-    raise(ArgumentError, "should be one of: input, output, filter or codec") unless ['input', 'output', 'filter', 'codec'].include?(arg)
-    arg
-  end
-
-  def execute
-    LogStash::Bundler.setup!
-
-    signal_error("No plugins found") if filtered_specs.empty?
-
-    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

@@ -1,21 +0,0 @@
-require "logstash/namespace"
-require "logstash/errors"
-require "logstash/pluginmanager/install"
-require "logstash/pluginmanager/uninstall"
-require "logstash/pluginmanager/list"
-require "logstash/pluginmanager/update"
-require "logstash/pluginmanager/util"
-require "clamp"
-
-module LogStash
-  module PluginManager
-    class Error < StandardError; end
-
-    class Main < Clamp::Command
-      subcommand "install", "Install a plugin", LogStash::PluginManager::Install
-      subcommand "uninstall", "Uninstall a plugin", LogStash::PluginManager::Uninstall
-      subcommand "update", "Install a plugin", LogStash::PluginManager::Update
-      subcommand "list", "List all installed plugins", LogStash::PluginManager::List
-    end
-  end
-end

data/lib/logstash/pluginmanager/uninstall.rb

@@ -1,43 +0,0 @@
-require "logstash/namespace"
-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 < LogStash::PluginManager::Command
-  parameter "PLUGIN", "plugin name"
-
-  def execute
-    LogStash::Bundler.setup!
-
-    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
-    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
-    if gemfile.remove(plugin)
-      gemfile.save
-
-      puts("Uninstalling #{plugin}")
-
-      # any errors will be logged to $stderr by invoke_bundler!
-      # 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,105 +0,0 @@
-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 < LogStash::PluginManager::Command
-  parameter "[PLUGIN] ...", "Plugin name(s) to upgrade to latest version", :attribute_name => :plugins_arg
-
-  def execute
-    local_gems = gemfile.locally_installed_gems
-
-    if update_all? && !local_gems.empty?
-      error_plugin_that_use_path!(local_gems)
-    else
-      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 = 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!
-    # 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) 
-
-    display_updated_plugins(previous_gem_specs_map)
-  rescue => exception
-    gemfile.restore!
-    report_exception("Updated Aborted", exception)
-  ensure
-    display_bundler_output(output)
-  end
-
-  # 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
-      if previous_gem_specs_map.has_key?(name)
-        if spec.version != previous_gem_specs_map[name].version
-          puts("Updated #{spec.name} #{previous_gem_specs_map[name].version.to_s} to #{spec.version.to_s}")
-          update_count += 1
-        end
-      else
-        puts("Installed #{spec.name} #{spec.version.to_s}")
-        update_count += 1
-      end
-    end
-
-    puts("No plugin updated") if update_count.zero?
-  end
-
-  # retrieve only the latest spec for all locally installed plugins
-  # @return [Hash] result hash {plugin_name.downcase => plugin_spec}
-  def find_latest_gem_specs
-    LogStash::Bundler.setup!
-    LogStash::PluginManager.find_plugins_gem_specs.inject({}) do |result, spec|
-      previous = result[spec.name.downcase]
-      result[spec.name.downcase] = previous ? [previous, spec].max_by{|s| s.version} : spec
-      result
-    end
-  end
-end

data/lib/logstash/pluginmanager/util.rb

@@ -1,89 +0,0 @@
-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
-  # @param version [String] gem version requirement string
-  # @return [Boolean] true if valid logstash plugin gem name & version or a .gem file
-  def self.logstash_plugin?(plugin, version = nil)
-    if plugin_file?(plugin)
-      begin
-        return logstash_plugin_gem_spec?(plugin_file_spec(plugin))
-      rescue => e
-        $stderr.puts("Error reading plugin file #{plugin}, caused by #{e.class}")
-        $stderr.puts(e.message) if ENV["DEBUG"]
-        return false
-      end
-    else
-      dep = Gem::Dependency.new(plugin, version || Gem::Requirement.default)
-      specs, error = Gem::SpecFetcher.fetcher.spec_for_dependency(dep)
-
-      # depending on version requirements, multiple specs can be returned in which case
-      # we will grab the one with the highest version number
-      if latest = specs.map(&:first).max_by(&:version)
-        unless valid = logstash_plugin_gem_spec?(latest)
-          $stderr.puts("#{plugin} is not a Logstash plugin")
-        end
-        return valid
-      else
-        $stderr.puts("Plugin #{plugin}" + (version ? " version #{version}" : "") + " does not exist")
-        return false
-      end
-    end
-  end
-
-  # @param spec [Gem::Specification] plugin gem specification
-  # @return [Boolean] true if this spec is for an installable logstash plugin
-  def self.logstash_plugin_gem_spec?(spec)
-    spec.metadata && spec.metadata["logstash_plugin"] == "true"
-  end
-
-  # @param path [String] path to .gem file
-  # @return [Gem::Specification] .get file gem specification
-  # @raise [Exception] Gem::Package::FormatError will be raised on invalid .gem file format, might be other exceptions too
-  def self.plugin_file_spec(path)
-    Gem::Package.new(path).spec
-  end
-
-  # @param plugin [String] the plugin name or the local path to a .gem file
-  # @return [Boolean] true if the plugin is a local .gem file
-  def self.plugin_file?(plugin)
-    (plugin =~ /\.gem$/ && File.file?(plugin))
-  end
-
-  # retrieve gem specs for all or specified name valid logstash plugins locally installed
-  # @param name [String] specific plugin name to find or nil for all plungins
-  # @return [Array<Gem::Specification>] all local logstash plugin gem specs
-  def self.find_plugins_gem_specs(name = nil)
-    specs = name ? Gem::Specification.find_all_by_name(name) : Gem::Specification.find_all
-    specs.select{|spec| logstash_plugin_gem_spec?(spec)}
-  end
-
-  # list of all locally installed plugins specs specified in the Gemfile.
-  # note that an installed plugin dependecies like codecs will not be listed, only those
-  # specifically listed in the Gemfile.
-  # @param gemfile [LogStash::Gemfile] the gemfile to validate against
-  # @return [Array<Gem::Specification>] list of plugin specs
-  def self.all_installed_plugins_gem_specs(gemfile)
-    # we start form the installed gemspecs so we can verify the metadata for valid logstash plugin
-    # then filter out those not included in the Gemfile
-    find_plugins_gem_specs.select{|spec| !!gemfile.find(spec.name)}
-  end
-
-  # @param plugin [String] plugin name
-  # @param gemfile [LogStash::Gemfile] the gemfile to validate against
-  # @return [Boolean] true if the plugin is an installed logstash plugin and spefificed in the Gemfile
-  def self.installed_plugin?(plugin, gemfile)
-    !!gemfile.find(plugin) && find_plugins_gem_specs(plugin).any?
-  end
-
-  # @param plugin_list [Array] array of [plugin name, version] tuples
-  # @return [Array] array of [plugin name, version, ...] tuples when duplciate names have been merged and non duplicate version requirements added
-  def self.merge_duplicates(plugin_list)
-
-    # quick & dirty naive dedup for now
-    # TODO: properly merge versions requirements
-    plugin_list.uniq(&:first)
-  end
-end