logstash-filter-cache-redis 0.1.0 → 0.2.0

data/vendor/bundle/jruby/1.9/gems/concurrent-ruby-1.0.0-java/lib/concurrent/configuration.rb

@@ -1,153 +0,0 @@
-require 'thread'
-require 'concurrent/delay'
-require 'concurrent/errors'
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/concern/logging'
-require 'concurrent/executor/immediate_executor'
-require 'concurrent/utility/at_exit'
-require 'concurrent/utility/processor_counter'
-
-module Concurrent
-  extend Concern::Logging
-
-  autoload :Options,            'concurrent/options'
-  autoload :TimerSet,           'concurrent/executor/timer_set'
-  autoload :ThreadPoolExecutor, 'concurrent/executor/thread_pool_executor'
-
-  # @return [Logger] Logger with provided level and output.
-  def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
-    logger           = Logger.new(output)
-    logger.level     = level
-    logger.formatter = lambda do |severity, datetime, progname, msg|
-      formatted_message = case msg
-                          when String
-                            msg
-                          when Exception
-                            format "%s (%s)\n%s",
-                              msg.message, msg.class, (msg.backtrace || []).join("\n")
-                          else
-                            msg.inspect
-                          end
-      format "[%s] %5s -- %s: %s\n",
-        datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
-        severity,
-        progname,
-        formatted_message
-    end
-
-    lambda do |loglevel, progname, message = nil, &block|
-    logger.add loglevel, message, progname, &block
-    end
-  end
-
-  # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
-  def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
-    Concurrent.global_logger = create_stdlib_logger level, output
-  end
-
-  # Suppresses all output when used for logging.
-  NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
-
-  # @!visibility private
-  GLOBAL_LOGGER = AtomicReference.new(create_stdlib_logger(Logger::WARN))
-  private_constant :GLOBAL_LOGGER
-
-  def self.global_logger
-    GLOBAL_LOGGER.value
-  end
-
-  def self.global_logger=(value)
-    GLOBAL_LOGGER.value = value
-  end
-
-  # @!visibility private
-  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor(auto_terminate: true) }
-  private_constant :GLOBAL_FAST_EXECUTOR
-
-  # @!visibility private
-  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor(auto_terminate: true) }
-  private_constant :GLOBAL_IO_EXECUTOR
-
-  # @!visibility private
-  GLOBAL_TIMER_SET = Delay.new { TimerSet.new(auto_terminate: true) }
-  private_constant :GLOBAL_TIMER_SET
-
-  # @!visibility private
-  GLOBAL_IMMEDIATE_EXECUTOR = ImmediateExecutor.new
-  private_constant :GLOBAL_IMMEDIATE_EXECUTOR
-
-  # Disables AtExit handlers including pool auto-termination handlers.
-  # When disabled it will be the application programmer's responsibility
-  # to ensure that the handlers are shutdown properly prior to application
-  # exit by calling {AtExit.run} method.
-  #
-  # @note this option should be needed only because of `at_exit` ordering
-  #   issues which may arise when running some of the testing frameworks.
-  #   E.g. Minitest's test-suite runs itself in `at_exit` callback which
-  #   executes after the pools are already terminated. Then auto termination
-  #   needs to be disabled and called manually after test-suite ends.
-  # @note This method should *never* be called
-  #   from within a gem. It should *only* be used from within the main
-  #   application and even then it should be used only when necessary.
-  # @see AtExit
-  def self.disable_at_exit_handlers!
-    AtExit.enabled = false
-  end
-
-  # Global thread pool optimized for short, fast *operations*.
-  #
-  # @return [ThreadPoolExecutor] the thread pool
-  def self.global_fast_executor
-    GLOBAL_FAST_EXECUTOR.value
-  end
-
-  # Global thread pool optimized for long, blocking (IO) *tasks*.
-  #
-  # @return [ThreadPoolExecutor] the thread pool
-  def self.global_io_executor
-    GLOBAL_IO_EXECUTOR.value
-  end
-
-  def self.global_immediate_executor
-    GLOBAL_IMMEDIATE_EXECUTOR
-  end
-
-  # Global thread pool user for global *timers*.
-  #
-  # @return [Concurrent::TimerSet] the thread pool
-  def self.global_timer_set
-    GLOBAL_TIMER_SET.value
-  end
-
-  # General access point to global executors.
-  # @param [Symbol, Executor] executor_identifier symbols:
-  #   - :fast - {Concurrent.global_fast_executor}
-  #   - :io - {Concurrent.global_io_executor}
-  #   - :immediate - {Concurrent.global_immediate_executor}
-  # @return [Executor]
-  def self.executor(executor_identifier)
-    Options.executor(executor_identifier)
-  end
-
-  def self.new_fast_executor(opts = {})
-    FixedThreadPool.new(
-      [2, Concurrent.processor_count].max,
-      auto_terminate:  opts.fetch(:auto_terminate, true),
-      idletime:        60, # 1 minute
-      max_queue:       0, # unlimited
-      fallback_policy: :abort # shouldn't matter -- 0 max queue
-    )
-  end
-
-  def self.new_io_executor(opts = {})
-    ThreadPoolExecutor.new(
-      min_threads:     [2, Concurrent.processor_count].max,
-      max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
-      # max_threads:     1000,
-      auto_terminate:  opts.fetch(:auto_terminate, true),
-      idletime:        60, # 1 minute
-      max_queue:       0, # unlimited
-      fallback_policy: :abort # shouldn't matter -- 0 max queue
-    )
-  end
-end

data/vendor/bundle/jruby/1.9/gems/concurrent-ruby-1.0.0-java/lib/concurrent/dataflow.rb

@@ -1,78 +0,0 @@
-require 'concurrent/future'
-require 'concurrent/atomic/atomic_fixnum'
-
-module Concurrent
-
-  # @!visibility private
-  class DependencyCounter # :nodoc:
-
-    def initialize(count, &block)
-      @counter = AtomicFixnum.new(count)
-      @block = block
-    end
-
-    def update(time, value, reason)
-      if @counter.decrement == 0
-        @block.call
-      end
-    end
-  end
-
-  # {include:file:doc/dataflow.md}
-  #
-  # @param [Future] inputs zero or more `Future` operations that this dataflow depends upon
-  #
-  # @yield The operation to perform once all the dependencies are met
-  # @yieldparam [Future] inputs each of the `Future` inputs to the dataflow
-  # @yieldreturn [Object] the result of the block operation
-  #
-  # @return [Object] the result of all the operations
-  #
-  # @raise [ArgumentError] if no block is given
-  # @raise [ArgumentError] if any of the inputs are not `IVar`s
-  def dataflow(*inputs, &block)
-    dataflow_with(Concurrent.global_io_executor, *inputs, &block)
-  end
-  module_function :dataflow
-
-  def dataflow_with(executor, *inputs, &block)
-    call_dataflow(:value, executor, *inputs, &block)
-  end
-  module_function :dataflow_with
-  
-  def dataflow!(*inputs, &block)
-    dataflow_with!(Concurrent.global_io_executor, *inputs, &block)
-  end
-  module_function :dataflow!
-
-  def dataflow_with!(executor, *inputs, &block)
-    call_dataflow(:value!, executor, *inputs, &block)
-  end
-  module_function :dataflow_with!
-
-  private 
-
-  def call_dataflow(method, executor, *inputs, &block)
-    raise ArgumentError.new('an executor must be provided') if executor.nil?
-    raise ArgumentError.new('no block given') unless block_given?
-    raise ArgumentError.new('not all dependencies are IVars') unless inputs.all? { |input| input.is_a? IVar }
-
-    result = Future.new(executor: executor) do
-      values = inputs.map { |input| input.send(method) }
-      block.call(*values)
-    end
-
-    if inputs.empty?
-      result.execute
-    else
-      counter = DependencyCounter.new(inputs.size) { result.execute }
-
-      inputs.each do |input|
-        input.add_observer counter
-      end
-    end
-
-    result
-  end
-  module_function :call_dataflow
-end

data/vendor/bundle/jruby/1.9/gems/concurrent-ruby-1.0.0-java/lib/concurrent/delay.rb

@@ -1,196 +0,0 @@
-require 'thread'
-require 'concurrent/concern/obligation'
-require 'concurrent/executor/immediate_executor'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  autoload :Options, 'concurrent/options'
-
-  # Lazy evaluation of a block yielding an immutable result. Useful for
-  # expensive operations that may never be needed. It may be non-blocking,
-  # supports the `Concern::Obligation` interface, and accepts the injection of
-  # custom executor upon which to execute the block. Processing of
-  # block will be deferred until the first time `#value` is called.
-  # At that time the caller can choose to return immediately and let
-  # the block execute asynchronously, block indefinitely, or block
-  # with a timeout.
-  #
-  # When a `Delay` is created its state is set to `pending`. The value and
-  # reason are both `nil`. The first time the `#value` method is called the
-  # enclosed opration will be run and the calling thread will block. Other
-  # threads attempting to call `#value` will block as well. Once the operation
-  # is complete the *value* will be set to the result of the operation or the
-  # *reason* will be set to the raised exception, as appropriate. All threads
-  # blocked on `#value` will return. Subsequent calls to `#value` will immediately
-  # return the cached value. The operation will only be run once. This means that
-  # any side effects created by the operation will only happen once as well.
-  #
-  # `Delay` includes the `Concurrent::Concern::Dereferenceable` mixin to support thread
-  # safety of the reference returned by `#value`.
-  #
-  # @!macro copy_options
-  #
-  # @!macro [attach] delay_note_regarding_blocking
-  #   @note The default behavior of `Delay` is to block indefinitely when
-  #     calling either `value` or `wait`, executing the delayed operation on
-  #     the current thread. This makes the `timeout` value completely
-  #     irrelevant. To enable non-blocking behavior, use the `executor`
-  #     constructor option. This will cause the delayed operation to be
-  #     execute on the given executor, allowing the call to timeout.
-  #
-  # @see Concurrent::Concern::Dereferenceable
-  class Delay < Synchronization::LockableObject
-    include Concern::Obligation
-
-    # NOTE: Because the global thread pools are lazy-loaded with these objects
-    # there is a performance hit every time we post a new task to one of these
-    # thread pools. Subsequently it is critical that `Delay` perform as fast
-    # as possible post-completion. This class has been highly optimized using
-    # the benchmark script `examples/lazy_and_delay.rb`. Do NOT attempt to
-    # DRY-up this class or perform other refactoring with running the
-    # benchmarks and ensuring that performance is not negatively impacted.
-
-    # Create a new `Delay` in the `:pending` state.
-    #
-    # @!macro executor_and_deref_options
-    #
-    # @yield the delayed operation to perform
-    #
-    # @raise [ArgumentError] if no block is given
-    def initialize(opts = {}, &block)
-      raise ArgumentError.new('no block given') unless block_given?
-      super(&nil)
-      synchronize { ns_initialize(opts, &block) }
-    end
-
-    # Return the value this object represents after applying the options
-    # specified by the `#set_deref_options` method. If the delayed operation
-    # raised an exception this method will return nil. The execption object
-    # can be accessed via the `#reason` method.
-    #
-    # @param [Numeric] timeout the maximum number of seconds to wait
-    # @return [Object] the current value of the object
-    #
-    # @!macro delay_note_regarding_blocking
-    def value(timeout = nil)
-      if @executor # TODO (pitr 12-Sep-2015): broken unsafe read?
-        super
-      else
-        # this function has been optimized for performance and
-        # should not be modified without running new benchmarks
-        synchronize do
-          execute = @computing = true unless @computing
-          if execute
-            begin
-              set_state(true, @task.call, nil)
-            rescue => ex
-              set_state(false, nil, ex)
-            end
-          end
-        end
-        if @do_nothing_on_deref
-          @value
-        else
-          apply_deref_options(@value)
-        end
-      end
-    end
-
-    # Return the value this object represents after applying the options
-    # specified by the `#set_deref_options` method. If the delayed operation
-    # raised an exception, this method will raise that exception (even when)
-    # the operation has already been executed).
-    #
-    # @param [Numeric] timeout the maximum number of seconds to wait
-    # @return [Object] the current value of the object
-    # @raise [Exception] when `#rejected?` raises `#reason`
-    #
-    # @!macro delay_note_regarding_blocking
-    def value!(timeout = nil)
-      if @executor
-        super
-      else
-        result = value
-        raise @reason if @reason
-        result
-      end
-    end
-
-    # Return the value this object represents after applying the options
-    # specified by the `#set_deref_options` method.
-    #
-    # @param [Integer] timeout (nil) the maximum number of seconds to wait for
-    #   the value to be computed. When `nil` the caller will block indefinitely.
-    #
-    # @return [Object] self
-    #
-    # @!macro delay_note_regarding_blocking
-    def wait(timeout = nil)
-      if @executor
-        execute_task_once
-        super(timeout)
-      else
-        value
-      end
-      self
-    end
-
-    # Reconfigures the block returning the value if still `#incomplete?`
-    #
-    # @yield the delayed operation to perform
-    # @return [true, false] if success
-    def reconfigure(&block)
-      synchronize do
-        raise ArgumentError.new('no block given') unless block_given?
-        unless @computing
-          @task = block
-          true
-        else
-          false
-        end
-      end
-    end
-
-    protected
-
-    def ns_initialize(opts, &block)
-      init_obligation
-      set_deref_options(opts)
-      @executor = opts[:executor]
-
-      @task      = block
-      @state     = :pending
-      @computing = false
-    end
-
-    private
-
-    # @!visibility private
-    def execute_task_once # :nodoc:
-      # this function has been optimized for performance and
-      # should not be modified without running new benchmarks
-      execute = task = nil
-      synchronize do
-        execute = @computing = true unless @computing
-        task    = @task
-      end
-
-      if execute
-        executor = Options.executor_from_options(executor: @executor)
-        executor.post do
-          begin
-            result  = task.call
-            success = true
-          rescue => ex
-            reason = ex
-          end
-          synchronize do
-            set_state(success, result, reason)
-            event.set
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/1.9/gems/concurrent-ruby-1.0.0-java/lib/concurrent/edge.rb

@@ -1,30 +0,0 @@
-module Concurrent
-
-  # A submodule for unstable, highly experimental features that are likely to
-  # change often and which may never become part of the core gem. Also for
-  # new, experimental version of abstractions already in the core gem.
-  #
-  # Most new features should start in this module, clearly indicating the
-  # experimental and unstable nature of the feature. Once a feature becomes
-  # more stable and is a candidate for inclusion in the core gem it should
-  # be moved up to the `Concurrent` module, where it would reside once merged
-  # into the core gem.
-  #
-  # The only exception to this is for features which *replace* features from
-  # the core gem in ways that are breaking and not backward compatible. These
-  # features should remain in this module until merged into the core gem. This
-  # will prevent namespace collisions.
-  #
-  # This file should *never* be used as a global `require` for all files within
-  # the edge gem. Because these features are experimental users should always
-  # explicitly require only what they need.
-  #
-  # @!macro [attach] edge_warning
-  #   @api Edge
-  #   @note **Edge Feature:** Edge features are under active development and may change frequently. They are expected not to
-  #     keep backward compatibility (there may also lack tests and documentation). Semantic versions will
-  #     be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move
-  #     to `concurrent-ruby` when final.
-  module Edge
-  end
-end