logstash-core 1.5.0.beta2-java → 1.5.0-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/JRUBY-PR1448.rb

@@ -1,32 +0,0 @@
-# This patch fixes a problem that exists in JRuby prior to 1.7.11 where the
-# ruby binary path used by rubygems is malformed on Windows, causing
-# dependencies to not install cleanly when using `.\bin\logstash.bat deps`.
-# This monkeypatch can probably be removed once it's unlikely that people
-# are still using JRuby older than 1.7.11.
-  class << Gem
-    def ruby
-      ruby_path = original_ruby
-      ruby_path = "java -jar #{jar_path(ruby_path)}" if jarred_path?(ruby_path)
-      ruby_path
-    end
-
-    def jarred_path?(p)
-      p =~ /^file:/
-    end
-
-    # A jar path looks like this on non-Windows platforms:
-    #   file:/path/to/file.jar!/path/within/jar/to/file.txt
-    # and like this on Windows:
-    #   file:/C:/path/to/file.jar!/path/within/jar/to/file.txt
-    #
-    # This method returns:
-    #   /path/to/file.jar
-    # or
-    #   C:/path/to/file.jar
-    # as appropriate.
-    def jar_path(p)
-      path = p.sub(/^file:/, "").sub(/!.*/, "")
-      path = path.sub(/^\//, "") if win_platform? && path =~ /^\/[A-Za-z]:/
-      path
-    end
-  end

data/lib/logstash/bundler.rb

@@ -1,124 +0,0 @@
-require "bundler"
-require "bundler/cli"
-
-module Bundler
-  # Patch bundler to write a .lock file specific to the version of ruby.
-  # This keeps MRI/JRuby/RBX from conflicting over the Gemfile.lock updates
-  module SharedHelpers
-    def default_lockfile
-      ruby = "#{LogStash::Environment.ruby_engine}-#{LogStash::Environment.ruby_abi_version}"
-      Pathname.new("#{default_gemfile}.#{ruby}.lock")
-    end
-  end
-
-  # Add the Bundler.reset! method which has been added in master but is not in 1.7.9.
-  class << self
-    unless self.method_defined?("reset!")
-      def reset!
-        @definition = nil
-      end
-    end
-
-    def reset_settings
-      # reset!
-      # clear_gemspec_cache
-
-      # remove_instance_variable(:@setup) if defined?(@setup)
-      # remove_instance_variable(:@locked_gems) if defined?(@locked_gems)
-      # remove_instance_variable(:@load) if defined?(@load)
-      remove_instance_variable(:@settings) if defined?(@settings)
-    end
-  end
-end
-
-module LogStash
-  module Bundler
-
-    # 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]
-
-      ENV["GEM_PATH"] = LogStash::Environment.logstash_gem_home
-      ENV["BUNDLE_PATH"] = LogStash::Environment::BUNDLE_DIR
-      ENV["BUNDLE_GEMFILE"] = LogStash::Environment::GEMFILE_PATH
-      ENV["BUNDLE_WITHOUT"] = options[:without].join(":")
-
-      try = 0
-
-      # capture_stdout also traps any raised exception and pass them back as the function return [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) if ENV["DEBUG"]
-            sleep(0.5)
-          end
-        end
-      end
-    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 << "--gemfile=#{LogStash::Environment::GEMFILE_PATH}"
-        arguments << ["--path", LogStash::Environment::BUNDLE_DIR]
-        # note that generating "--without=" when options[:without] is empty is intended
-        arguments << "--without=#{options[:without].join(' ')}"
-      end
-
-      if options[:update]
-        arguments << "update"
-        arguments << options[:update]
-      end
-
-      arguments << "--clean" if options[:clean]
-
-      arguments.flatten
-    end
-  end
-end

data/lib/logstash/gemfile.rb

@@ -1,175 +0,0 @@
-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)
-      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
-  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/install.rb

@@ -1,112 +0,0 @@
-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 "logstash/gemfile"
-require "logstash/bundler"
-
-class LogStash::PluginManager::Install < Clamp::Command
-  parameter "[PLUGIN] ...", "plugin name(s) or file"
-  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.
-  #
-  # 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?
-    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
-    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 = []
-
-    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
-    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
-
-      install_list = version ? [plugin_list << version] : plugin_list.map{|plugin| [plugin, nil]}
-
-      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?
-
-      # at this point we know that we either have a valid gem name & version or a valid .gem file path
-
-      # 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
-    end
-
-
-    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(", ")))
-
-    bundler_options = {:install => true}
-    bundler_options[:without] = [] if development?
-
-    # any errors will be logged to $stderr by invoke_bundler!
-    output, exception = LogStash::Bundler.invoke_bundler!(bundler_options)
-
-    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, "Installation aborted")
-    end
-
-    puts("Installation successful")
-  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
-    end
-    true
-  end
-end # class Logstash::PluginManager