logstash-codec-json 2.0.3 → 2.0.4

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

@@ -1,206 +0,0 @@
-require 'concurrent/utility/engine'
-require 'concurrent/executor/thread_pool_executor'
-
-module Concurrent
-
-  # @!macro [new] thread_pool_executor_constant_default_max_pool_size
-  #   Default maximum number of threads that will be created in the pool.
-
-  # @!macro [new] thread_pool_executor_constant_default_min_pool_size
-  #   Default minimum number of threads that will be retained in the pool.
-
-  # @!macro [new] thread_pool_executor_constant_default_max_queue_size
-  #   Default maximum number of tasks that may be added to the task queue.
-
-  # @!macro [new] thread_pool_executor_constant_default_thread_timeout
-  #   Default maximum number of seconds a thread in the pool may remain idle
-  #   before being reclaimed.
-
-  # @!macro [new] thread_pool_executor_attr_reader_max_length
-  #   The maximum number of threads that may be created in the pool.
-  #   @return [Integer] The maximum number of threads that may be created in the pool.
-
-  # @!macro [new] thread_pool_executor_attr_reader_min_length
-  #   The minimum number of threads that may be retained in the pool.
-  #   @return [Integer] The minimum number of threads that may be retained in the pool.
-
-  # @!macro [new] thread_pool_executor_attr_reader_largest_length
-  #   The largest number of threads that have been created in the pool since construction.
-  #   @return [Integer] The largest number of threads that have been created in the pool since construction.
-
-  # @!macro [new] thread_pool_executor_attr_reader_scheduled_task_count
-  #   The number of tasks that have been scheduled for execution on the pool since construction.
-  #   @return [Integer] The number of tasks that have been scheduled for execution on the pool since construction.
-
-  # @!macro [new] thread_pool_executor_attr_reader_completed_task_count
-  #   The number of tasks that have been completed by the pool since construction.
-  #   @return [Integer] The number of tasks that have been completed by the pool since construction.
-
-  # @!macro [new] thread_pool_executor_attr_reader_idletime
-  #   The number of seconds that a thread may be idle before being reclaimed.
-  #   @return [Integer] The number of seconds that a thread may be idle before being reclaimed.
-
-  # @!macro [new] thread_pool_executor_attr_reader_max_queue
-  #   The maximum number of tasks that may be waiting in the work queue at any one time.
-  #   When the queue size reaches `max_queue` subsequent tasks will be rejected in
-  #   accordance with the configured `fallback_policy`.
-  #
-  #   @return [Integer] The maximum number of tasks that may be waiting in the work queue at any one time.
-  #     When the queue size reaches `max_queue` subsequent tasks will be rejected in
-  #     accordance with the configured `fallback_policy`.
-
-  # @!macro [new] thread_pool_executor_attr_reader_length
-  #   The number of threads currently in the pool.
-  #   @return [Integer] The number of threads currently in the pool.
-
-  # @!macro [new] thread_pool_executor_attr_reader_queue_length
-  #   The number of tasks in the queue awaiting execution.
-  #   @return [Integer] The number of tasks in the queue awaiting execution.
-
-  # @!macro [new] thread_pool_executor_attr_reader_remaining_capacity
-  #   Number of tasks that may be enqueued before reaching `max_queue` and rejecting
-  #   new tasks. A value of -1 indicates that the queue may grow without bound.
-  #
-  #   @return [Integer] Number of tasks that may be enqueued before reaching `max_queue` and rejecting
-  #     new tasks. A value of -1 indicates that the queue may grow without bound.
-
-
-
-
-
-  # @!macro [new] thread_pool_executor_public_api
-  #
-  #   @!macro abstract_executor_service_public_api
-  #
-  #   @!attribute [r] max_length
-  #     @!macro thread_pool_executor_attr_reader_max_length
-  #
-  #   @!attribute [r] min_length
-  #     @!macro thread_pool_executor_attr_reader_min_length
-  #
-  #   @!attribute [r] largest_length
-  #     @!macro thread_pool_executor_attr_reader_largest_length
-  #
-  #   @!attribute [r] scheduled_task_count
-  #     @!macro thread_pool_executor_attr_reader_scheduled_task_count
-  #
-  #   @!attribute [r] completed_task_count
-  #     @!macro thread_pool_executor_attr_reader_completed_task_count
-  #
-  #   @!attribute [r] idletime
-  #     @!macro thread_pool_executor_attr_reader_idletime
-  #
-  #   @!attribute [r] max_queue
-  #     @!macro thread_pool_executor_attr_reader_max_queue
-  #
-  #   @!attribute [r] length
-  #     @!macro thread_pool_executor_attr_reader_length
-  #
-  #   @!attribute [r] queue_length
-  #     @!macro thread_pool_executor_attr_reader_queue_length
-  #
-  #   @!attribute [r] remaining_capacity
-  #     @!macro thread_pool_executor_attr_reader_remaining_capacity
-  #
-  #   @!method can_overflow?
-  #     @!macro executor_service_method_can_overflow_question
-
-
-
-
-  # @!macro [new] thread_pool_options
-  #
-  #   **Thread Pool Options**
-  #
-  #   Thread pools support several configuration options:
-  #
-  #   * `idletime`: The number of seconds that a thread may be idle before being reclaimed.
-  #   * `max_queue`: The maximum number of tasks that may be waiting in the work queue at
-  #     any one time. When the queue size reaches `max_queue` subsequent tasks will be
-  #     rejected in accordance with the configured `fallback_policy`.
-  #   * `auto_terminate`: When true (default) an `at_exit` handler will be registered which
-  #     will stop the thread pool when the application exits. See below for more information
-  #     on shutting down thread pools.
-  #   * `fallback_policy`: The policy defining how rejected tasks are handled.
-  #
-  #   Three fallback policies are supported:
-  #
-  #   * `:abort`: Raise a `RejectedExecutionError` exception and discard the task.
-  #   * `:discard`: Discard the task and return false.
-  #   * `:caller_runs`: Execute the task on the calling thread.
-  #
-  #   **Shutting Down Thread Pools**
-  #
-  #   Killing a thread pool while tasks are still being processed, either by calling
-  #   the `#kill` method or at application exit, will have unpredictable results. There
-  #   is no way for the thread pool to know what resources are being used by the
-  #   in-progress tasks. When those tasks are killed the impact on those resources
-  #   cannot be predicted. The *best* practice is to explicitly shutdown all thread
-  #   pools using the provided methods:
-  #
-  #   * Call `#shutdown` to initiate an orderly termination of all in-progress tasks
-  #   * Call `#wait_for_termination` with an appropriate timeout interval an allow
-  #     the orderly shutdown to complete
-  #   * Call `#kill` *only when* the thread pool fails to shutdown in the allotted time
-  #
-  #   On some runtime platforms (most notably the JVM) the application will not
-  #   exit until all thread pools have been shutdown. To prevent applications from
-  #   "hanging" on exit all thread pools include an `at_exit` handler that will
-  #   stop the thread pool when the application exists. This handler uses a brute
-  #   force method to stop the pool and makes no guarantees regarding resources being
-  #   used by any tasks still running. Registration of this `at_exit` handler can be
-  #   prevented by setting the thread pool's constructor `:auto_terminate` option to
-  #   `false` when the thread pool is created. All thread pools support this option.
-  #
-  #   ```ruby
-  #   pool1 = Concurrent::FixedThreadPool.new(5) # an `at_exit` handler will be registered
-  #   pool2 = Concurrent::FixedThreadPool.new(5, auto_terminate: false) # prevent `at_exit` handler registration
-  #   ```
-  #
-  #   @note Failure to properly shutdown a thread pool can lead to unpredictable results.
-  #     Please read *Shutting Down Thread Pools* for more information.
-  #
-  #   @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html Java Tutorials: Thread Pools
-  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html Java Executors class
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html Java ExecutorService interface
-  #   @see http://ruby-doc.org//core-2.2.0/Kernel.html#method-i-at_exit Kernel#at_exit
-
-
-
-
-
-  # @!macro [attach] fixed_thread_pool
-  #
-  #   A thread pool with a set number of threads. The number of threads in the pool
-  #   is set on construction and remains constant. When all threads are busy new
-  #   tasks `#post` to the thread pool are enqueued until a thread becomes available.
-  #   Should a thread crash for any reason the thread will immediately be removed
-  #   from the pool and replaced.
-  #
-  #   The API and behavior of this class are based on Java's `FixedThreadPool`
-  #
-  # @!macro thread_pool_options
-  class FixedThreadPool < ThreadPoolExecutor
-
-    # @!macro [attach] fixed_thread_pool_method_initialize
-    #
-    #   Create a new thread pool.
-    #
-    #   @param [Integer] num_threads the number of threads to allocate
-    #   @param [Hash] opts the options defining pool behavior.
-    #   @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
-    #
-    #   @raise [ArgumentError] if `num_threads` is less than or equal to zero
-    #   @raise [ArgumentError] if `fallback_policy` is not a known policy
-    #
-    #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
-    def initialize(num_threads, opts = {})
-      raise ArgumentError.new('number of threads must be greater than zero') if num_threads.to_i < 1
-      defaults  = { max_queue:   DEFAULT_MAX_QUEUE_SIZE,
-                    idletime:    DEFAULT_THREAD_IDLETIMEOUT }
-      overrides = { min_threads: num_threads,
-                    max_threads: num_threads }
-      super(defaults.merge(opts).merge(overrides))
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-require 'concurrent/atomic/event'
-require 'concurrent/executor/executor_service'
-
-module Concurrent
-
-  # An executor service which runs all operations on the current thread,
-  # blocking as necessary. Operations are performed in the order they are
-  # received and no two operations can be performed simultaneously.
-  #
-  # This executor service exists mainly for testing an debugging. When used
-  # it immediately runs every `#post` operation on the current thread, blocking
-  # that thread until the operation is complete. This can be very beneficial
-  # during testing because it makes all operations deterministic.
-  #
-  # @note Intended for use primarily in testing and debugging.
-  class ImmediateExecutor
-    include SerialExecutorService
-
-    # Creates a new executor
-    def initialize
-      @stopped = Concurrent::Event.new
-    end
-
-    # @!macro executor_service_method_post
-    def post(*args, &task)
-      raise ArgumentError.new('no block given') unless block_given?
-      return false unless running?
-      task.call(*args)
-      true
-    end
-
-    # @!macro executor_service_method_left_shift
-    def <<(task)
-      post(&task)
-      self
-    end
-
-    # @!macro executor_service_method_running_question
-    def running?
-      ! shutdown?
-    end
-
-    # @!macro executor_service_method_shuttingdown_question
-    def shuttingdown?
-      false
-    end
-
-    # @!macro executor_service_method_shutdown_question
-    def shutdown?
-      @stopped.set?
-    end
-
-    # @!macro executor_service_method_shutdown
-    def shutdown
-      @stopped.set
-      true
-    end
-    alias_method :kill, :shutdown
-
-    # @!macro executor_service_method_wait_for_termination
-    def wait_for_termination(timeout = nil)
-      @stopped.wait(timeout)
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require 'concurrent/executor/immediate_executor'
-require 'concurrent/executor/simple_executor_service'
-
-module Concurrent
-  # An executor service which runs all operations on a new thread, blocking
-  # until it completes. Operations are performed in the order they are received
-  # and no two operations can be performed simultaneously.
-  #
-  # This executor service exists mainly for testing an debugging. When used it
-  # immediately runs every `#post` operation on a new thread, blocking the
-  # current thread until the operation is complete. This is similar to how the
-  # ImmediateExecutor works, but the operation has the full stack of the new
-  # thread at its disposal. This can be helpful when the operations will spawn
-  # more operations on the same executor and so on - such a situation might
-  # overflow the single stack in case of an ImmediateExecutor, which is
-  # inconsistent with how it would behave for a threaded executor.
-  #
-  # @note Intended for use primarily in testing and debugging.
-  class IndirectImmediateExecutor < ImmediateExecutor
-    # Creates a new executor
-    def initialize
-      super
-      @internal_executor = SimpleExecutorService.new
-    end
-
-    # @!macro executor_service_method_post
-    def post(*args, &task)
-      raise ArgumentError.new("no block given") unless block_given?
-      return false unless running?
-
-      event = Concurrent::Event.new
-      @internal_executor.post do
-        begin
-          task.call(*args)
-        ensure
-          event.set
-        end
-      end
-      event.wait
-
-      true
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-if Concurrent.on_jruby?
-
-  require 'concurrent/executor/executor_service'
-
-  module Concurrent
-
-    # @!macro single_thread_executor
-    # @!macro thread_pool_options
-    # @!macro abstract_executor_service_public_api
-    # @!visibility private
-    class JavaSingleThreadExecutor < JavaExecutorService
-      include SerialExecutorService
-
-      # @!macro single_thread_executor_method_initialize
-      def initialize(opts = {})
-        super(opts)
-      end
-
-      protected
-      
-      def ns_initialize(opts)
-        @executor = java.util.concurrent.Executors.newSingleThreadExecutor
-        @fallback_policy = opts.fetch(:fallback_policy, :discard)
-        raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICY_CLASSES.keys.include?(@fallback_policy)
-        self.auto_terminate = opts.fetch(:auto_terminate, true)
-      end
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-if Concurrent.on_jruby?
-
-  require 'concurrent/executor/executor_service'
-
-  module Concurrent
-
-    # @!macro thread_pool_executor
-    # @!macro thread_pool_options
-    # @!visibility private
-    class JavaThreadPoolExecutor < JavaExecutorService
-
-      # @!macro thread_pool_executor_constant_default_max_pool_size
-      DEFAULT_MAX_POOL_SIZE = java.lang.Integer::MAX_VALUE # 2147483647
-
-      # @!macro thread_pool_executor_constant_default_min_pool_size
-      DEFAULT_MIN_POOL_SIZE = 0
-
-      # @!macro thread_pool_executor_constant_default_max_queue_size
-      DEFAULT_MAX_QUEUE_SIZE = 0
-
-      # @!macro thread_pool_executor_constant_default_thread_timeout
-      DEFAULT_THREAD_IDLETIMEOUT = 60
-
-      # @!macro thread_pool_executor_attr_reader_max_length
-      attr_reader :max_length
-
-      # @!macro thread_pool_executor_attr_reader_max_queue
-      attr_reader :max_queue
-
-      # @!macro thread_pool_executor_method_initialize
-      def initialize(opts = {})
-        super(opts)
-      end
-
-      # @!macro executor_service_method_can_overflow_question
-      def can_overflow?
-        @max_queue != 0
-      end
-
-      # @!macro thread_pool_executor_attr_reader_min_length
-      def min_length
-        @executor.getCorePoolSize
-      end
-
-      # @!macro thread_pool_executor_attr_reader_max_length
-      def max_length
-        @executor.getMaximumPoolSize
-      end
-
-      # @!macro thread_pool_executor_attr_reader_length
-      def length
-        @executor.getPoolSize
-      end
-
-      # @!macro thread_pool_executor_attr_reader_largest_length
-      def largest_length
-        @executor.getLargestPoolSize
-      end
-
-      # @!macro thread_pool_executor_attr_reader_scheduled_task_count
-      def scheduled_task_count
-        @executor.getTaskCount
-      end
-
-      # @!macro thread_pool_executor_attr_reader_completed_task_count
-      def completed_task_count
-        @executor.getCompletedTaskCount
-      end
-
-      # @!macro thread_pool_executor_attr_reader_idletime
-      def idletime
-        @executor.getKeepAliveTime(java.util.concurrent.TimeUnit::SECONDS)
-      end
-
-      # @!macro thread_pool_executor_attr_reader_queue_length
-      def queue_length
-        @executor.getQueue.size
-      end
-
-      # @!macro thread_pool_executor_attr_reader_remaining_capacity
-      def remaining_capacity
-        @max_queue == 0 ? -1 : @executor.getQueue.remainingCapacity
-      end
-
-      # @!macro executor_service_method_running_question
-      def running?
-        super && !@executor.isTerminating
-      end
-
-      protected
-
-      def ns_initialize(opts)
-        min_length = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
-        max_length = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
-        idletime = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
-        @max_queue = opts.fetch(:max_queue, DEFAULT_MAX_QUEUE_SIZE).to_i
-        @fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
-        deprecated ' :overflow_policy is deprecated terminology, please use :fallback_policy instead' if opts.has_key?(:overflow_policy)
-
-        raise ArgumentError.new("`max_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if max_length < DEFAULT_MIN_POOL_SIZE
-        raise ArgumentError.new("`max_threads` cannot be greater than #{DEFAULT_MAX_POOL_SIZE}") if max_length > DEFAULT_MAX_POOL_SIZE
-        raise ArgumentError.new("`min_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if min_length < DEFAULT_MIN_POOL_SIZE
-        raise ArgumentError.new("`min_threads` cannot be more than `max_threads`") if min_length > max_length
-        raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICY_CLASSES.include?(@fallback_policy)
-
-        if @max_queue == 0
-          queue = java.util.concurrent.LinkedBlockingQueue.new
-        else
-          queue = java.util.concurrent.LinkedBlockingQueue.new(@max_queue)
-        end
-
-        @executor = java.util.concurrent.ThreadPoolExecutor.new(
-          min_length, max_length,
-          idletime, java.util.concurrent.TimeUnit::SECONDS,
-          queue, FALLBACK_POLICY_CLASSES[@fallback_policy].new)
-
-        self.auto_terminate = opts.fetch(:auto_terminate, true)
-      end
-    end
-  end
-end