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

data/lib/logstash-event.rb

@@ -1,2 +0,0 @@
-# encoding: utf-8
-require "logstash/event"

data/lib/logstash.rb

@@ -1,4 +0,0 @@
-# encoding: utf-8
-require "logstash/agent"
-require "logstash/event"
-require "logstash/namespace"

data/lib/logstash/bundler.rb

@@ -1,156 +0,0 @@
-require "logstash/environment"
-
-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
-
-    def self.setup!(options = {})
-      options = {:without => [:development]}.merge(options)
-      options[:without] = Array(options[:without])
-
-      # make sure we use our own installed bundler
-      require "logstash/patches/rubygems" # patch rubygems before clear_paths
-      ::Gem.clear_paths
-      ::Gem.paths = ENV['GEM_HOME'] = ENV['GEM_PATH'] = LogStash::Environment.logstash_gem_home
-
-      # set BUNDLE_GEMFILE ENV before requiring bundler to avoid bundler recurse and load unrelated Gemfile(s)
-      ENV["BUNDLE_GEMFILE"] = LogStash::Environment::GEMFILE_PATH
-
-      require "bundler"
-      require "logstash/bundler"
-      require "logstash/patches/bundler"
-
-      ::Bundler.settings[:path]    = LogStash::Environment::BUNDLE_DIR
-      ::Bundler.settings[:without] = options[:without].join(":")
-      # in the context of Bundler.setup it looks like this is useless here because Gemfile path can only be specified using
-      # the ENV, see https://github.com/bundler/bundler/blob/v1.8.3/lib/bundler/shared_helpers.rb#L103
-      ::Bundler.settings[:gemfile] = LogStash::Environment::GEMFILE_PATH
-
-      ::Bundler.reset!
-      ::Bundler.setup
-    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
-    # @return [String, Exception] the captured $stdout string and any trapped exception or nil if none
-    def self.capture_stdout(&block)
-      old_stdout = $stdout
-      $stdout = StringIO.new("", "w")
-      begin
-        block.call
-      rescue => e
-        return [$stdout.string, e]
-      end
-
-      [$stdout.string, nil]
-    ensure
-      $stdout = old_stdout
-    end
-
-    # execute bundle install and capture any $stdout output. any raised exception in the process will be trapped
-    # and returned. logs errors to $stdout.
-    # @param options [Hash] invoke options with default values, :max_tries => 10, :clean => false, :install => false, :update => false
-    # @param   options[:update] must be either false or a String or an Array of String
-    # @return [String, Exception] the installation captured output and any raised exception or nil if none
-    def self.invoke_bundler!(options = {})
-      options = {:max_tries => 10, :clean => false, :install => false, :update => false, :without => [:development]}.merge(options)
-      options[:without] = Array(options[:without])
-      options[:update] = Array(options[:update]) if options[:update]
-
-      # make sure we use our own installed bundler
-      require "logstash/patches/rubygems" # patch rubygems before clear_paths
-      ::Gem.clear_paths
-      ::Gem.paths = ENV['GEM_HOME'] = ENV['GEM_PATH'] = LogStash::Environment.logstash_gem_home
-
-      # set BUNDLE_GEMFILE ENV before requiring bundler to avoid bundler recurse and load unrelated Gemfile(s).
-      # in the context of calling Bundler::CLI this is not really required since Bundler::CLI will look at
-      # Bundler.settings[:gemfile] unlike Bundler.setup. For the sake of consistency and defensive/future proofing, let's keep it here.
-      ENV["BUNDLE_GEMFILE"] = LogStash::Environment::GEMFILE_PATH
-
-      require "bundler"
-      require "bundler/cli"
-      require "logstash/patches/bundler"
-
-      # 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(":")
-
-      try = 0
-
-      # capture_stdout also traps any raised exception and pass them back as the function return [output, exception]
-      output, exception = capture_stdout do
-        loop do
-          begin
-            ::Bundler.reset!
-            ::Bundler::CLI.start(bundler_arguments(options))
-            break
-          rescue ::Bundler::VersionConflict => e
-            $stderr.puts("Plugin version conflict, aborting")
-            raise(e)
-          rescue ::Bundler::GemNotFound => e
-            $stderr.puts("Plugin not found, aborting")
-            raise(e)
-          rescue => e
-            if try >= options[:max_tries]
-              $stderr.puts("Too many retries, aborting, caused by #{e.class}")
-              $stderr.puts(e.message) if ENV["DEBUG"]
-              raise(e)
-            end
-
-            try += 1
-            $stderr.puts("Error #{e.class}, retrying #{try}/#{options[:max_tries]}")
-            $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
-    # @param option [Hash] the invoke_bundler! options hash
-    # @return [Array<String>] Bundler::CLI.start string arguments array
-    def self.bundler_arguments(options = {})
-      arguments = []
-
-      if options[:install]
-        arguments << "install"
-        arguments << "--clean" if options[:clean]
-      elsif options[:update]
-        arguments << "update"
-        arguments << options[:update]
-      elsif options[:clean]
-        arguments << "clean"
-      end
-
-      arguments.flatten
-    end
-  end
-end

data/lib/logstash/gemfile.rb

@@ -1,193 +0,0 @@
-require "logstash/util"
-module LogStash
-
-  class GemfileError < StandardError; end
-
-  class Gemfile
-    attr_accessor :gemset
-
-    HEADER = \
-      "# This is a Logstash generated Gemfile.\n" + \
-      "# If you modify this file manually all comments and formatting will be lost.\n\n"
-
-    # @params io [IO] any IO object that supports read, write, truncate, rewind
-    def initialize(io)
-      @io = io
-      @gemset = nil
-    end
-
-    def load
-      @gemset ||= DSL.parse(@io.read)
-      backup
-      self
-    end
-
-    def save
-      raise(GemfileError, "a Gemfile must first be loaded") unless @gemset
-      @io.truncate(0)
-      @io.rewind
-      @io.write(HEADER)
-      @io.write(@gemset.to_s)
-      @io.flush
-    end
-
-    def find(name)
-      @gemset.find_gem(name)
-    end
-
-    # @param name [String] gem name
-    # @param *requirements params following name use the same notation as the Gemfile gem DSL statement
-    # @raise GemfileError if gem already exists in Gemfile
-    def add(name, *requirements)
-      @gemset.add_gem(Gem.parse(name, *requirements))
-    end
-
-    # update existing or add new
-    # @param name [String] gem name
-    # @param *requirements params following name use the same notation as the Gemfile gem DSL statement
-    def update(name, *requirements)
-      @gemset.update_gem(Gem.parse(name, *requirements))
-    end
-
-    # @return [Gem] removed gem or nil if not found
-    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
-    attr_accessor :sources, :gems, :gemspec
-
-    def initialize
-      @sources = []      # list of urls
-      @gems = []         # list of Gem class
-      @gems_by_name = {} # hash of name => Gem
-      @gemspec = {}      # gemspec is a options hash
-    end
-
-    def to_s
-      [sources_to_s, gemspec_to_s, gems_to_s].select{|s| !s.empty?}.join("\n") + "\n"
-    end
-
-    # @return [Gem] found gem or nil if not found
-    def find_gem(name)
-      @gems_by_name[name.downcase]
-    end
-
-    # @raise GemfileError if gem already exists
-    def add_gem(_gem)
-      raise(GemfileError, "duplicate gem #{_gem.name}") if find_gem(_gem.name)
-      @gems << _gem
-      @gems_by_name[_gem.name.downcase] = _gem
-    end
-
-    # update existing or add new
-    def update_gem(_gem)
-      if old = find_gem(_gem.name)
-        @gems[@gems.index(old)] = _gem
-      else
-        @gems << _gem
-      end
-      @gems_by_name[_gem.name.downcase] = _gem
-    end
-
-    # @return [Gem] removed gem or nil if not found
-    def remove_gem(name)
-      if _gem = @gems_by_name.delete(name.downcase)
-        @gems.delete_at(@gems.index(_gem))
-      end
-      _gem
-    end
-
-    # deep clone self
-    def copy
-      Marshal.load(Marshal.dump(self))
-    end
-    private
-
-    def sources_to_s
-      return "" if @sources.empty?
-      @sources.map{|source| "source #{source.inspect}"}.join("\n")
-    end
-
-    def gems_to_s
-      return "" if @gems.empty?
-      @gems.map do |gem|
-        requirements = gem.requirements.empty? ? nil : gem.requirements.map{|r| r.inspect}.join(", ")
-        options = gem.options.empty? ? nil : gem.options.map{|k, v| "#{k.inspect} => #{v.inspect}"}.join(", ")
-        "gem " + [gem.name.inspect, requirements, options].compact.join(", ")
-      end.join("\n")
-    end
-
-    def gemspec_to_s
-      return "" if @gemspec.empty?
-      options = @gemspec.map{|k, v| "#{k.inspect} => #{v.inspect}"}.join(", ")
-      "gemspec #{options}"
-    end
-  end
-
-  # DSL is a minimal, incomplete Gemfile DSL subset parser, only what is currently required is implemented.
-  class DSL
-    attr_reader :gemset
-
-    def initialize
-      @gemset = Gemset.new
-    end
-
-    # @param gemfile_content [String] the Gemfile string content
-    # @return [Gemset] parsed Gemfile content as a Gemset
-    def self.parse(gemfile_content)
-      dsl = self.new
-      dsl.instance_eval(gemfile_content)
-      dsl.gemset
-    end
-
-    # DSL methods
-
-    def source(url)
-      @gemset.sources << url
-    end
-
-    def gem(name, *requirements)
-      parsed = Gem.parse(name, *requirements)
-      @gemset.add_gem(parsed)
-    end
-
-    def gemspec(options = {})
-      raise(GemfileError, "cannot declare multiple gemspec directives") unless @gemset.gemspec.empty?
-      @gemset.gemspec = options
-    end
-  end
-
-  class Gem
-    attr_accessor :name, :requirements, :options
-
-    def initialize(name, requirements = [], options = {})
-      @name = name
-      @requirements = requirements.map{|r| r.to_s.strip}.select{|r| !r.empty?}
-      @options = options
-    end
-
-    def self.parse(name, *requirements)
-      options = requirements.last.is_a?(Hash) ? requirements.pop : {}
-      self.new(name, requirements, options)
-    end
-  end
-end

data/lib/logstash/pluginmanager.rb

@@ -1,17 +0,0 @@
-$DEBUGLIST = (ENV["DEBUG"] || "").split(",")
-
-require "logstash/environment"
-
-ENV["GEM_HOME"] = ENV["GEM_PATH"] = LogStash::Environment.logstash_gem_home
-Gem.use_paths(LogStash::Environment.logstash_gem_home)
-
-require 'logstash/pluginmanager/main'
-
-if __FILE__ == $0
-  begin
-    LogStash::PluginManager::Main.run("bin/plugin", ARGV)
-  rescue LogStash::PluginManager::Error => e
-    $stderr.puts(e.message)
-    exit(1)
-  end
-end

data/lib/logstash/pluginmanager/command.rb

@@ -1,38 +0,0 @@
-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)
-    require "pathname"
-    ::Pathname.new(path).relative_path_from(::Pathname.new(LogStash::Environment::LOGSTASH_HOME)).to_s
-  end
-end

data/lib/logstash/pluginmanager/install.rb

@@ -1,141 +0,0 @@
-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 < 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
-
-  # 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.
-  def execute
-    validate_cli_options!
-    
-    if local_gems?
-      gems = extract_local_gems_plugins
-    elsif development?
-      gems = plugins_development_gems
-    else
-      gems = plugins_gems
-      verify_remote!(gems) if verify?
-    end
-
-    install_gems_list!(gems)
-    remove_unused_locally_installed_gems! 
-  end
-
-  private
-  def validate_cli_options!
-    if development?
-      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
-      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
-
-  # 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
-
-  def plugins_development_gems
-    # Get currently defined gems and their dev dependencies
-    specs = []
-
-    specs = LogStash::PluginManager.all_installed_plugins_gem_specs(gemfile)
-
-    # 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)
-
-    # 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
-
-    output = LogStash::Bundler.invoke_bundler!(bundler_options)
-
-    puts("Installation successful")
-  rescue => exception
-    gemfile.restore!
-    report_exception("Installation Aborted", exception)
-  ensure
-    display_bundler_output(output)
-  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
-
-      package, path = LogStash::Bundler.unpack(plugin, LogStash::Environment::LOCAL_GEM_PATH)
-      [package.spec.name, package.spec.version, { :path => relative_path(path) }]
-    end
-  end
-
-  # 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
-  end
-end # class Logstash::PluginManager