ric 0.12.0 → 0.14.1

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

@@ -0,0 +1,377 @@
+require 'thread'
+require 'concurrent/atomic/event'
+require 'concurrent/concern/logging'
+require 'concurrent/executor/ruby_executor_service'
+require 'concurrent/utility/monotonic_time'
+
+module Concurrent
+
+  # @!macro thread_pool_executor
+  # @!macro thread_pool_options
+  # @!visibility private
+  class RubyThreadPoolExecutor < RubyExecutorService
+
+    # @!macro thread_pool_executor_constant_default_max_pool_size
+    DEFAULT_MAX_POOL_SIZE      = 2_147_483_647 # java.lang.Integer::MAX_VALUE
+
+    # @!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_constant_default_synchronous
+    DEFAULT_SYNCHRONOUS = false
+
+    # @!macro thread_pool_executor_attr_reader_max_length
+    attr_reader :max_length
+
+    # @!macro thread_pool_executor_attr_reader_min_length
+    attr_reader :min_length
+
+    # @!macro thread_pool_executor_attr_reader_idletime
+    attr_reader :idletime
+
+    # @!macro thread_pool_executor_attr_reader_max_queue
+    attr_reader :max_queue
+
+    # @!macro thread_pool_executor_attr_reader_synchronous
+    attr_reader :synchronous
+
+    # @!macro thread_pool_executor_method_initialize
+    def initialize(opts = {})
+      super(opts)
+    end
+
+    # @!macro thread_pool_executor_attr_reader_largest_length
+    def largest_length
+      synchronize { @largest_length }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_scheduled_task_count
+    def scheduled_task_count
+      synchronize { @scheduled_task_count }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_completed_task_count
+    def completed_task_count
+      synchronize { @completed_task_count }
+    end
+
+    # @!macro executor_service_method_can_overflow_question
+    def can_overflow?
+      synchronize { ns_limited_queue? }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_length
+    def length
+      synchronize { @pool.length }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_queue_length
+    def queue_length
+      synchronize { @queue.length }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_remaining_capacity
+    def remaining_capacity
+      synchronize do
+        if ns_limited_queue?
+          @max_queue - @queue.length
+        else
+          -1
+        end
+      end
+    end
+
+    # @!visibility private
+    def remove_busy_worker(worker)
+      synchronize { ns_remove_busy_worker worker }
+    end
+
+    # @!visibility private
+    def ready_worker(worker)
+      synchronize { ns_ready_worker worker }
+    end
+
+    # @!visibility private
+    def worker_not_old_enough(worker)
+      synchronize { ns_worker_not_old_enough worker }
+    end
+
+    # @!visibility private
+    def worker_died(worker)
+      synchronize { ns_worker_died worker }
+    end
+
+    # @!visibility private
+    def worker_task_completed
+      synchronize { @completed_task_count += 1 }
+    end
+
+    private
+
+    # @!visibility 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
+      @synchronous     = opts.fetch(:synchronous, DEFAULT_SYNCHRONOUS)
+      @fallback_policy = opts.fetch(:fallback_policy, :abort)
+
+      raise ArgumentError.new("`synchronous` cannot be set unless `max_queue` is 0") if @synchronous && @max_queue > 0
+      raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_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
+
+      @pool                 = [] # all workers
+      @ready                = [] # used as a stash (most idle worker is at the start)
+      @queue                = [] # used as queue
+      # @ready or @queue is empty at all times
+      @scheduled_task_count = 0
+      @completed_task_count = 0
+      @largest_length       = 0
+      @workers_counter      = 0
+      @ruby_pid             = $$ # detects if Ruby has forked
+
+      @gc_interval  = opts.fetch(:gc_interval, @idletime / 2.0).to_i # undocumented
+      @next_gc_time = Concurrent.monotonic_time + @gc_interval
+    end
+
+    # @!visibility private
+    def ns_limited_queue?
+      @max_queue != 0
+    end
+
+    # @!visibility private
+    def ns_execute(*args, &task)
+      ns_reset_if_forked
+
+      if ns_assign_worker(*args, &task) || ns_enqueue(*args, &task)
+        @scheduled_task_count += 1
+      else
+        handle_fallback(*args, &task)
+      end
+
+      ns_prune_pool if @next_gc_time < Concurrent.monotonic_time
+    end
+
+    # @!visibility private
+    def ns_shutdown_execution
+      ns_reset_if_forked
+
+      if @pool.empty?
+        # nothing to do
+        stopped_event.set
+      end
+
+      if @queue.empty?
+        # no more tasks will be accepted, just stop all workers
+        @pool.each(&:stop)
+      end
+    end
+
+    # @!visibility private
+    def ns_kill_execution
+      # TODO log out unprocessed tasks in queue
+      # TODO try to shutdown first?
+      @pool.each(&:kill)
+      @pool.clear
+      @ready.clear
+    end
+
+    # tries to assign task to a worker, tries to get one from @ready or to create new one
+    # @return [true, false] if task is assigned to a worker
+    #
+    # @!visibility private
+    def ns_assign_worker(*args, &task)
+      # keep growing if the pool is not at the minimum yet
+      worker = (@ready.pop if @pool.size >= @min_length) || ns_add_busy_worker
+      if worker
+        worker << [task, args]
+        true
+      else
+        false
+      end
+    rescue ThreadError
+      # Raised when the operating system refuses to create the new thread
+      return false
+    end
+
+    # tries to enqueue task
+    # @return [true, false] if enqueued
+    #
+    # @!visibility private
+    def ns_enqueue(*args, &task)
+      return false if @synchronous
+      
+      if !ns_limited_queue? || @queue.size < @max_queue
+        @queue << [task, args]
+        true
+      else
+        false
+      end
+    end
+
+    # @!visibility private
+    def ns_worker_died(worker)
+      ns_remove_busy_worker worker
+      replacement_worker = ns_add_busy_worker
+      ns_ready_worker replacement_worker, false if replacement_worker
+    end
+
+    # creates new worker which has to receive work to do after it's added
+    # @return [nil, Worker] nil of max capacity is reached
+    #
+    # @!visibility private
+    def ns_add_busy_worker
+      return if @pool.size >= @max_length
+
+      @workers_counter += 1
+      @pool << (worker = Worker.new(self, @workers_counter))
+      @largest_length = @pool.length if @pool.length > @largest_length
+      worker
+    end
+
+    # handle ready worker, giving it new job or assigning back to @ready
+    #
+    # @!visibility private
+    def ns_ready_worker(worker, success = true)
+      task_and_args = @queue.shift
+      if task_and_args
+        worker << task_and_args
+      else
+        # stop workers when !running?, do not return them to @ready
+        if running?
+          @ready.push(worker)
+        else
+          worker.stop
+        end
+      end
+    end
+
+    # returns back worker to @ready which was not idle for enough time
+    #
+    # @!visibility private
+    def ns_worker_not_old_enough(worker)
+      # let's put workers coming from idle_test back to the start (as the oldest worker)
+      @ready.unshift(worker)
+      true
+    end
+
+    # removes a worker which is not in not tracked in @ready
+    #
+    # @!visibility private
+    def ns_remove_busy_worker(worker)
+      @pool.delete(worker)
+      stopped_event.set if @pool.empty? && !running?
+      true
+    end
+
+    # try oldest worker if it is idle for enough time, it's returned back at the start
+    #
+    # @!visibility private
+    def ns_prune_pool
+      return if @pool.size <= @min_length
+
+      last_used = @ready.shift
+      last_used << :idle_test if last_used
+
+      @next_gc_time = Concurrent.monotonic_time + @gc_interval
+    end
+
+    def ns_reset_if_forked
+      if $$ != @ruby_pid
+        @queue.clear
+        @ready.clear
+        @pool.clear
+        @scheduled_task_count = 0
+        @completed_task_count = 0
+        @largest_length       = 0
+        @workers_counter      = 0
+        @ruby_pid             = $$
+      end
+    end
+
+    # @!visibility private
+    class Worker
+      include Concern::Logging
+
+      def initialize(pool, id)
+        # instance variables accessed only under pool's lock so no need to sync here again
+        @queue  = Queue.new
+        @pool   = pool
+        @thread = create_worker @queue, pool, pool.idletime
+
+        if @thread.respond_to?(:name=)
+          @thread.name = [pool.name, 'worker', id].compact.join('-')
+        end
+      end
+
+      def <<(message)
+        @queue << message
+      end
+
+      def stop
+        @queue << :stop
+      end
+
+      def kill
+        @thread.kill
+      end
+
+      private
+
+      def create_worker(queue, pool, idletime)
+        Thread.new(queue, pool, idletime) do |my_queue, my_pool, my_idletime|
+          last_message = Concurrent.monotonic_time
+          catch(:stop) do
+            loop do
+
+              case message = my_queue.pop
+              when :idle_test
+                if (Concurrent.monotonic_time - last_message) > my_idletime
+                  my_pool.remove_busy_worker(self)
+                  throw :stop
+                else
+                  my_pool.worker_not_old_enough(self)
+                end
+
+              when :stop
+                my_pool.remove_busy_worker(self)
+                throw :stop
+
+              else
+                task, args = message
+                run_task my_pool, task, args
+                last_message = Concurrent.monotonic_time
+
+                my_pool.ready_worker(self)
+              end
+            end
+          end
+        end
+      end
+
+      def run_task(pool, task, args)
+        task.call(*args)
+        pool.worker_task_completed
+      rescue => ex
+        # let it fail
+        log DEBUG, ex
+      rescue Exception => ex
+        log ERROR, ex
+        pool.worker_died(self)
+        throw :stop
+      end
+    end
+
+    private_constant :Worker
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  # A simple utility class that executes a callable and returns and array of three elements:
+  # success - indicating if the callable has been executed without errors
+  # value - filled by the callable result if it has been executed without errors, nil otherwise
+  # reason - the error risen by the callable if it has been executed with errors, nil otherwise
+  class SafeTaskExecutor < Synchronization::LockableObject
+
+    def initialize(task, opts = {})
+      @task            = task
+      @exception_class = opts.fetch(:rescue_exception, false) ? Exception : StandardError
+      super() # ensures visibility
+    end
+
+    # @return [Array]
+    def execute(*args)
+      synchronize do
+        success = false
+        value   = reason = nil
+
+        begin
+          value   = @task.call(*args)
+          success = true
+        rescue @exception_class => ex
+          reason  = ex
+          success = false
+        end
+
+        [success, value, reason]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'concurrent/executor/executor_service'
+
+module Concurrent
+
+  # Indicates that the including `ExecutorService` guarantees
+  # that all operations will occur in the order they are post and that no
+  # two operations may occur simultaneously. This module provides no
+  # functionality and provides no guarantees. That is the responsibility
+  # of the including class. This module exists solely to allow the including
+  # object to be interrogated for its serialization status.
+  #
+  # @example
+  #   class Foo
+  #     include Concurrent::SerialExecutor
+  #   end
+  #
+  #   foo = Foo.new
+  #
+  #   foo.is_a? Concurrent::ExecutorService #=> true
+  #   foo.is_a? Concurrent::SerialExecutor  #=> true
+  #   foo.serialized?                       #=> true
+  #
+  # @!visibility private
+  module SerialExecutorService
+    include ExecutorService
+
+    # @!macro executor_service_method_serialized_question
+    #
+    # @note Always returns `true`
+    def serialized?
+      true
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+require 'concurrent/errors'
+require 'concurrent/concern/logging'
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  # Ensures passed jobs in a serialized order never running at the same time.
+  class SerializedExecution < Synchronization::LockableObject
+    include Concern::Logging
+
+    def initialize()
+      super()
+      synchronize { ns_initialize }
+    end
+
+    Job = Struct.new(:executor, :args, :block) do
+      def call
+        block.call(*args)
+      end
+    end
+
+    # Submit a task to the executor for asynchronous processing.
+    #
+    # @param [Executor] executor to be used for this job
+    #
+    # @param [Array] args zero or more arguments to be passed to the task
+    #
+    # @yield the asynchronous task to perform
+    #
+    # @return [Boolean] `true` if the task is queued, `false` if the executor
+    #   is not running
+    #
+    # @raise [ArgumentError] if no task is given
+    def post(executor, *args, &task)
+      posts [[executor, args, task]]
+      true
+    end
+
+    # As {#post} but allows to submit multiple tasks at once, it's guaranteed that they will not
+    # be interleaved by other tasks.
+    #
+    # @param [Array<Array(ExecutorService, Array<Object>, Proc)>] posts array of triplets where
+    #   first is a {ExecutorService}, second is array of args for task, third is a task (Proc)
+    def posts(posts)
+      # if can_overflow?
+      #   raise ArgumentError, 'SerializedExecution does not support thread-pools which can overflow'
+      # end
+
+      return nil if posts.empty?
+
+      jobs = posts.map { |executor, args, task| Job.new executor, args, task }
+
+      job_to_post = synchronize do
+        if @being_executed
+          @stash.push(*jobs)
+          nil
+        else
+          @being_executed = true
+          @stash.push(*jobs[1..-1])
+          jobs.first
+        end
+      end
+
+      call_job job_to_post if job_to_post
+      true
+    end
+
+    private
+
+    def ns_initialize
+      @being_executed = false
+      @stash          = []
+    end
+
+    def call_job(job)
+      did_it_run = begin
+                     job.executor.post { work(job) }
+                     true
+                   rescue RejectedExecutionError => ex
+                     false
+                   end
+
+      # TODO not the best idea to run it myself
+      unless did_it_run
+        begin
+          work job
+        rescue => ex
+          # let it fail
+          log DEBUG, ex
+        end
+      end
+    end
+
+    # ensures next job is executed if any is stashed
+    def work(job)
+      job.call
+    ensure
+      synchronize do
+        job = @stash.shift || (@being_executed = false)
+      end
+
+      # TODO maybe be able to tell caching pool to just enqueue this job, because the current one end at the end
+      # of this block
+      call_job job if job
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'delegate'
+require 'concurrent/executor/serial_executor_service'
+require 'concurrent/executor/serialized_execution'
+
+module Concurrent
+
+  # A wrapper/delegator for any `ExecutorService` that
+  # guarantees serialized execution of tasks.
+  #
+  # @see [SimpleDelegator](http://www.ruby-doc.org/stdlib-2.1.2/libdoc/delegate/rdoc/SimpleDelegator.html)
+  # @see Concurrent::SerializedExecution
+  class SerializedExecutionDelegator < SimpleDelegator
+    include SerialExecutorService
+
+    def initialize(executor)
+      @executor   = executor
+      @serializer = SerializedExecution.new
+      super(executor)
+    end
+
+    # @!macro executor_service_method_post
+    def post(*args, &task)
+      raise ArgumentError.new('no block given') unless block_given?
+      return false unless running?
+      @serializer.post(@executor, *args, &task)
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require 'concurrent/atomics'
+require 'concurrent/executor/executor_service'
+
+module Concurrent
+
+  # An executor service in which every operation spawns a new,
+  # independently operating thread.
+  #
+  # This is perhaps the most inefficient executor service in this
+  # library. It exists mainly for testing an debugging. Thread creation
+  # and management is expensive in Ruby and this executor performs no
+  # resource pooling. This can be very beneficial during testing and
+  # debugging because it decouples the using code from the underlying
+  # executor implementation. In production this executor will likely
+  # lead to suboptimal performance.
+  #
+  # @note Intended for use primarily in testing and debugging.
+  class SimpleExecutorService < RubyExecutorService
+
+    # @!macro executor_service_method_post
+    def self.post(*args)
+      raise ArgumentError.new('no block given') unless block_given?
+      Thread.new(*args) do
+        Thread.current.abort_on_exception = false
+        yield(*args)
+      end
+      true
+    end
+
+    # @!macro executor_service_method_left_shift
+    def self.<<(task)
+      post(&task)
+      self
+    end
+
+    # @!macro executor_service_method_post
+    def post(*args, &task)
+      raise ArgumentError.new('no block given') unless block_given?
+      return false unless running?
+      @count.increment
+      Thread.new(*args) do
+        Thread.current.abort_on_exception = false
+        begin
+          yield(*args)
+        ensure
+          @count.decrement
+          @stopped.set if @running.false? && @count.value == 0
+        end
+      end
+    end
+
+    # @!macro executor_service_method_left_shift
+    def <<(task)
+      post(&task)
+      self
+    end
+
+    # @!macro executor_service_method_running_question
+    def running?
+      @running.true?
+    end
+
+    # @!macro executor_service_method_shuttingdown_question
+    def shuttingdown?
+      @running.false? && ! @stopped.set?
+    end
+
+    # @!macro executor_service_method_shutdown_question
+    def shutdown?
+      @stopped.set?
+    end
+
+    # @!macro executor_service_method_shutdown
+    def shutdown
+      @running.make_false
+      @stopped.set if @count.value == 0
+      true
+    end
+
+    # @!macro executor_service_method_kill
+    def kill
+      @running.make_false
+      @stopped.set
+      true
+    end
+
+    # @!macro executor_service_method_wait_for_termination
+    def wait_for_termination(timeout = nil)
+      @stopped.wait(timeout)
+    end
+
+    private
+
+    def ns_initialize(*args)
+      @running = Concurrent::AtomicBoolean.new(true)
+      @stopped = Concurrent::Event.new
+      @count = Concurrent::AtomicFixnum.new(0)
+    end
+  end
+end