async_resource_pool 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75133743aeaeab2c6bee303c2d2497055d9d5563e7b4ccebb3bf6cae0660fe13
-  data.tar.gz: 247147e3ce15590265ac8b9a55d82008c4f031a7d503748e727263b8734384e4
+  metadata.gz: 33a430430c05e8d4c974bd33e7ddef4c5c312135837374b0ed5610421347eee4
+  data.tar.gz: 8bd7329c95eb067c6338930dfcf577aca8e0738c315c2bc902bb2e8883397812
 SHA512:
-  metadata.gz: 5aa8a66212a37bf79160fbcf29f6ca523180512a3a9de16f058db725514aaf2c3dab8ed40605787ccc407feb26c44e90df77b7f079bf8e2ffa36412a44098383
-  data.tar.gz: 5d844e30908ce0c0a448ab0cc33eb7238acd5079defe643a644544896aab7c004ed662ca969f29198834d87a5976e79c8f4e1425d7b4e73fb89834151b154461
+  metadata.gz: 8b54fe315d31d27ea0761ebf54779e4c651ab82386a90b818534b6ae6d08f9d16b9fd5e38fc000326dc81cbbab6ef04719c3deffcde74fa179c9e3bf419ac883
+  data.tar.gz: 0c71b6f55af4b0b436ec4b5f7ba227d2d55761922af1249d6075403715697c2628e3bbef06f99562e4502472bc5740b5fc52469bcfc1f8fc194db28588bda595

data/.travis.yml

@@ -10,14 +10,7 @@ rvm:
   - 2.3
   - 2.4
   - 2.5
-  - jruby-head
-  - ruby-head
-  - rbx-3
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
-    - rvm: rbx-3
+  - 2.6
 before_install:
   - gem update --system
-  - gem install bundler -v 2.0.1
+  - gem install bundler -v 1.7.13

data/README.md

@@ -1,5 +1,6 @@
 # AsyncResourcePool
 
+[![Gem Version](https://badge.fury.io/rb/async_resource_pool.svg)](https://rubygems.org/gems/async_resource_pool)
 [![Build Status](https://travis-ci.com/senid231/async_resource_pool.svg?branch=master)](https://travis-ci.com/senid231/async_resource_pool)
 
 TODO:

data/async_resource_pool.gemspec

@@ -1,10 +1,11 @@
 
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'async/resource_pool/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'async_resource_pool'
-  spec.version       = '0.1.0'
+  spec.version       = Async::ResourcePool::VERSION
   spec.authors       = ['Denis Talakevich']
   spec.email         = ['senid231@gmail.com']
 

data/lib/async/resource_pool.rb

@@ -1,105 +1,8 @@
 require 'async'
+require 'async/resource_pool/version'
+require 'async/resource_pool/simple'
 
 module Async
-  class ResourcePool
-    VERSION = '0.1.0'
-
-    class Error < StandardError
-    end
-
-    class DoesNotOwnError < Error
-      def initialize
-        super('current fiber does not own this resource')
-      end
-    end
-
-    class AlreadyOwnError < Error
-      def initialize
-        super('current fiber already own this resource')
-      end
-    end
-
-    class TimeoutError < Error
-      def initialize(timeout)
-        super("timeout #{timeout} seconds was elapsed")
-      end
-    end
-
-    def initialize(limit)
-      @limit = limit
-      @owners = []
-      @waiters = []
-    end
-
-    def acquire(timeout = nil)
-      raise AlreadyOwnError.new if already_acquired?
-
-      unless can_be_acquired?
-        timeout.nil? ? wait : wait_with_timeout(timeout)
-      end
-
-      @owners.push(Fiber.current)
-
-      if block_given?
-        begin
-          yield
-        ensure
-          release
-        end
-      end
-
-      nil
-    end
-
-    def release
-      raise DoesNotOwnError.new unless already_acquired?
-      @owners.delete(Fiber.current)
-      wakeup
-    end
-
-    def already_acquired?
-      @owners.include?(Fiber.current)
-    end
-
-    def can_be_acquired?
-      @owners.size < @limit
-    end
-
-    def info
-      {
-          waiters: @waiters.size,
-          owners: @owners.size,
-          limit: @limit
-      }
-    end
-
-    private
-
-    def wakeup
-      return if @waiters.empty?
-      fiber = @waiters.shift
-      fiber.resume if fiber.alive?
-    end
-
-    def wait
-      @waiters.push(Fiber.current)
-      Async::Task.yield
-    end
-
-    def wait_with_timeout(timeout)
-      fiber = Fiber.current
-      @waiters.push(Fiber.current)
-
-      Async::Task.current.with_timeout(timeout) do |timer|
-        begin
-          Async::Task.yield
-          timer.cancel
-        rescue Async::TimeoutError => _
-          @waiters.delete(fiber)
-          raise TimeoutError.new(timeout)
-        end
-      end
-    end
-
+  module ResourcePool
   end
 end

data/lib/async/resource_pool/errors.rb

@@ -0,0 +1,26 @@
+module Async
+  module ResourcePool
+
+    class Error < StandardError
+    end
+
+    class DoesNotOwnError < Error
+      def initialize
+        super('current fiber does not own this resource')
+      end
+    end
+
+    class AlreadyOwnError < Error
+      def initialize
+        super('current fiber already own this resource')
+      end
+    end
+
+    class TimeoutError < Error
+      def initialize(timeout)
+        super("timeout #{timeout} seconds was elapsed")
+      end
+    end
+
+  end
+end

data/lib/async/resource_pool/simple.rb

@@ -0,0 +1,145 @@
+require 'thread'
+require_relative 'errors'
+
+module Async
+  module ResourcePool
+    class Simple
+
+      # @param limit [Integer] - max number of acquired resources, must be greater then 0.
+      # @param wakeup_strategy [Symbol] - can be :immediately or :next_loop.
+      def initialize(limit, wakeup_strategy = :immediately)
+        raise ArgumentError, 'limit must be greater than 0' if limit <= 0
+        unless [:immediately, :next_loop].include?(wakeup_strategy)
+          raise ArgumentError, 'wakeup_strategy must be :immediately or :next_loop'
+        end
+
+        @limit = limit
+        @wakeup_strategy = wakeup_strategy
+        @owners = []
+        @waiters = []
+        @thread_mutex = Mutex.new
+      end
+
+      # Acquires resource for current fiber if available otherwise yield to reactor.
+      # Will be resumed once resource available.
+      # Will raise Async::ResourcePool::TimeoutError if timeout not nil and resource isn't available after timeout.
+      # Will raise Async::ResourcePool::AlreadyOwnError if resource already acquired.
+      # @param timeout [Integer|Float] - timeout in seconds (default nil).
+      def acquire(timeout = nil)
+        raise Async::ResourcePool::AlreadyOwnError.new if already_acquired?
+
+        unless acquire_if_available
+          timeout.nil? ? Async::Task.yield : wait_with_timeout(timeout)
+          @thread_mutex.synchronize { @owners.push(Fiber.current) }
+        end
+
+        if block_given?
+          begin
+            yield
+          ensure
+            release
+          end
+        end
+
+        nil
+      end
+
+      # Acquires resource for current fiber if resource available.
+      # Will raise Async::ResourcePool::AlreadyOwnError if resource already acquired.
+      # @return [True|False] returns true if resource was acquired.
+      def try_acquire
+        raise Async::ResourcePool::AlreadyOwnError.new if already_acquired?
+
+        if acquire_if_available
+          true
+        else
+          @waiters.delete(Fiber.current)
+          false
+        end
+      end
+
+      # Releases resource for current fiber.
+      # Will resume first fiber that waits for resource immediately if wakeup_strategy == :immediately
+      # Will resume first fiber that waits for resource in next reactor loop if wakeup_strategy == :next_loop
+      # Will raise Async::ResourcePool::DoesNotOwnError if fiber does not own resource.
+      def release
+        raise Async::ResourcePool::DoesNotOwnError.new unless already_acquired?
+        @owners.delete(Fiber.current)
+        wakeup
+      end
+
+      # @return [True|False] returns true if resource already acquired by fiber
+      def already_acquired?
+        @owners.include?(Fiber.current)
+      end
+
+      # @return [True|False] returns true if pool has available resource
+      def can_be_acquired?
+        @owners.size < @limit
+      end
+
+      # @return [Hash] represents current state of resource pool.
+      #   waiters - how many fibers waits for resource.
+      #   owners - how many fibers own resource.
+      #   limit - maximum of resources that can be owned simultaneously.
+      def info
+        {
+            waiters: @waiters.size,
+            owners: @owners.size,
+            limit: @limit
+        }
+      end
+
+      private
+
+      def wakeup
+        return if @waiters.empty?
+        fiber = @waiters.shift
+        return unless fiber.alive?
+
+        if @wakeup_strategy == :immediately
+          fiber.resume
+        else
+          Async::Task.current.reactor << fiber
+        end
+      end
+
+      def wakeup_fiber(fiber)
+        if @wakeup_strategy == :immediately
+          fiber.resume
+        else
+          Async::Task.current.reactor << fiber
+        end
+      end
+
+      def acquire_if_available
+        fiber = Fiber.current
+
+        @thread_mutex.synchronize do
+          if can_be_acquired?
+            @owners.push(fiber)
+            true
+          else
+            @waiters.push(fiber)
+            false
+          end
+        end
+      end
+
+      def wait_with_timeout(timeout)
+        fiber = Fiber.current
+
+        Async::Task.current.with_timeout(timeout) do |timer|
+          begin
+            Async::Task.yield
+            timer.cancel
+          rescue Async::TimeoutError => _
+            @waiters.delete(fiber)
+            raise Async::ResourcePool::TimeoutError.new(timeout)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/async/resource_pool/version.rb

@@ -0,0 +1,5 @@
+module Async
+  module ResourcePool
+    VERSION = '0.2.0'
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async_resource_pool
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Denis Talakevich
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-13 00:00:00.000000000 Z
+date: 2019-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -85,6 +85,9 @@ files:
 - bin/console
 - bin/setup
 - lib/async/resource_pool.rb
+- lib/async/resource_pool/errors.rb
+- lib/async/resource_pool/simple.rb
+- lib/async/resource_pool/version.rb
 - lib/async_resource_pool.rb
 homepage: https://github.com/senid231/async_resource_pool
 licenses: