logstash-codec-json 2.0.2 → 2.0.3

data/vendor/gems/concurrent-ruby-0.9.1-java/lib/concurrent/configuration.rb

@@ -0,0 +1,296 @@
+require 'thread'
+require 'concurrent/delay'
+require 'concurrent/errors'
+require 'concurrent/atomic/atomic_reference'
+require 'concurrent/concern/deprecation'
+require 'concurrent/concern/logging'
+require 'concurrent/executor/timer_set'
+require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/executor/thread_pool_executor'
+require 'concurrent/utility/at_exit'
+require 'concurrent/utility/processor_counter'
+
+module Concurrent
+  extend Concern::Logging
+  extend Concern::Deprecation
+
+  # @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
+
+  def self.disable_executor_auto_termination!
+    deprecated_method 'disable_executor_auto_termination!', 'disable_at_exit_handlers!'
+    disable_at_exit_handlers!
+  end
+
+  # @return [true,false]
+  # @see .disable_executor_auto_termination!
+  def self.disable_executor_auto_termination?
+    deprecated_method 'disable_executor_auto_termination?', 'Concurrent::AtExit.enabled?'
+    AtExit.enabled?
+  end
+
+  # terminates all pools and blocks until they are terminated
+  # @see .disable_executor_auto_termination!
+  def self.terminate_pools!
+    deprecated_method 'terminate_pools!', 'Concurrent::AtExit.run'
+    AtExit.run
+  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)
+    Executor.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
+
+  # A gem-level configuration object.
+  class Configuration
+    include Concern::Deprecation
+
+    # Create a new configuration object.
+    def initialize
+    end
+
+    # if assigned to {#logger}, it will log nothing.
+    # @deprecated Use Concurrent::NULL_LOGGER instead
+    def no_logger
+      deprecated_method 'Concurrent.configuration.no_logger', 'Concurrent::NULL_LOGGER'
+      NULL_LOGGER
+    end
+
+    # a proc defining how to log messages, its interface has to be:
+    #   lambda { |level, progname, message = nil, &block| _ }
+    #
+    # @deprecated Use Concurrent.global_logger instead
+    def logger
+      deprecated_method 'Concurrent.configuration.logger', 'Concurrent.global_logger'
+      Concurrent.global_logger.value
+    end
+
+    # a proc defining how to log messages, its interface has to be:
+    #   lambda { |level, progname, message = nil, &block| _ }
+    #
+    # @deprecated Use Concurrent.global_logger instead
+    def logger=(value)
+      deprecated_method 'Concurrent.configuration.logger=', 'Concurrent.global_logger='
+      Concurrent.global_logger = value
+    end
+
+    # @deprecated Use Concurrent.global_io_executor instead
+    def global_task_pool
+      deprecated_method 'Concurrent.configuration.global_task_pool', 'Concurrent.global_io_executor'
+      Concurrent.global_io_executor
+    end
+
+    # @deprecated Use Concurrent.global_fast_executor instead
+    def global_operation_pool
+      deprecated_method 'Concurrent.configuration.global_operation_pool', 'Concurrent.global_fast_executor'
+      Concurrent.global_fast_executor
+    end
+
+    # @deprecated Use Concurrent.global_timer_set instead
+    def global_timer_set
+      deprecated_method 'Concurrent.configuration.global_timer_set', 'Concurrent.global_timer_set'
+      Concurrent.global_timer_set
+    end
+
+    # @deprecated Replacing global thread pools is deprecated.
+    #   Use the :executor constructor option instead.
+    def global_task_pool=(executor)
+      deprecated 'Replacing global thread pools is deprecated. Use the :executor constructor option instead.'
+      GLOBAL_IO_EXECUTOR.reconfigure { executor } or
+          raise ConfigurationError.new('global task pool was already set')
+    end
+
+    # @deprecated Replacing global thread pools is deprecated.
+    #   Use the :executor constructor option instead.
+    def global_operation_pool=(executor)
+      deprecated 'Replacing global thread pools is deprecated. Use the :executor constructor option instead.'
+      GLOBAL_FAST_EXECUTOR.reconfigure { executor } or
+          raise ConfigurationError.new('global operation pool was already set')
+    end
+
+    # @deprecated Use Concurrent.new_io_executor instead
+    def new_task_pool
+      deprecated_method 'Concurrent.configuration.new_task_pool', 'Concurrent.new_io_executor'
+      Concurrent.new_io_executor
+    end
+
+    # @deprecated Use Concurrent.new_fast_executor instead
+    def new_operation_pool
+      deprecated_method 'Concurrent.configuration.new_operation_pool', 'Concurrent.new_fast_executor'
+      Concurrent.new_fast_executor
+    end
+
+    # @deprecated Use Concurrent.disable_executor_auto_termination! instead
+    def auto_terminate=(value)
+      deprecated_method 'Concurrent.configuration.auto_terminate=', 'Concurrent.disable_executor_auto_termination!'
+      Concurrent.disable_executor_auto_termination! if !value
+    end
+
+    # @deprecated Use Concurrent.auto_terminate_global_executors? instead
+    def auto_terminate
+      deprecated_method 'Concurrent.configuration.auto_terminate', 'Concurrent.auto_terminate_global_executors?'
+      Concurrent.auto_terminate_global_executors?
+    end
+  end
+
+  # create the default configuration on load
+  CONFIGURATION = AtomicReference.new(Configuration.new)
+  private_constant :CONFIGURATION
+
+  # @return [Configuration]
+  def self.configuration
+    CONFIGURATION.value
+  end
+
+  # Perform gem-level configuration.
+  #
+  # @yield the configuration commands
+  # @yieldparam [Configuration] the current configuration object
+  def self.configure
+    yield(configuration)
+  end
+
+  # for dependency reasons this check cannot be in concurrent/synchronization
+  if Concurrent.on_jruby?
+    require 'java'
+
+    version_string = java.lang.System.getProperties['java.runtime.version']
+    version        = version_string.split('.', 3)[0..1].map(&:to_i)
+    if (version <=> [1, 8]) < 0
+      deprecated <<-TXT.gsub(/^\s*\|/, '').chop, 0
+          |Java 7 is deprecated, please use Java 8.
+          |Java 7 support is only best effort, it may not work. It will be removed in next release (1.0).
+      TXT
+    end
+  end
+end

data/vendor/gems/concurrent-ruby-0.9.1-java/lib/concurrent/dataflow.rb

@@ -0,0 +1,78 @@
+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/gems/concurrent-ruby-0.9.1-java/lib/concurrent/delay.rb

@@ -0,0 +1,194 @@
+require 'thread'
+require 'concurrent/concern/obligation'
+require 'concurrent/executor/executor'
+require 'concurrent/executor/immediate_executor'
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  # 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::Object
+    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 @task_executor
+        super
+      else
+        # this function has been optimized for performance and
+        # should not be modified without running new benchmarks
+        mutex.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 @task_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 @task_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)
+      mutex.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(self)
+      set_deref_options(opts)
+      @task_executor = Executor.executor_from_options(opts)
+
+      @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
+      mutex.synchronize do
+        execute = @computing = true unless @computing
+        task    = @task
+      end
+
+      if execute
+        @task_executor.post do
+          begin
+            result  = task.call
+            success = true
+          rescue => ex
+            reason = ex
+          end
+          mutex.synchronize do
+            set_state(success, result, reason)
+            event.set
+          end
+        end
+      end
+    end
+  end
+end