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/synchronization/lock.rb

@@ -1,33 +0,0 @@
-module Concurrent
-  module Synchronization
-    class Lock < LockableObject
-      # TODO use JavaReentrantLock on JRuby
-
-      public :synchronize
-
-      def wait(timeout = nil)
-        synchronize { ns_wait(timeout) }
-      end
-
-      public :ns_wait
-
-      def wait_until(timeout = nil, &condition)
-        synchronize { ns_wait_until(timeout, &condition) }
-      end
-
-      public :ns_wait_until
-
-      def signal
-        synchronize { ns_signal }
-      end
-
-      public :ns_signal
-
-      def broadcast
-        synchronize { ns_broadcast }
-      end
-
-      public :ns_broadcast
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    LockableObjectImplementation = case
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:<=, 1, 9, 3)
-                                     MriMonitorLockableObject
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:>, 1, 9, 3)
-                                     MriMutexLockableObject
-                                   when Concurrent.on_jruby?
-                                     JRubyLockableObject
-                                   when Concurrent.on_rbx? || Concurrent.on_truffle?
-                                     RbxLockableObject
-                                   else
-                                     warn 'Possibly unsupported Ruby implementation'
-                                     MriMonitorLockableObject
-                                   end
-    private_constant :LockableObjectImplementation
-
-    #   Safe synchronization under any Ruby implementation.
-    #   It provides methods like {#synchronize}, {#wait}, {#signal} and {#broadcast}.
-    #   Provides a single layer which can improve its implementation over time without changes needed to
-    #   the classes using it. Use {Synchronization::Object} not this abstract class.
-    #
-    #   @note this object does not support usage together with
-    #     [`Thread#wakeup`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-wakeup)
-    #     and [`Thread#raise`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-raise).
-    #     `Thread#sleep` and `Thread#wakeup` will work as expected but mixing `Synchronization::Object#wait` and
-    #     `Thread#wakeup` will not work on all platforms.
-    #
-    #   @see {Event} implementation as an example of this class use
-    #
-    #   @example simple
-    #     class AnClass < Synchronization::Object
-    #       def initialize
-    #         super
-    #         synchronize { @value = 'asd' }
-    #       end
-    #
-    #       def value
-    #         synchronize { @value }
-    #       end
-    #     end
-    #
-    # @!visibility private
-    class LockableObject < LockableObjectImplementation
-
-      # TODO (pitr 12-Sep-2015): make private for c-r, prohibit subclassing
-      # TODO (pitr 12-Sep-2015): we inherit too much ourselves :/
-
-      # @!method initialize(*args, &block)
-      #   @!macro synchronization_object_method_initialize
-
-      # @!method synchronize
-      #   @!macro synchronization_object_method_synchronize
-
-      # @!method wait_until(timeout = nil, &condition)
-      #   @!macro synchronization_object_method_ns_wait_until
-
-      # @!method wait(timeout = nil)
-      #   @!macro synchronization_object_method_ns_wait
-
-      # @!method signal
-      #   @!macro synchronization_object_method_ns_signal
-
-      # @!method broadcast
-      #   @!macro synchronization_object_method_ns_broadcast
-
-    end
-  end
-end

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

@@ -1,150 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    ObjectImplementation = case
-                           when Concurrent.on_cruby?
-                             MriObject
-                           when Concurrent.on_jruby?
-                             JRubyObject
-                           when Concurrent.on_rbx? || Concurrent.on_truffle?
-                             RbxObject
-                           else
-                             MriObject
-                           end
-    private_constant :ObjectImplementation
-
-    # Abstract object providing final, volatile, ans CAS extensions to build other concurrent abstractions.
-    # - final instance variables see {Object.safe_initialization!}
-    # - volatile instance variables see {Object.attr_volatile}
-    # - volatile instance variables see {Object.attr_atomic}
-    class Object < ObjectImplementation
-
-      # @!method self.attr_volatile(*names)
-      #   Creates methods for reading and writing (as `attr_accessor` does) to a instance variable with
-      #   volatile (Java) semantic. The instance variable should be accessed oly through generated methods.
-      #
-      #   @param [Array<Symbol>] names of the instance variables to be volatile
-      #   @return [Array<Symbol>] names of defined method names
-
-      # Has to be called by children.
-      def initialize
-        super
-        initialize_volatile_with_cas
-      end
-
-      # By calling this method on a class, it and all its children are marked to be constructed safely. Meaning that
-      # all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
-      # same behaviour as Java's final fields.
-      # @example
-      #   class AClass < Concurrent::Synchronization::Object
-      #     safe_initialization!
-      #
-      #     def initialize
-      #       @AFinalValue = 'value' # published safely, does not have to be synchronized
-      #     end
-      #   end
-      def self.safe_initialization!
-        # define only once, and not again in children
-        return if safe_initialization?
-
-        def self.new(*)
-          object = super
-        ensure
-          object.full_memory_barrier if object
-        end
-
-        @safe_initialization = true
-      end
-
-      # @return [true, false] if this class is safely initialized.
-      def self.safe_initialization?
-        @safe_initialization = false unless defined? @safe_initialization
-        @safe_initialization || (superclass.respond_to?(:safe_initialization?) && superclass.safe_initialization?)
-      end
-
-      # For testing purposes, quite slow. Injects assert code to new method which will raise if class instance contains
-      # any instance variables with CamelCase names and isn't {.safe_initialization?}.
-      def self.ensure_safe_initialization_when_final_fields_are_present
-        Object.class_eval do
-          def self.new(*)
-            object = super
-          ensure
-            has_final_field = object.instance_variables.any? { |v| v.to_s =~ /^@[A-Z]/ }
-            if has_final_field && !safe_initialization?
-              raise "there was an instance of #{object.class} with final field but not marked with safe_initialization!"
-            end
-          end
-        end
-      end
-
-      # Creates methods for reading and writing to a instance variable with
-      # volatile (Java) semantic as {.attr_volatile} does.
-      # The instance variable should be accessed oly through generated methods.
-      # This method generates following methods: `value`, `value=(new_value) #=> new_value`,
-      # `swap_value(new_value) #=> old_value`,
-      # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.
-      # @param [Array<Symbol>] names of the instance variables to be volatile with CAS.
-      # @return [Array<Symbol>] names of defined method names.
-      def self.attr_atomic(*names)
-        @volatile_cas_fields ||= []
-        @volatile_cas_fields += names
-        safe_initialization!
-        define_initialize_volatile_with_cas
-
-        names.each do |name|
-          ivar = :"@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }}"
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{name}
-              #{ivar}.get
-            end
-
-            def #{name}=(value)
-              #{ivar}.set value
-            end
-
-            def swap_#{name}(value)
-              #{ivar}.swap value
-            end
-
-            def compare_and_set_#{name}(expected, value)
-              #{ivar}.compare_and_set expected, value
-            end
-
-            def update_#{name}(&block)
-              #{ivar}.update(&block)
-            end
-          RUBY
-        end
-        names.flat_map { |n| [n, :"#{n}=", :"swap_#{n}", :"compare_and_set_#{n}", :"update_#{n}"] }
-      end
-
-      # @param [true,false] inherited should inherited volatile with CAS fields be returned?
-      # @return [Array<Symbol>] Returns defined volatile with CAS fields on this class.
-      def self.volatile_cas_fields(inherited = true)
-        @volatile_cas_fields ||= []
-        ((superclass.volatile_cas_fields if superclass.respond_to?(:volatile_cas_fields) && inherited) || []) +
-            @volatile_cas_fields
-      end
-
-      private
-
-      def self.define_initialize_volatile_with_cas
-        assignments = @volatile_cas_fields.map { |name| "@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = AtomicReference.new(nil)" }.join("\n")
-        class_eval <<-RUBY
-          def initialize_volatile_with_cas
-            super
-            #{assignments}
-          end
-        RUBY
-      end
-
-      private_class_method :define_initialize_volatile_with_cas
-
-      def initialize_volatile_with_cas
-      end
-
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    module RbxAttrVolatile
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def attr_volatile(*names)
-          names.each do |name|
-            ivar = :"@volatile_#{name}"
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}
-                Rubinius.memory_barrier
-                #{ivar}
-              end
-
-              def #{name}=(value)
-                #{ivar} = value
-                Rubinius.memory_barrier
-              end
-            RUBY
-          end
-          names.map { |n| [n, :"#{n}="] }.flatten
-        end
-      end
-
-      def full_memory_barrier
-        # Rubinius instance variables are not volatile so we need to insert barrier
-        Rubinius.memory_barrier
-      end
-    end
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class RbxObject < AbstractObject
-      include RbxAttrVolatile
-
-      def initialize
-        # nothing to do
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Concurrent
-
-  # @!visibility private
-  module ThreadSafe
-
-    # @!visibility private
-    module Util
-
-      FIXNUM_BIT_SIZE = (0.size * 8) - 2
-      MAX_INT         = (2 ** FIXNUM_BIT_SIZE) - 1
-      CPU_COUNT       = 16 # is there a way to determine this?
-    end
-  end
-end

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

@@ -1,329 +0,0 @@
-require 'concurrent/collection/copy_on_notify_observer_set'
-require 'concurrent/concern/dereferenceable'
-require 'concurrent/concern/observable'
-require 'concurrent/atomic/atomic_boolean'
-require 'concurrent/executor/executor_service'
-require 'concurrent/executor/safe_task_executor'
-
-module Concurrent
-
-  # A very common currency pattern is to run a thread that performs a task at
-  # regular intervals. The thread that performs the task sleeps for the given
-  # interval then wakes up and performs the task. Lather, rinse, repeat... This
-  # pattern causes two problems. First, it is difficult to test the business
-  # logic of the task because the task itself is tightly coupled with the
-  # concurrency logic. Second, an exception raised while performing the task can
-  # cause the entire thread to abend. In a long-running application where the
-  # task thread is intended to run for days/weeks/years a crashed task thread
-  # can pose a significant problem. `TimerTask` alleviates both problems.
-  #
-  # When a `TimerTask` is launched it starts a thread for monitoring the
-  # execution interval. The `TimerTask` thread does not perform the task,
-  # however. Instead, the TimerTask launches the task on a separate thread.
-  # Should the task experience an unrecoverable crash only the task thread will
-  # crash. This makes the `TimerTask` very fault tolerant Additionally, the
-  # `TimerTask` thread can respond to the success or failure of the task,
-  # performing logging or ancillary operations. `TimerTask` can also be
-  # configured with a timeout value allowing it to kill a task that runs too
-  # long.
-  #
-  # One other advantage of `TimerTask` is that it forces the business logic to
-  # be completely decoupled from the concurrency logic. The business logic can
-  # be tested separately then passed to the `TimerTask` for scheduling and
-  # running.
-  #
-  # In some cases it may be necessary for a `TimerTask` to affect its own
-  # execution cycle. To facilitate this, a reference to the TimerTask instance
-  # is passed as an argument to the provided block every time the task is
-  # executed.
-  #
-  # The `TimerTask` class includes the `Dereferenceable` mixin module so the
-  # result of the last execution is always available via the `#value` method.
-  # Derefencing options can be passed to the `TimerTask` during construction or
-  # at any later time using the `#set_deref_options` method.
-  #
-  # `TimerTask` supports notification through the Ruby standard library
-  # {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
-  # Observable} module. On execution the `TimerTask` will notify the observers
-  # with three arguments: time of execution, the result of the block (or nil on
-  # failure), and any raised exceptions (or nil on success). If the timeout
-  # interval is exceeded the observer will receive a `Concurrent::TimeoutError`
-  # object as the third argument.
-  #
-  # @!macro copy_options
-  #
-  # @example Basic usage
-  #   task = Concurrent::TimerTask.new{ puts 'Boom!' }
-  #   task.execute
-  #
-  #   task.execution_interval #=> 60 (default)
-  #   task.timeout_interval   #=> 30 (default)
-  #
-  #   # wait 60 seconds...
-  #   #=> 'Boom!'
-  #
-  #   task.shutdown #=> true
-  #
-  # @example Configuring `:execution_interval` and `:timeout_interval`
-  #   task = Concurrent::TimerTask.new(execution_interval: 5, timeout_interval: 5) do
-  #          puts 'Boom!'
-  #        end
-  #
-  #   task.execution_interval #=> 5
-  #   task.timeout_interval   #=> 5
-  #
-  # @example Immediate execution with `:run_now`
-  #   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
-  #   task.execute
-  #
-  #   #=> 'Boom!'
-  #
-  # @example Last `#value` and `Dereferenceable` mixin
-  #   task = Concurrent::TimerTask.new(
-  #     dup_on_deref: true,
-  #     execution_interval: 5
-  #   ){ Time.now }
-  #
-  #   task.execute
-  #   Time.now   #=> 2013-11-07 18:06:50 -0500
-  #   sleep(10)
-  #   task.value #=> 2013-11-07 18:06:55 -0500
-  #
-  # @example Controlling execution from within the block
-  #   timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
-  #     task.execution_interval.times{ print 'Boom! ' }
-  #     print "\n"
-  #     task.execution_interval += 1
-  #     if task.execution_interval > 5
-  #       puts 'Stopping...'
-  #       task.shutdown
-  #     end
-  #   end
-  #
-  #   timer_task.execute # blocking call - this task will stop itself
-  #   #=> Boom!
-  #   #=> Boom! Boom!
-  #   #=> Boom! Boom! Boom!
-  #   #=> Boom! Boom! Boom! Boom!
-  #   #=> Boom! Boom! Boom! Boom! Boom!
-  #   #=> Stopping...
-  #
-  # @example Observation
-  #   class TaskObserver
-  #     def update(time, result, ex)
-  #       if result
-  #         print "(#{time}) Execution successfully returned #{result}\n"
-  #       elsif ex.is_a?(Concurrent::TimeoutError)
-  #         print "(#{time}) Execution timed out\n"
-  #       else
-  #         print "(#{time}) Execution failed with error #{ex}\n"
-  #       end
-  #     end
-  #   end
-  #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ 42 }
-  #   task.add_observer(TaskObserver.new)
-  #   task.execute
-  #
-  #   #=> (2013-10-13 19:08:58 -0400) Execution successfully returned 42
-  #   #=> (2013-10-13 19:08:59 -0400) Execution successfully returned 42
-  #   #=> (2013-10-13 19:09:00 -0400) Execution successfully returned 42
-  #   task.shutdown
-  #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ sleep }
-  #   task.add_observer(TaskObserver.new)
-  #   task.execute
-  #
-  #   #=> (2013-10-13 19:07:25 -0400) Execution timed out
-  #   #=> (2013-10-13 19:07:27 -0400) Execution timed out
-  #   #=> (2013-10-13 19:07:29 -0400) Execution timed out
-  #   task.shutdown
-  #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1){ raise StandardError }
-  #   task.add_observer(TaskObserver.new)
-  #   task.execute
-  #
-  #   #=> (2013-10-13 19:09:37 -0400) Execution failed with error StandardError
-  #   #=> (2013-10-13 19:09:38 -0400) Execution failed with error StandardError
-  #   #=> (2013-10-13 19:09:39 -0400) Execution failed with error StandardError
-  #   task.shutdown
-  #
-  # @see http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
-  # @see http://docs.oracle.com/javase/7/docs/api/java/util/TimerTask.html
-  class TimerTask < RubyExecutorService
-    include Concern::Dereferenceable
-    include Concern::Observable
-
-    # Default `:execution_interval` in seconds.
-    EXECUTION_INTERVAL = 60
-
-    # Default `:timeout_interval` in seconds.
-    TIMEOUT_INTERVAL = 30
-
-    # Create a new TimerTask with the given task and configuration.
-    #
-    # @!macro [attach] timer_task_initialize
-    #   @param [Hash] opts the options defining task execution.
-    #   @option opts [Integer] :execution_interval number of seconds between
-    #     task executions (default: EXECUTION_INTERVAL)
-    #   @option opts [Integer] :timeout_interval number of seconds a task can
-    #     run before it is considered to have failed (default: TIMEOUT_INTERVAL)
-    #   @option opts [Boolean] :run_now Whether to run the task immediately
-    #     upon instantiation or to wait until the first #  execution_interval
-    #     has passed (default: false)
-    #
-    #   @!macro deref_options
-    #
-    #   @raise ArgumentError when no block is given.
-    #
-    #   @yield to the block after :execution_interval seconds have passed since
-    #     the last yield
-    #   @yieldparam task a reference to the `TimerTask` instance so that the
-    #     block can control its own lifecycle. Necessary since `self` will
-    #     refer to the execution context of the block rather than the running
-    #     `TimerTask`.
-    #
-    #   @return [TimerTask] the new `TimerTask`
-    def initialize(opts = {}, &task)
-      raise ArgumentError.new('no block given') unless block_given?
-      super
-    end
-
-    # Is the executor running?
-    #
-    # @return [Boolean] `true` when running, `false` when shutting down or shutdown
-    def running?
-      @running.true?
-    end
-
-    # Execute a previously created `TimerTask`.
-    #
-    # @return [TimerTask] a reference to `self`
-    #
-    # @example Instance and execute in separate steps
-    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }
-    #   task.running? #=> false
-    #   task.execute
-    #   task.running? #=> true
-    #
-    # @example Instance and execute in one line
-    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }.execute
-    #   task.running? #=> true
-    def execute
-      synchronize do
-        if @running.false?
-          @running.make_true
-          schedule_next_task(@run_now ? 0 : @execution_interval)
-        end
-      end
-      self
-    end
-
-    # Create and execute a new `TimerTask`.
-    #
-    # @!macro timer_task_initialize
-    #
-    # @example
-    #   task = Concurrent::TimerTask.execute(execution_interval: 10){ print "Hello World\n" }
-    #   task.running? #=> true
-    def self.execute(opts = {}, &task)
-      TimerTask.new(opts, &task).execute
-    end
-
-    # @!attribute [rw] execution_interval
-    # @return [Fixnum] Number of seconds after the task completes before the
-    #   task is performed again.
-    def execution_interval
-      synchronize { @execution_interval }
-    end
-
-    # @!attribute [rw] execution_interval
-    # @return [Fixnum] Number of seconds after the task completes before the
-    #   task is performed again.
-    def execution_interval=(value)
-      if (value = value.to_f) <= 0.0
-        raise ArgumentError.new('must be greater than zero')
-      else
-        synchronize { @execution_interval = value }
-      end
-    end
-
-    # @!attribute [rw] timeout_interval
-    # @return [Fixnum] Number of seconds the task can run before it is
-    #   considered to have failed.
-    def timeout_interval
-      synchronize { @timeout_interval }
-    end
-
-    # @!attribute [rw] timeout_interval
-    # @return [Fixnum] Number of seconds the task can run before it is
-    #   considered to have failed.
-    def timeout_interval=(value)
-      if (value = value.to_f) <= 0.0
-        raise ArgumentError.new('must be greater than zero')
-      else
-        synchronize { @timeout_interval = value }
-      end
-    end
-
-    private :post, :<<
-
-    private
-
-    def ns_initialize(opts, &task)
-      set_deref_options(opts)
-
-      self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
-      self.timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
-      @run_now = opts[:now] || opts[:run_now]
-      @executor = Concurrent::SafeTaskExecutor.new(task)
-      @running = Concurrent::AtomicBoolean.new(false)
-
-      self.observers = Collection::CopyOnNotifyObserverSet.new
-    end
-
-    # @!visibility private
-    def ns_shutdown_execution
-      @running.make_false
-      super
-    end
-
-    # @!visibility private
-    def ns_kill_execution
-      @running.make_false
-      super
-    end
-
-    # @!visibility private
-    def schedule_next_task(interval = execution_interval)
-      ScheduledTask.execute(interval, args: [Concurrent::Event.new], &method(:execute_task))
-      nil
-    end
-
-    # @!visibility private
-    def execute_task(completion)
-      return nil unless @running.true?
-      ScheduledTask.execute(execution_interval, args: [completion], &method(:timeout_task))
-      _success, value, reason = @executor.execute(self)
-      if completion.try?
-        self.value = value
-        schedule_next_task
-        time = Time.now
-        observers.notify_observers do
-          [time, self.value, reason]
-        end
-      end
-      nil
-    end
-
-    # @!visibility private
-    def timeout_task(completion)
-      return unless @running.true?
-      if completion.try?
-        self.value = value
-        schedule_next_task
-        observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
-      end
-    end
-  end
-end