ric 0.14.2 → 0.14.6

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

@@ -1,377 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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