logstash-input-beats 0.9 → 0.9.1

data/vendor/jruby/1.9/gems/concurrent-ruby-0.9.1-java/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -0,0 +1,28 @@
+module Concurrent
+
+  # Special "compare and set" handling of numeric values.
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
+  module AtomicNumericCompareAndSetWrapper
+
+    # @!macro atomic_reference_method_compare_and_set
+    def compare_and_set(old_value, new_value)
+      if old_value.kind_of? Numeric
+        while true
+          old = get
+
+          return false unless old.kind_of? Numeric
+
+          return false unless old == old_value
+
+          result = _compare_and_set(old, new_value)
+          return result if result
+        end
+      else
+        _compare_and_set(old_value, new_value)
+      end
+    end
+    alias_method :compare_and_swap, :compare_and_set
+  end
+end

data/vendor/jruby/1.9/gems/concurrent-ruby-0.9.1-java/lib/concurrent/atomic_reference/rbx.rb

@@ -0,0 +1,22 @@
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+
+  # @!macro atomic_reference
+  #
+  # @note Extends `Rubinius::AtomicReference` version adding aliases
+  #   and numeric logic.
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class RbxAtomicReference < Rubinius::AtomicReference
+    alias _compare_and_set compare_and_set
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
+    alias_method :value, :get
+    alias_method :value=, :set
+    alias_method :swap, :get_and_set
+  end
+end

data/vendor/jruby/1.9/gems/concurrent-ruby-0.9.1-java/lib/concurrent/atomic_reference/ruby.rb

@@ -0,0 +1,32 @@
+if defined? Concurrent::CAtomicReference
+  require 'concurrent/utility/native_extension_loader'
+  require 'concurrent/atomic_reference/direct_update'
+  require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+  module Concurrent
+
+    # @!macro atomic_reference
+    #
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class CAtomicReference
+      include Concurrent::AtomicDirectUpdate
+      include Concurrent::AtomicNumericCompareAndSetWrapper
+
+      # @!method initialize
+      #   @!macro atomic_reference_method_initialize
+
+      # @!method get
+      #   @!macro atomic_reference_method_get
+
+      # @!method set
+      #   @!macro atomic_reference_method_set
+
+      # @!method get_and_set
+      #   @!macro atomic_reference_method_get_and_set
+
+      # @!method _compare_and_set
+      #   @!macro atomic_reference_method_compare_and_set
+    end
+  end
+end

data/vendor/jruby/1.9/gems/concurrent-ruby-0.9.1-java/lib/concurrent/atomics.rb

@@ -0,0 +1,82 @@
+# @!macro [new] atomic_reference
+#
+#   An object reference that may be updated atomically.
+#
+#       Testing with ruby 2.1.2
+#       
+#       *** Sequential updates ***
+#                                 user     system      total        real
+#       no lock               0.000000   0.000000   0.000000 (  0.005502)
+#       mutex                 0.030000   0.000000   0.030000 (  0.025158)
+#       MutexAtomicReference  0.100000   0.000000   0.100000 (  0.103096)
+#       CAtomicReference      0.040000   0.000000   0.040000 (  0.034012)
+#       
+#       *** Parallel updates ***
+#                                 user     system      total        real
+#       no lock               0.010000   0.000000   0.010000 (  0.009387)
+#       mutex                 0.030000   0.010000   0.040000 (  0.032545)
+#       MutexAtomicReference  0.830000   2.280000   3.110000 (  2.146622)
+#       CAtomicReference      0.040000   0.000000   0.040000 (  0.038332)
+#
+#       Testing with jruby 1.9.3
+#       
+#       *** Sequential updates ***
+#                                 user     system      total        real
+#       no lock               0.170000   0.000000   0.170000 (  0.051000)
+#       mutex                 0.370000   0.010000   0.380000 (  0.121000)
+#       MutexAtomicReference  1.530000   0.020000   1.550000 (  0.471000)
+#       JavaAtomicReference   0.370000   0.010000   0.380000 (  0.112000)
+#       
+#       *** Parallel updates ***
+#                                 user     system      total        real
+#       no lock               0.390000   0.000000   0.390000 (  0.105000)
+#       mutex                 0.480000   0.040000   0.520000 (  0.145000)
+#       MutexAtomicReference  1.600000   0.180000   1.780000 (  0.511000)
+#       JavaAtomicReference   0.460000   0.010000   0.470000 (  0.131000)
+#
+#   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
+#   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
+#
+#   @!method initialize
+#     @!macro [new] atomic_reference_method_initialize
+#       @param [Object] value The initial value.
+#   
+#   @!method get
+#     @!macro [new] atomic_reference_method_get
+#       Gets the current value.
+#       @return [Object] the current value
+#   
+#   @!method set
+#     @!macro [new] atomic_reference_method_set
+#       Sets to the given value.
+#       @param [Object] new_value the new value
+#       @return [Object] the new value
+#   
+#   @!method get_and_set
+#     @!macro [new] atomic_reference_method_get_and_set
+#       Atomically sets to the given value and returns the old value.
+#       @param [Object] new_value the new value
+#       @return [Object] the old value
+#   
+#   @!method compare_and_set
+#     @!macro [new] atomic_reference_method_compare_and_set
+#
+#       Atomically sets the value to the given updated value if
+#       the current value == the expected value.
+#
+#       @param [Object] old_value the expected value
+#       @param [Object] new_value the new value
+#
+#       @return [Boolean] `true` if successful. A `false` return indicates
+#       that the actual value was not equal to the expected value.
+
+require 'concurrent/atomic/atomic_reference'
+require 'concurrent/atomic/atomic_boolean'
+require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/condition'
+require 'concurrent/atomic/cyclic_barrier'
+require 'concurrent/atomic/count_down_latch'
+require 'concurrent/atomic/event'
+require 'concurrent/atomic/read_write_lock'
+require 'concurrent/atomic/semaphore'
+require 'concurrent/atomic/thread_local_var'

data/vendor/jruby/1.9/gems/concurrent-ruby-0.9.1-java/lib/concurrent/collection/copy_on_notify_observer_set.rb

@@ -0,0 +1,115 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+  module Collection
+
+    # A thread safe observer set implemented using copy-on-read approach:
+    # observers are added and removed from a thread safe collection; every time
+    # a notification is required the internal data structure is copied to
+    # prevent concurrency issues
+    # 
+    # @api private
+    class CopyOnNotifyObserverSet < Synchronization::Object
+
+      def initialize
+        super()
+        synchronize { ns_initialize }
+      end
+
+      # Adds an observer to this set. If a block is passed, the observer will be
+      # created by this method and no other params should be passed
+      #
+      # @param [Object] observer the observer to add
+      # @param [Symbol] func the function to call on the observer during notification.
+      #   Default is :update
+      # @return [Object] the added observer
+      def add_observer(observer=nil, func=:update, &block)
+        if observer.nil? && block.nil?
+          raise ArgumentError, 'should pass observer as a first argument or block'
+        elsif observer && block
+          raise ArgumentError.new('cannot provide both an observer and a block')
+        end
+
+        if block
+          observer = block
+          func     = :call
+        end
+
+        synchronize do
+          @observers[observer] = func
+          observer
+        end
+      end
+
+      # @param [Object] observer the observer to remove
+      # @return [Object] the deleted observer
+      def delete_observer(observer)
+        synchronize do
+          @observers.delete(observer)
+          observer
+        end
+      end
+
+      # Deletes all observers
+      # @return [CopyOnWriteObserverSet] self
+      def delete_observers
+        synchronize do
+          @observers.clear
+          self
+        end
+      end
+
+      # @return [Integer] the observers count
+      def count_observers
+        synchronize { @observers.count }
+      end
+
+      # Notifies all registered observers with optional args
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_observers(*args, &block)
+        observers = duplicate_observers
+        notify_to(observers, *args, &block)
+        self
+      end
+
+      # Notifies all registered observers with optional args and deletes them.
+      #
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_and_delete_observers(*args, &block)
+        observers = duplicate_and_clear_observers
+        notify_to(observers, *args, &block)
+        self
+      end
+
+      protected
+
+      def ns_initialize
+        @observers = {}
+      end
+
+      private
+
+      def duplicate_and_clear_observers
+        synchronize do
+          observers = @observers.dup
+          @observers.clear
+          observers
+        end
+      end
+
+      def duplicate_observers
+        synchronize { @observers.dup }
+      end
+
+      def notify_to(observers, *args)
+        raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+        observers.each do |observer, function|
+          args = yield if block_given?
+          observer.send(function, *args)
+        end
+      end
+    end
+  end
+end

data/vendor/jruby/1.9/gems/concurrent-ruby-0.9.1-java/lib/concurrent/collection/copy_on_write_observer_set.rb

@@ -0,0 +1,119 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+  module Collection
+
+    # A thread safe observer set implemented using copy-on-write approach:
+    # every time an observer is added or removed the whole internal data structure is
+    # duplicated and replaced with a new one.
+    # 
+    # @api private
+    class CopyOnWriteObserverSet < Synchronization::Object
+
+      def initialize
+        super()
+        synchronize { ns_initialize }
+      end
+
+      # Adds an observer to this set
+      # If a block is passed, the observer will be created by this method and no
+      #   other params should be passed
+      # @param [Object] observer the observer to add
+      # @param [Symbol] func the function to call on the observer during notification.
+      #   Default is :update
+      # @return [Object] the added observer
+      def add_observer(observer=nil, func=:update, &block)
+        if observer.nil? && block.nil?
+          raise ArgumentError, 'should pass observer as a first argument or block'
+        elsif observer && block
+          raise ArgumentError.new('cannot provide both an observer and a block')
+        end
+
+        if block
+          observer = block
+          func = :call
+        end
+
+        synchronize do
+          new_observers = @observers.dup
+          new_observers[observer] = func
+          @observers = new_observers
+          observer
+        end
+      end
+
+      # @param [Object] observer the observer to remove
+      # @return [Object] the deleted observer
+      def delete_observer(observer)
+        synchronize do
+          new_observers = @observers.dup
+          new_observers.delete(observer)
+          @observers = new_observers
+          observer
+        end
+      end
+
+      # Deletes all observers
+      # @return [CopyOnWriteObserverSet] self
+      def delete_observers
+        self.observers = {}
+        self
+      end
+
+      # @return [Integer] the observers count
+      def count_observers
+        observers.count
+      end
+
+      # Notifies all registered observers with optional args
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_observers(*args, &block)
+        notify_to(observers, *args, &block)
+        self
+      end
+
+      # Notifies all registered observers with optional args and deletes them.
+      #
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_and_delete_observers(*args, &block)
+        old = clear_observers_and_return_old
+        notify_to(old, *args, &block)
+        self
+      end
+
+      protected
+
+      def ns_initialize
+        @observers = {}
+      end
+
+      private
+
+      def notify_to(observers, *args)
+        raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+        observers.each do |observer, function|
+          args = yield if block_given?
+          observer.send(function, *args)
+        end
+      end
+
+      def observers
+        synchronize { @observers }
+      end
+
+      def observers=(new_set)
+        synchronize { @observers = new_set }
+      end
+
+      def clear_observers_and_return_old
+        synchronize do
+          old_observers = @observers
+          @observers = {}
+          old_observers
+        end
+      end
+    end
+  end
+end

data/vendor/jruby/1.9/gems/concurrent-ruby-0.9.1-java/lib/concurrent/collection/priority_queue.rb

@@ -0,0 +1,360 @@
+module Concurrent
+  module Collection
+
+    # @!macro [attach] priority_queue
+    #
+    #   A queue collection in which the elements are sorted based on their
+    #   comparison (spaceship) operator `<=>`. Items are added to the queue
+    #   at a position relative to their priority. On removal the element
+    #   with the "highest" priority is removed. By default the sort order is
+    #   from highest to lowest, but a lowest-to-highest sort order can be
+    #   set on construction.
+    #
+    #   The API is based on the `Queue` class from the Ruby standard library.
+    #
+    #   The pure Ruby implementation, `MutexPriorityQueue` uses a heap algorithm
+    #   stored in an array. The algorithm is based on the work of Robert Sedgewick
+    #   and Kevin Wayne.
+    #
+    #   The JRuby native implementation is a thin wrapper around the standard
+    #   library `java.util.PriorityQueue`.
+    #
+    #   When running under JRuby the class `PriorityQueue` extends `JavaPriorityQueue`.
+    #   When running under all other interpreters it extends `MutexPriorityQueue`.
+    #
+    #   @note This implementation is *not* thread safe.
+    #
+    #   @see http://en.wikipedia.org/wiki/Priority_queue
+    #   @see http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html
+    #
+    #   @see http://algs4.cs.princeton.edu/24pq/index.php#2.6
+    #   @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
+    #
+    #   @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
+    # 
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MutexPriorityQueue
+
+      # @!macro [attach] priority_queue_method_initialize
+      #
+      #   Create a new priority queue with no items.
+      #  
+      #   @param [Hash] opts the options for creating the queue
+      #   @option opts [Symbol] :order (:max) dictates the order in which items are
+      #     stored: from highest to lowest when `:max` or `:high`; from lowest to
+      #     highest when `:min` or `:low`
+      def initialize(opts = {})
+        order = opts.fetch(:order, :max)
+        @comparator = [:min, :low].include?(order) ? -1 : 1
+        clear
+      end
+
+      # @!macro [attach] priority_queue_method_clear
+      #
+      #   Removes all of the elements from this priority queue.
+      def clear
+        @queue = [nil]
+        @length = 0
+        true
+      end
+
+      # @!macro [attach] priority_queue_method_delete
+      #
+      #   Deletes all items from `self` that are equal to `item`.
+      #  
+      #   @param [Object] item the item to be removed from the queue
+      #   @return [Object] true if the item is found else false
+      def delete(item)
+        original_length = @length
+        k = 1
+        while k <= @length
+          if @queue[k] == item
+            swap(k, @length)
+            @length -= 1
+            sink(k)
+            @queue.pop
+          else
+            k += 1
+          end
+        end
+        @length != original_length
+      end
+
+      # @!macro [attach] priority_queue_method_empty
+      #  
+      #   Returns `true` if `self` contains no elements.
+      #  
+      #   @return [Boolean] true if there are no items in the queue else false
+      def empty?
+        size == 0
+      end
+
+      # @!macro [attach] priority_queue_method_include
+      #
+      #   Returns `true` if the given item is present in `self` (that is, if any
+      #   element == `item`), otherwise returns false.
+      #  
+      #   @param [Object] item the item to search for
+      #  
+      #   @return [Boolean] true if the item is found else false
+      def include?(item)
+        @queue.include?(item)
+      end
+      alias_method :has_priority?, :include?
+
+      # @!macro [attach] priority_queue_method_length
+      #  
+      #   The current length of the queue.
+      #  
+      #   @return [Fixnum] the number of items in the queue
+      def length
+        @length
+      end
+      alias_method :size, :length
+
+      # @!macro [attach] priority_queue_method_peek
+      #  
+      #   Retrieves, but does not remove, the head of this queue, or returns `nil`
+      #   if this queue is empty.
+      #   
+      #   @return [Object] the head of the queue or `nil` when empty
+      def peek
+        @queue[1]
+      end
+
+      # @!macro [attach] priority_queue_method_pop
+      #  
+      #   Retrieves and removes the head of this queue, or returns `nil` if this
+      #   queue is empty.
+      #   
+      #   @return [Object] the head of the queue or `nil` when empty
+      def pop
+        max = @queue[1]
+        swap(1, @length)
+        @length -= 1
+        sink(1)
+        @queue.pop
+        max
+      end
+      alias_method :deq, :pop
+      alias_method :shift, :pop
+
+      # @!macro [attach] priority_queue_method_push
+      #  
+      #   Inserts the specified element into this priority queue.
+      #  
+      #   @param [Object] item the item to insert onto the queue
+      def push(item)
+        @length += 1
+        @queue << item
+        swim(@length)
+        true
+      end
+      alias_method :<<, :push
+      alias_method :enq, :push
+
+      # @!macro [attach] priority_queue_method_from_list
+      #  
+      #   Create a new priority queue from the given list.
+      #  
+      #   @param [Enumerable] list the list to build the queue from
+      #   @param [Hash] opts the options for creating the queue
+      #  
+      #   @return [PriorityQueue] the newly created and populated queue
+      def self.from_list(list, opts = {})
+        queue = new(opts)
+        list.each{|item| queue << item }
+        queue
+      end
+
+      protected
+
+      # Exchange the values at the given indexes within the internal array.
+      # 
+      # @param [Integer] x the first index to swap
+      # @param [Integer] y the second index to swap
+      # 
+      # @!visibility private
+      def swap(x, y)
+        temp = @queue[x]
+        @queue[x] = @queue[y]
+        @queue[y] = temp
+      end
+
+      # Are the items at the given indexes ordered based on the priority
+      # order specified at construction?
+      #
+      # @param [Integer] x the first index from which to retrieve a comparable value
+      # @param [Integer] y the second index from which to retrieve a comparable value
+      #
+      # @return [Boolean] true if the two elements are in the correct priority order
+      #   else false
+      # 
+      # @!visibility private
+      def ordered?(x, y)
+        (@queue[x] <=> @queue[y]) == @comparator
+      end
+
+      # Percolate down to maintain heap invariant.
+      # 
+      # @param [Integer] k the index at which to start the percolation
+      # 
+      # @!visibility private
+      def sink(k)
+        while (j = (2 * k)) <= @length do
+          j += 1 if j < @length && ! ordered?(j, j+1)
+          break if ordered?(k, j)
+          swap(k, j)
+          k = j
+        end
+      end
+
+      # Percolate up to maintain heap invariant.
+      # 
+      # @param [Integer] k the index at which to start the percolation
+      # 
+      # @!visibility private
+      def swim(k)
+        while k > 1 && ! ordered?(k/2, k) do
+          swap(k, k/2)
+          k = k/2
+        end
+      end
+    end
+
+    if Concurrent.on_jruby?
+
+      # @!macro priority_queue
+      # 
+      # @!visibility private
+      # @!macro internal_implementation_note
+      class JavaPriorityQueue
+
+        # @!macro priority_queue_method_initialize
+        def initialize(opts = {})
+          order = opts.fetch(:order, :max)
+          if [:min, :low].include?(order)
+            @queue = java.util.PriorityQueue.new(11) # 11 is the default initial capacity
+          else
+            @queue = java.util.PriorityQueue.new(11, java.util.Collections.reverseOrder())
+          end
+        end
+
+        # @!macro priority_queue_method_clear
+        def clear
+          @queue.clear
+          true
+        end
+
+        # @!macro priority_queue_method_delete
+        def delete(item)
+          found = false
+          while @queue.remove(item) do
+            found = true
+          end
+          found
+        end
+
+        # @!macro priority_queue_method_empty
+        def empty?
+          @queue.size == 0
+        end
+
+        # @!macro priority_queue_method_include
+        def include?(item)
+          @queue.contains(item)
+        end
+        alias_method :has_priority?, :include?
+
+        # @!macro priority_queue_method_length
+        def length
+          @queue.size
+        end
+        alias_method :size, :length
+
+        # @!macro priority_queue_method_peek
+        def peek
+          @queue.peek
+        end
+
+        # @!macro priority_queue_method_pop
+        def pop
+          @queue.poll
+        end
+        alias_method :deq, :pop
+        alias_method :shift, :pop
+
+        # @!macro priority_queue_method_push
+        def push(item)
+          @queue.add(item)
+        end
+        alias_method :<<, :push
+        alias_method :enq, :push
+
+        # @!macro priority_queue_method_from_list
+        def self.from_list(list, opts = {})
+          queue = new(opts)
+          list.each{|item| queue << item }
+          queue
+        end
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    PriorityQueueImplementation = case
+                                  when Concurrent.on_jruby?
+                                    JavaPriorityQueue
+                                  else
+                                    MutexPriorityQueue
+                                  end
+    private_constant :PriorityQueueImplementation
+
+    # @!macro priority_queue
+    # 
+    # @!visibility private
+    class PriorityQueue < PriorityQueueImplementation
+
+      alias_method :has_priority?, :include?
+
+      alias_method :size, :length
+
+      alias_method :deq, :pop
+      alias_method :shift, :pop
+
+      alias_method :<<, :push
+      alias_method :enq, :push
+
+      # @!method initialize(opts = {})
+      #   @!macro priority_queue_method_initialize
+
+      # @!method clear
+      #   @!macro priority_queue_method_clear
+
+      # @!method delete(item)
+      #   @!macro priority_queue_method_delete
+
+      # @!method empty?
+      #   @!macro priority_queue_method_empty
+
+      # @!method include?(item)
+      #   @!macro priority_queue_method_include
+
+      # @!method length
+      #   @!macro priority_queue_method_length
+
+      # @!method peek
+      #   @!macro priority_queue_method_peek
+
+      # @!method pop
+      #   @!macro priority_queue_method_pop
+
+      # @!method push(item)
+      #   @!macro priority_queue_method_push
+
+      # @!method self.from_list(list, opts = {})
+      #   @!macro priority_queue_method_from_list
+    end
+  end
+end