async-limiter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1e4bf6b1b1477475fc5bf247364592ebd062e86cd5039614a9963cfdc9e23ab
+  data.tar.gz: 82f5fc81a61d6d8cc0400d86b4a84977379f3edc8f6951bba738e2215e1e3445
+SHA512:
+  metadata.gz: 8c2698448ec6846405dc647c0e11b37616fbd80027b92a03e28a849d511164835909d4982ddbe6cfff7e963b00bedc6699dd90dbc33067f52969480170bc1c4a
+  data.tar.gz: 62e777daf244f5cfe6b9ef89cdcdd8b07791808324713db58a7242825cf9d3d82f4978c920639bbc603dae625fbe819a41fdb7b95897d3f619d8d80eb9195794

data/lib/async/limiter.rb

@@ -0,0 +1,114 @@
+require "async/task"
+
+module Async
+  # Base class for all the limiters.
+  class Limiter
+    Error = Class.new(StandardError)
+    ArgumentError = Class.new(Error)
+
+    MAX_LIMIT = Float::INFINITY
+    MIN_LIMIT = Float::MIN
+
+    attr_reader :count
+
+    attr_reader :limit
+
+    attr_reader :waiting
+
+    def initialize(limit = 1, parent: nil,
+      max_limit: MAX_LIMIT, min_limit: MIN_LIMIT)
+      @count = 0
+      @limit = limit
+      @waiting = []
+      @parent = parent
+      @max_limit = max_limit
+      @min_limit = min_limit
+
+      validate!
+    end
+
+    def blocking?
+      @count >= @limit
+    end
+
+    def async(parent: (@parent or Task.current), **options)
+      acquire
+      parent.async(**options) do |task|
+        yield task
+      ensure
+        release
+      end
+    end
+
+    def acquire
+      wait
+      @count += 1
+    end
+
+    def release
+      @count -= 1
+
+      while under_limit? && (fiber = @waiting.shift)
+        fiber.resume if fiber.alive?
+      end
+    end
+
+    def increase_limit(number = 1)
+      new_limit = @limit + number
+      return false if new_limit > @max_limit
+
+      @limit = new_limit
+    end
+
+    def decrease_limit(number = 1)
+      new_limit = @limit - number
+      return false if new_limit < @min_limit
+
+      @limit = new_limit
+    end
+
+    def waiting_count
+      @waiting.size
+    end
+
+    private
+
+    def under_limit?
+      available_units.positive?
+    end
+
+    def available_units
+      @limit - @count
+    end
+
+    def wait
+      fiber = Fiber.current
+
+      if blocking?
+        @waiting << fiber
+        Task.yield while blocking?
+      end
+    rescue Exception
+      @waiting.delete(fiber)
+      raise
+    end
+
+    def validate!
+      if @max_limit < @min_limit
+        raise ArgumentError, "max_limit is lower than min_limit"
+      end
+
+      unless @max_limit.positive?
+        raise ArgumentError, "max_limit must be positive"
+      end
+
+      unless @min_limit.positive?
+        raise ArgumentError, "min_limit must be positive"
+      end
+
+      unless @limit.between?(@min_limit, @max_limit)
+        raise ArgumentError, "limit not between min_limit and max_limit"
+      end
+    end
+  end
+end

data/lib/async/limiter/concurrent.rb

@@ -0,0 +1,10 @@
+require_relative "../limiter"
+
+module Async
+  class Limiter
+    # Allows running x units of work concurrently.
+    # Has the same logic as Async::Semaphore.
+    class Concurrent < Limiter
+    end
+  end
+end

data/lib/async/limiter/delay.rb

@@ -0,0 +1,47 @@
+require "async/clock"
+require_relative "../limiter"
+
+module Async
+  class Limiter
+    # Ensures units are evenly acquired during the sliding time window.
+    # Example: If limit is 2 you can perform one operation every 500ms. First
+    # operation at 10:10:10.000, and then another one at 10:10:10.500.
+    class Throttle < Limiter
+      attr_reader :window
+
+      def initialize(*args, window: 1, min_limit: 0, **options)
+        super(*args, min_limit: min_limit, **options)
+
+        @window = window
+        @last_acquired_time = -1
+      end
+
+      def blocking?
+        super && current_delay.positive?
+      end
+
+      def acquire
+        super
+        @last_acquired_time = now
+      end
+
+      def delay
+        @window.to_f / @limit
+      end
+
+      private
+
+      def now
+        Clock.now
+      end
+
+      def current_delay
+        [delay - elapsed_time, 0].max
+      end
+
+      def elapsed_time
+        now - @last_acquired_time
+      end
+    end
+  end
+end

data/lib/async/limiter/fixed_window.rb

@@ -0,0 +1,53 @@
+require "async/clock"
+require_relative "../limiter"
+
+module Async
+  class Limiter
+    # Ensures units are acquired during the time window.
+    # Example: You can perform N operations at 10:10:10.999, and then can
+    # perform another N operations at 10:10:11.000.
+    class FixedWindow < Limiter
+      attr_reader :window
+
+      def initialize(*args, window: 1, **options)
+        super(*args, **options)
+
+        @window = window
+        @acquired_window_indexes = []
+      end
+
+      def blocking?
+        super && window_limited?
+      end
+
+      def acquire
+        super
+        @acquired_window_indexes.unshift(window_index)
+        # keep more entries in case a limit is increased
+        @acquired_window_indexes = @acquired_window_indexes.first(keep_limit)
+      end
+
+      private
+
+      def window_limited?
+        first_index_in_limit_scope == window_index
+      end
+
+      def first_index_in_limit_scope
+        @acquired_window_indexes.fetch(@limit - 1) { -1 }
+      end
+
+      def window_index
+        (now / @window).floor
+      end
+
+      def keep_limit
+        @max_limit.infinite? ? @limit * 10 : @max_limit
+      end
+
+      def now
+        Clock.now
+      end
+    end
+  end
+end

data/lib/async/limiter/sliding_window.rb

@@ -0,0 +1,53 @@
+require "async/clock"
+require_relative "../limiter"
+
+module Async
+  class Limiter
+    # Ensures units are acquired during the sliding time window.
+    # Example: You can perform N operations at 10:10:10.999 but can't perform
+    # another N operations until 10:10:11.999.
+    class SlidingWindow < Limiter
+      attr_reader :window
+
+      def initialize(*args, window: 1, min_limit: 0, **options)
+        super(*args, min_limit: min_limit, **options)
+
+        @window = window
+        @acquired_times = []
+      end
+
+      def blocking?
+        super && window_limited?
+      end
+
+      def acquire
+        super
+        @acquired_times.unshift(now)
+        # keep more entries in case a limit is increased
+        @acquired_times = @acquired_times.first(keep_limit)
+      end
+
+      private
+
+      def window_limited?
+        first_time_in_limit_scope >= window_start_time
+      end
+
+      def first_time_in_limit_scope
+        @acquired_times.fetch(@limit - 1) { -1 }
+      end
+
+      def window_start_time
+        now - @window
+      end
+
+      def keep_limit
+        @max_limit.infinite? ? @limit * 10 : @max_limit
+      end
+
+      def now
+        Clock.now
+      end
+    end
+  end
+end

data/lib/async/limiter/version.rb

@@ -0,0 +1,5 @@
+module Async
+  class Limiter
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: async-limiter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Bruno Sutic
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description:
+email: code@brunosutic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/async/limiter.rb
+- lib/async/limiter/concurrent.rb
+- lib/async/limiter/delay.rb
+- lib/async/limiter/fixed_window.rb
+- lib/async/limiter/sliding_window.rb
+- lib/async/limiter/version.rb
+homepage: https://github.com/bruno-/async-limiter
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Async limiters
+test_files: []