ric 0.14.2 → 0.14.6

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/timer_task.rb

@@ -1,333 +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/ruby_executor_service'
-require 'concurrent/executor/safe_task_executor'
-require 'concurrent/scheduled_task'
-
-module Concurrent
-
-  # A very common concurrency 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.
-  # Dereferencing 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
-  #   sleep 4
-  #
-  #   #=> (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 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
-      set_deref_options opts
-    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)
-      @value = nil
-
-      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(timeout_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?
-        schedule_next_task
-        observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/tuple.rb

@@ -1,86 +0,0 @@
-require 'concurrent/atomic/atomic_reference'
-
-module Concurrent
-
-  # A fixed size array with volatile (synchronized, thread safe) getters/setters.
-  # Mixes in Ruby's `Enumerable` module for enhanced search, sort, and traversal.
-  #
-  # @example
-  #   tuple = Concurrent::Tuple.new(16)
-  #
-  #   tuple.set(0, :foo)                   #=> :foo  | volatile write
-  #   tuple.get(0)                         #=> :foo  | volatile read
-  #   tuple.compare_and_set(0, :foo, :bar) #=> true  | strong CAS
-  #   tuple.cas(0, :foo, :baz)             #=> false | strong CAS
-  #   tuple.get(0)                         #=> :bar  | volatile read
-  #
-  # @see https://en.wikipedia.org/wiki/Tuple Tuple entry at Wikipedia
-  # @see http://www.erlang.org/doc/reference_manual/data_types.html#id70396 Erlang Tuple
-  # @see http://ruby-doc.org/core-2.2.2/Enumerable.html Enumerable
-  class Tuple
-    include Enumerable
-
-    # The (fixed) size of the tuple.
-    attr_reader :size
-
-    # @!visibility private
-    Tuple = defined?(Rubinius::Tuple) ? Rubinius::Tuple : ::Array
-    private_constant :Tuple
-
-    # Create a new tuple of the given size.
-    #
-    # @param [Integer] size the number of elements in the tuple
-    def initialize(size)
-      @size = size
-      @tuple = tuple = Tuple.new(size)
-      i = 0
-      while i < size
-        tuple[i] = Concurrent::AtomicReference.new
-        i += 1
-      end
-    end
-
-    # Get the value of the element at the given index.
-    #
-    # @param [Integer] i the index from which to retrieve the value
-    # @return [Object] the value at the given index or nil if the index is out of bounds
-    def get(i)
-      return nil if i >= @size || i < 0
-      @tuple[i].get
-    end
-    alias_method :volatile_get, :get
-
-    # Set the element at the given index to the given value
-    #
-    # @param [Integer] i the index for the element to set
-    # @param [Object] value the value to set at the given index
-    #
-    # @return [Object] the new value of the element at the given index or nil if the index is out of bounds
-    def set(i, value)
-      return nil if i >= @size || i < 0
-      @tuple[i].set(value)
-    end
-    alias_method :volatile_set, :set
-
-    # Set the value at the given index to the new value if and only if the current
-    # value matches the given old value.
-    #
-    # @param [Integer] i the index for the element to set
-    # @param [Object] old_value the value to compare against the current value
-    # @param [Object] new_value the value to set at the given index
-    #
-    # @return [Boolean] true if the value at the given element was set else false
-    def compare_and_set(i, old_value, new_value)
-      return false if i >= @size || i < 0
-      @tuple[i].compare_and_set(old_value, new_value)
-    end
-    alias_method :cas, :compare_and_set
-
-    # Calls the given block once for each element in self, passing that element as a parameter.
-    #
-    # @yieldparam [Object] ref the `Concurrent::AtomicReference` object at the current index
-    def each
-      @tuple.each {|ref| yield ref.get}
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/tvar.rb

@@ -1,261 +0,0 @@
-require 'set'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  # A `TVar` is a transactional variable - a single-element container that
-  # is used as part of a transaction - see `Concurrent::atomically`.
-  #
-  # @!macro thread_safe_variable_comparison
-  #
-  # {include:file:docs-source/tvar.md}
-  class TVar < Synchronization::Object
-    safe_initialization!
-
-    # Create a new `TVar` with an initial value.
-    def initialize(value)
-      @value = value
-      @version = 0
-      @lock = Mutex.new
-    end
-
-    # Get the value of a `TVar`.
-    def value
-      Concurrent::atomically do
-        Transaction::current.read(self)
-      end
-    end
-
-    # Set the value of a `TVar`.
-    def value=(value)
-      Concurrent::atomically do
-        Transaction::current.write(self, value)
-      end
-    end
-
-    # @!visibility private
-    def unsafe_value # :nodoc:
-      @value
-    end
-
-    # @!visibility private
-    def unsafe_value=(value) # :nodoc:
-      @value = value
-    end
-
-    # @!visibility private
-    def unsafe_version # :nodoc:
-      @version
-    end
-
-    # @!visibility private
-    def unsafe_increment_version # :nodoc:
-      @version += 1
-    end
-
-    # @!visibility private
-    def unsafe_lock # :nodoc:
-      @lock
-    end
-
-  end
-
-  # Run a block that reads and writes `TVar`s as a single atomic transaction.
-  # With respect to the value of `TVar` objects, the transaction is atomic, in
-  # that it either happens or it does not, consistent, in that the `TVar`
-  # objects involved will never enter an illegal state, and isolated, in that
-  # transactions never interfere with each other. You may recognise these
-  # properties from database transactions.
-  #
-  # There are some very important and unusual semantics that you must be aware of:
-  #
-  # * Most importantly, the block that you pass to atomically may be executed
-  #     more than once. In most cases your code should be free of
-  #     side-effects, except for via TVar.
-  #
-  # * If an exception escapes an atomically block it will abort the transaction.
-  #
-  # * It is undefined behaviour to use callcc or Fiber with atomically.
-  #
-  # * If you create a new thread within an atomically, it will not be part of
-  #     the transaction. Creating a thread counts as a side-effect.
-  #
-  # Transactions within transactions are flattened to a single transaction.
-  #
-  # @example
-  #   a = new TVar(100_000)
-  #   b = new TVar(100)
-  #
-  #   Concurrent::atomically do
-  #     a.value -= 10
-  #     b.value += 10
-  #   end
-  def atomically
-    raise ArgumentError.new('no block given') unless block_given?
-
-    # Get the current transaction
-
-    transaction = Transaction::current
-
-    # Are we not already in a transaction (not nested)?
-
-    if transaction.nil?
-      # New transaction
-
-      begin
-        # Retry loop
-
-        loop do
-
-          # Create a new transaction
-
-          transaction = Transaction.new
-          Transaction::current = transaction
-
-          # Run the block, aborting on exceptions
-
-          begin
-            result = yield
-          rescue Transaction::AbortError => e
-            transaction.abort
-            result = Transaction::ABORTED
-          rescue Transaction::LeaveError => e
-            transaction.abort
-            break result
-          rescue => e
-            transaction.abort
-            raise e
-          end
-          # If we can commit, break out of the loop
-
-          if result != Transaction::ABORTED
-            if transaction.commit
-              break result
-            end
-          end
-        end
-      ensure
-        # Clear the current transaction
-
-        Transaction::current = nil
-      end
-    else
-      # Nested transaction - flatten it and just run the block
-
-      yield
-    end
-  end
-
-  # Abort a currently running transaction - see `Concurrent::atomically`.
-  def abort_transaction
-    raise Transaction::AbortError.new
-  end
-
-  # Leave a transaction without committing or aborting - see `Concurrent::atomically`.
-  def leave_transaction
-    raise Transaction::LeaveError.new
-  end
-
-  module_function :atomically, :abort_transaction, :leave_transaction
-
-  private
-
-  class Transaction
-
-    ABORTED = ::Object.new
-
-    ReadLogEntry = Struct.new(:tvar, :version)
-
-    AbortError = Class.new(StandardError)
-    LeaveError = Class.new(StandardError)
-
-    def initialize
-      @read_log  = []
-      @write_log = {}
-    end
-
-    def read(tvar)
-      Concurrent::abort_transaction unless valid?
-
-      if @write_log.has_key? tvar
-        @write_log[tvar]
-      else
-        @read_log.push(ReadLogEntry.new(tvar, tvar.unsafe_version))
-        tvar.unsafe_value
-      end
-    end
-
-    def write(tvar, value)
-      # Have we already written to this TVar?
-
-      if @write_log.has_key? tvar
-        # Record the value written
-        @write_log[tvar] = value
-      else
-        # Try to lock the TVar
-
-        unless tvar.unsafe_lock.try_lock
-          # Someone else is writing to this TVar - abort
-          Concurrent::abort_transaction
-        end
-
-        # Record the value written
-  
-        @write_log[tvar] = value
-
-        # If we previously read from it, check the version hasn't changed
-
-        @read_log.each do |log_entry|
-          if log_entry.tvar == tvar and tvar.unsafe_version > log_entry.version
-            Concurrent::abort_transaction
-          end
-        end
-      end
-    end
-
-    def abort
-      unlock
-    end
-
-    def commit
-      return false unless valid?
-
-      @write_log.each_pair do |tvar, value|
-        tvar.unsafe_value = value
-        tvar.unsafe_increment_version
-      end
-
-      unlock
-
-      true
-    end
-
-    def valid?
-      @read_log.each do |log_entry|
-        unless @write_log.has_key? log_entry.tvar
-          if log_entry.tvar.unsafe_version > log_entry.version
-            return false
-          end
-        end
-      end
-
-      true
-    end
-
-    def unlock
-      @write_log.each_key do |tvar|
-        tvar.unsafe_lock.unlock
-      end
-    end
-
-    def self.current
-      Thread.current[:current_tvar_transaction]
-    end
-
-    def self.current=(transaction)
-      Thread.current[:current_tvar_transaction] = transaction
-    end
-
-  end
-
-end