logstash-output-scalyr 0.1.5 → 0.1.10.beta

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/executor/immediate_executor.rb

@@ -1,66 +0,0 @@
-require 'concurrent/atomic/event'
-require 'concurrent/executor/abstract_executor_service'
-require 'concurrent/executor/serial_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 < AbstractExecutorService
-    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/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/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/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb

@@ -1,103 +0,0 @@
-if Concurrent.on_jruby?
-
-  require 'concurrent/errors'
-  require 'concurrent/utility/engine'
-  require 'concurrent/executor/abstract_executor_service'
-
-  module Concurrent
-
-    # @!macro abstract_executor_service_public_api
-    # @!visibility private
-    class JavaExecutorService < AbstractExecutorService
-      java_import 'java.lang.Runnable'
-
-      FALLBACK_POLICY_CLASSES = {
-        abort:       java.util.concurrent.ThreadPoolExecutor::AbortPolicy,
-        discard:     java.util.concurrent.ThreadPoolExecutor::DiscardPolicy,
-        caller_runs: java.util.concurrent.ThreadPoolExecutor::CallerRunsPolicy
-      }.freeze
-      private_constant :FALLBACK_POLICY_CLASSES
-
-      def post(*args, &task)
-        raise ArgumentError.new('no block given') unless block_given?
-        return handle_fallback(*args, &task) unless running?
-        @executor.submit Job.new(args, task)
-        true
-      rescue Java::JavaUtilConcurrent::RejectedExecutionException
-        raise RejectedExecutionError
-      end
-
-      def wait_for_termination(timeout = nil)
-        if timeout.nil?
-          ok = @executor.awaitTermination(60, java.util.concurrent.TimeUnit::SECONDS) until ok
-          true
-        else
-          @executor.awaitTermination(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
-        end
-      end
-
-      def shutdown
-        synchronize do
-          @executor.shutdown
-          nil
-        end
-      end
-
-      def kill
-        synchronize do
-          @executor.shutdownNow
-          nil
-        end
-      end
-
-      private
-
-      def ns_running?
-        !(ns_shuttingdown? || ns_shutdown?)
-      end
-
-      def ns_shuttingdown?
-        if @executor.respond_to? :isTerminating
-          @executor.isTerminating
-        else
-          false
-        end
-      end
-
-      def ns_shutdown?
-        @executor.isShutdown || @executor.isTerminated
-      end
-
-      class Job
-        include Runnable
-        def initialize(args, block)
-          @args = args
-          @block = block
-        end
-
-        def run
-          @block.call(*@args)
-        end
-      end
-      private_constant :Job
-    end
-
-    class DaemonThreadFactory
-      # hide include from YARD
-      send :include, java.util.concurrent.ThreadFactory
-
-      def initialize(daemonize = true)
-        @daemonize = daemonize
-      end
-
-      def newThread(runnable)
-        thread = java.util.concurrent.Executors.defaultThreadFactory().newThread(runnable)
-        thread.setDaemon(@daemonize)
-        return thread
-      end
-    end
-
-    private_constant :DaemonThreadFactory
-
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/executor/java_single_thread_executor.rb

@@ -1,30 +0,0 @@
-if Concurrent.on_jruby?
-
-  require 'concurrent/executor/java_executor_service'
-  require 'concurrent/executor/serial_executor_service'
-
-  module Concurrent
-
-    # @!macro single_thread_executor
-    # @!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
-
-      private
-
-      def ns_initialize(opts)
-        @executor = java.util.concurrent.Executors.newSingleThreadExecutor(
-            DaemonThreadFactory.new(ns_auto_terminate?)
-        )
-        @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)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb

@@ -1,124 +0,0 @@
-if Concurrent.on_jruby?
-
-  require 'concurrent/executor/java_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
-
-      private
-
-      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, :abort)
-
-        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,
-            DaemonThreadFactory.new(ns_auto_terminate?),
-            FALLBACK_POLICY_CLASSES[@fallback_policy].new)
-
-      end
-    end
-
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb

@@ -1,76 +0,0 @@
-require 'concurrent/executor/abstract_executor_service'
-require 'concurrent/atomic/event'
-
-module Concurrent
-
-  # @!macro abstract_executor_service_public_api
-  # @!visibility private
-  class RubyExecutorService < AbstractExecutorService
-    safe_initialization!
-
-    def initialize(*args, &block)
-      super
-      @StopEvent    = Event.new
-      @StoppedEvent = Event.new
-    end
-
-    def post(*args, &task)
-      raise ArgumentError.new('no block given') unless block_given?
-      synchronize do
-        # If the executor is shut down, reject this task
-        return handle_fallback(*args, &task) unless running?
-        ns_execute(*args, &task)
-        true
-      end
-    end
-
-    def shutdown
-      synchronize do
-        break unless running?
-        stop_event.set
-        ns_shutdown_execution
-      end
-      true
-    end
-
-    def kill
-      synchronize do
-        break if shutdown?
-        stop_event.set
-        ns_kill_execution
-        stopped_event.set
-      end
-      true
-    end
-
-    def wait_for_termination(timeout = nil)
-      stopped_event.wait(timeout)
-    end
-
-    private
-
-    def stop_event
-      @StopEvent
-    end
-
-    def stopped_event
-      @StoppedEvent
-    end
-
-    def ns_shutdown_execution
-      stopped_event.set
-    end
-
-    def ns_running?
-      !stop_event.set?
-    end
-
-    def ns_shuttingdown?
-      !(ns_running? || ns_shutdown?)
-    end
-
-    def ns_shutdown?
-      stopped_event.set?
-    end
-  end
-end