woolen_common 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4aeb6013d053af960f118edcd50414ed21b10ea1
-  data.tar.gz: fbf8e57654e519f7602adc9bd6b5b136b2cf2d6b
+  metadata.gz: 9d7a51c6d6588cdc16871b1e1c56a1a121bc4cc8
+  data.tar.gz: aa457dfb8dca27ac9dcf78003e00645b052eff73
 SHA512:
-  metadata.gz: c55cea41a15a9d15948873ae0628c581d8b55a3d1bfdf187afe19862ccbcaba30483c57ad6b80b624422bffafb70903fdf9cfbc274abb84d30646a657b74e642
-  data.tar.gz: 561ea2799300a3b7bb891b3e86391683e7b8d153cd3659f5d39e1bfb2b4f88a625891b3ffe1f24c6d3dcf1afc8671aaf9b8e7041bf514d86bb75b726e43c9711
+  metadata.gz: 9ea5baa5799fec9538c99cc34ccf22f5b0ac4a653f7bde9b884627185190c0764cad947de16cc355cf462bfd14cb28108332ac59bed10176713183a532d8d27c
+  data.tar.gz: 71486006f8525b1aa2506ad216ebca1ee144fee753d1400b94e3ffdd5fa13e1a8951c05a4a0ae3dd39ca5a310368c331bc4428af2f9004326b6729c31a7177da

data/lib/woolen_common/connection_pool/monotonic_time.rb

@@ -0,0 +1,68 @@
+# Global monotonic clock from Concurrent Ruby 1.0.
+# Copyright (c) Jerry D'Antonio -- released under the MIT license.
+# Slightly modified; used with permission.
+# https://github.com/ruby-concurrency/concurrent-ruby
+
+require 'thread'
+
+module WoolenCommon
+    class ConnectionPool
+
+        class_definition = Class.new do
+
+            if defined?(Process::CLOCK_MONOTONIC)
+
+                # @!visibility private
+                def get_time
+                    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+                end
+
+            elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+                # @!visibility private
+                def get_time
+                    java.lang.System.nanoTime() / 1_000_000_000.0
+                end
+
+            else
+
+                # @!visibility private
+                def initialize
+                    @mutex = Mutex.new
+                    @last_time = Time.now.to_f
+                end
+
+                # @!visibility private
+                def get_time
+                    @mutex.synchronize do
+                        now = Time.now.to_f
+                        if @last_time < now
+                            @last_time = now
+                        else # clock has moved back in time
+                            @last_time += 0.000_001
+                        end
+                    end
+                end
+            end
+        end
+
+        ##
+        # Clock that cannot be set and represents monotonic time since
+        # some unspecified starting point.
+        #
+        # @!visibility private
+        GLOBAL_MONOTONIC_CLOCK = class_definition.new
+        private_constant :GLOBAL_MONOTONIC_CLOCK
+
+        class << self
+            ##
+            # Returns the current time a tracked by the application monotonic clock.
+            #
+            # @return [Float] The current monotonic time when `since` not given else
+            #   the elapsed monotonic time between `since` and the current time
+            def monotonic_time
+                GLOBAL_MONOTONIC_CLOCK.get_time
+            end
+        end
+    end
+end

data/lib/woolen_common/connection_pool/timed_stack.rb

@@ -0,0 +1,179 @@
+require 'thread'
+require 'timeout'
+require_relative 'monotonic_time'
+
+module WoolenCommon
+##
+# Raised when you attempt to retrieve a connection from a pool that has been
+# shut down.
+
+    class ConnectionPool::PoolShuttingDownError < RuntimeError;
+    end
+
+##
+# The TimedStack manages a pool of homogeneous connections (or any resource
+# you wish to manage).  Connections are created lazily up to a given maximum
+# number.
+
+# Examples:
+#
+#    ts = TimedStack.new(1) { MyConnection.new }
+#
+#    # fetch a connection
+#    conn = ts.pop
+#
+#    # return a connection
+#    ts.push conn
+#
+#    conn = ts.pop
+#    ts.pop timeout: 5
+#    #=> raises Timeout::Error after 5 seconds
+
+    class ConnectionPool::TimedStack
+
+        ##
+        # Creates a new pool with +size+ connections that are created from the given
+        # +block+.
+
+        def initialize(size = 0, &block)
+            @create_block = block
+            @created = 0
+            @que = []
+            @max = size
+            @mutex = Mutex.new
+            @resource = ConditionVariable.new
+            @shutdown_block = nil
+        end
+
+        ##
+        # Returns +obj+ to the stack.  +options+ is ignored in TimedStack but may be
+        # used by subclasses that extend TimedStack.
+
+        def push(obj, options = {})
+            @mutex.synchronize do
+                if @shutdown_block
+                    @shutdown_block.call(obj)
+                else
+                    store_connection obj, options
+                end
+
+                @resource.broadcast
+            end
+        end
+
+        alias_method :<<, :push
+
+        ##
+        # Retrieves a connection from the stack.  If a connection is available it is
+        # immediately returned.  If no connection is available within the given
+        # timeout a Timeout::Error is raised.
+        #
+        # +:timeout+ is the only checked entry in +options+ and is preferred over
+        # the +timeout+ argument (which will be removed in a future release).  Other
+        # options may be used by subclasses that extend TimedStack.
+
+        def pop(timeout = 0.5, options = {})
+            options, timeout = timeout, 0.5 if Hash === timeout
+            timeout = options.fetch :timeout, timeout
+
+            deadline = ConnectionPool.monotonic_time + timeout
+            @mutex.synchronize do
+                loop do
+                    raise ConnectionPool::PoolShuttingDownError if @shutdown_block
+                    return fetch_connection(options) if connection_stored?(options)
+
+                    connection = try_create(options)
+                    return connection if connection
+
+                    to_wait = deadline - ConnectionPool.monotonic_time
+                    raise Timeout::Error, "Waited #{timeout} sec" if to_wait <= 0
+                    @resource.wait(@mutex, to_wait)
+                end
+            end
+        end
+
+        ##
+        # Shuts down the TimedStack which prevents connections from being checked
+        # out.  The +block+ is called once for each connection on the stack.
+
+        def shutdown(&block)
+            raise ArgumentError, "shutdown must receive a block" unless block_given?
+
+            @mutex.synchronize do
+                @shutdown_block = block
+                @resource.broadcast
+
+                shutdown_connections
+            end
+        end
+
+        ##
+        # Returns +true+ if there are no available connections.
+
+        def empty?
+            (@created - @que.length) >= @max
+        end
+
+        ##
+        # The number of connections available on the stack.
+
+        def length
+            @max - @created + @que.length
+        end
+
+        private
+
+        ##
+        # This is an extension point for TimedStack and is called with a mutex.
+        #
+        # This method must returns true if a connection is available on the stack.
+
+        def connection_stored?(options = nil)
+            !@que.empty?
+        end
+
+        ##
+        # This is an extension point for TimedStack and is called with a mutex.
+        #
+        # This method must return a connection from the stack.
+
+        def fetch_connection(options = nil)
+            @que.pop
+        end
+
+        ##
+        # This is an extension point for TimedStack and is called with a mutex.
+        #
+        # This method must shut down all connections on the stack.
+
+        def shutdown_connections(options = nil)
+            while connection_stored?(options)
+                conn = fetch_connection(options)
+                @shutdown_block.call(conn)
+            end
+        end
+
+        ##
+        # This is an extension point for TimedStack and is called with a mutex.
+        #
+        # This method must return +obj+ to the stack.
+
+        def store_connection(obj, options = nil)
+            @que.push obj
+        end
+
+        ##
+        # This is an extension point for TimedStack and is called with a mutex.
+        #
+        # This method must create a connection if and only if the total number of
+        # connections allowed has not been met.
+
+        def try_create(options = nil)
+            unless @created == @max
+                object = @create_block.call
+                @created += 1
+                object
+            end
+        end
+    end
+end

data/lib/woolen_common/connection_pool.rb

@@ -0,0 +1,149 @@
+require_relative 'connection_pool/timed_stack'
+
+
+# Generic connection pool class for e.g. sharing a limited number of network connections
+# among many threads.  Note: Connections are lazily created.
+#
+# Example usage with block (faster):
+#
+#    @pool = ConnectionPool.new { Redis.new }
+#
+#    @pool.with do |redis|
+#      redis.lpop('my-list') if redis.llen('my-list') > 0
+#    end
+#
+# Using optional timeout override (for that single invocation)
+#
+#    @pool.with(timeout: 2.0) do |redis|
+#      redis.lpop('my-list') if redis.llen('my-list') > 0
+#    end
+#
+# Example usage replacing an existing connection (slower):
+#
+#    $redis = ConnectionPool.wrap { Redis.new }
+#
+#    def do_work
+#      $redis.lpop('my-list') if $redis.llen('my-list') > 0
+#    end
+#
+# Accepts the following options:
+# - :size - number of connections to pool, defaults to 5
+# - :timeout - amount of time to wait for a connection if none currently available, defaults to 5 seconds
+#
+module WoolenCommon
+    class ConnectionPool
+        DEFAULTS = { size: 5, timeout: 5 }
+
+        class Error < RuntimeError
+        end
+
+        def self.wrap(options, &block)
+            Wrapper.new(options, &block)
+        end
+
+        def initialize(options = {}, &block)
+            raise ArgumentError, 'Connection pool requires a block' unless block
+
+            options = DEFAULTS.merge(options)
+
+            @size = options.fetch(:size)
+            @timeout = options.fetch(:timeout)
+
+            @available = TimedStack.new(@size, &block)
+            @key = :"current-#{@available.object_id}"
+        end
+
+        if Thread.respond_to?(:handle_interrupt)
+
+            # MRI
+            def with(options = {})
+                Thread.handle_interrupt(Exception => :never) do
+                    conn = checkout(options)
+                    begin
+                        Thread.handle_interrupt(Exception => :immediate) do
+                            yield conn
+                        end
+                    ensure
+                        checkin
+                    end
+                end
+            end
+
+        else
+
+            # jruby 1.7.x
+            def with(options = {})
+                conn = checkout(options)
+                begin
+                    yield conn
+                ensure
+                    checkin
+                end
+            end
+
+        end
+
+        def checkout(options = {})
+            conn = if stack.empty?
+                       timeout = options[:timeout] || @timeout
+                       @available.pop(timeout: timeout)
+                   else
+                       stack.last
+                   end
+
+            stack.push conn
+            conn
+        end
+
+        def checkin
+            conn = pop_connection # mutates stack, must be on its own line
+            @available.push(conn) if stack.empty?
+
+            nil
+        end
+
+        def shutdown(&block)
+            @available.shutdown(&block)
+        end
+
+        private
+
+        def pop_connection
+            if stack.empty?
+                raise ConnectionPool::Error, 'no connections are checked out'
+            else
+                stack.pop
+            end
+        end
+
+        def stack
+            ::Thread.current[@key] ||= []
+        end
+
+        class Wrapper < ::BasicObject
+            METHODS = [:with, :pool_shutdown]
+
+            def initialize(options = {}, &block)
+                @pool = options.fetch(:pool) { ::ConnectionPool.new(options, &block) }
+            end
+
+            def with(&block)
+                @pool.with(&block)
+            end
+
+            def pool_shutdown(&block)
+                @pool.shutdown(&block)
+            end
+
+            def respond_to?(id, *args)
+                METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
+            end
+
+            def method_missing(name, *args, &block)
+                with do |connection|
+                    connection.send(name, *args, &block)
+                end
+            end
+        end
+    end
+end

data/lib/woolen_common/ssh_proxy.rb

@@ -2,7 +2,7 @@
 begin
     require 'net/ssh' rescue nil
     require 'net/sftp' rescue nil
-    require 'connection_pool'
+    require "#{File.join(File.dirname(__FILE__), 'connection_pool')}"
     require "#{File.join(File.dirname(__FILE__), 'logger')}"
     module WoolenCommon
         class SshProxyPool
@@ -32,7 +32,7 @@ begin
             end
 
             def get_pool
-                @ssh_connection_pool ||= ::ConnectionPool.new({:size => @max_ssh, :timeout => @time_out}) do
+                @ssh_connection_pool ||= ::WoolenCommon::ConnectionPool.new({:size => @max_ssh, :timeout => @time_out}) do
                     debug "ip:#{@ip},@password:#{@password},@port:#{@port}"
                     ::WoolenCommon::SshProxy.new(@ip, @user, :password => @password, :port => @port)
                 end

data/lib/woolen_common/version.rb

@@ -1,3 +1,3 @@
 module WoolenCommon
-  VERSION = '0.0.7'
+  VERSION = '0.0.8'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: woolen_common
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - just_woolen
@@ -66,20 +66,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: connection_pool
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: The common helper for dev in ruby
 email:
 - just_woolen@qq.com
@@ -109,6 +95,9 @@ files:
 - lib/woolen_common/cache.rb
 - lib/woolen_common/common_helper.rb
 - lib/woolen_common/config_manager.rb
+- lib/woolen_common/connection_pool.rb
+- lib/woolen_common/connection_pool/monotonic_time.rb
+- lib/woolen_common/connection_pool/timed_stack.rb
 - lib/woolen_common/drb_helper.rb
 - lib/woolen_common/ffi/win32_kernel32.rb
 - lib/woolen_common/logger.rb