woolen_common 0.0.1

data/lib/woolen_common/abstract_middleware/map_cfg_manager.rb

@@ -0,0 +1,52 @@
+# -*- encoding : utf-8 -*-
+require "#{File.join(File.dirname(__FILE__),'..', 'logger')}"
+module WoolenCommon
+    module Middleware
+        class MapCfgManager
+            include WoolenCommon::ToolLogger
+            MERGE_TYPE_REPLACE = 'replace'
+            MERGE_TYPE_HASH = 'hash'
+            MERGE_TYPE_ARRAY = 'array'
+            attr_accessor :cfg_hash,:merge_type
+            def initialize(cfg_path,cfg_type='yml',merge_type = MERGE_TYPE_REPLACE)
+                case cfg_type
+                    when 'yml'
+                        @cfg_hash = YmlCfgManager.load cfg_path
+                    else
+                        error "不支持的配置文件格式:#{cfg_type}"
+                end
+                @merge_type = merge_type
+            end
+
+            def add_cfg(cfg_path,cfg_type='yml')
+                case cfg_type
+                    when 'yml'
+                        add_cfg = YmlCfgManager.load cfg_path
+                    else
+                        add_cfg = {}
+                        error "不支持的配置文件格式:#{cfg_type}"
+                end
+                @cfg_hash.merge! add_cfg do |key,old_val,new_val|
+                    case @merge_type
+                        when MERGE_TYPE_REPLACE
+                            ret_val = new_val
+                        when MERGE_TYPE_HASH
+                            ret_val = {:old_val=>old_val,:new_val=>new_val}
+                        when MERGE_TYPE_ARRAY
+                            ret_val = [new_val,old_val]
+                        else
+                            ret_val = old_val
+                    end
+                    trace "merge key :#{key},the old_val :#{old_val},the new_val :#{new_val},ret_val :#{ret_val}"
+                    ret_val
+                end
+            end
+        end
+
+        class YmlCfgManager
+            def self.load(path)
+                YAML.load_file(path) || {}
+            end
+        end
+    end
+end

data/lib/woolen_common/abstract_middleware/runner.rb

@@ -0,0 +1,72 @@
+# -*- encoding : utf-8 -*-
+module WoolenCommon
+    module Middleware
+        # This is a basic runner for middleware stacks. This runner does
+        # the default expected behavior of running the middleware stacks
+        # in order, then reversing the order.
+        class Runner
+            # A middleware which does nothing
+            EMPTY_MIDDLEWARE = lambda { |env| }
+
+            # Build a new middleware runner with the given middleware
+            # stack.
+            #
+            # Note: This class usually doesn't need to be used directly.
+            # Instead, take a look at using the {Builder} class, which is
+            # a much friendlier way to build up a middleware stack.
+            #
+            # @param [Array] stack An array of the middleware to run.
+            def initialize(stack)
+                # We need to take the stack of middleware and initialize them
+                # all so they call the proper next middleware.
+                @kickoff = build_call_chain(stack)
+            end
+
+            # Run the middleware stack with the given state bag.
+            #
+            # @param [Object] env The state to pass into as the initial
+            #   environment data. This is usual a hash of some sort.
+            def call(env)
+                # We just call the kickoff middleware, which is responsible
+                # for properly calling the next middleware, and so on and so
+                # forth.
+                @kickoff.call(env)
+            end
+
+            protected
+
+            # This takes a stack of middlewares and initializes them in a way
+            # that each middleware properly calls the next middleware.
+            def build_call_chain(stack)
+                # We need to instantiate the middleware stack in reverse
+                # order so that each middleware can have a reference to
+                # the next middleware it has to call. The final middleware
+                # is always the empty middleware, which does nothing but return.
+                stack.reverse.inject(EMPTY_MIDDLEWARE) do |next_middleware, current_middleware|
+                    # Unpack the actual item
+                    klass, args, block = current_middleware
+
+                    # Default the arguments to an empty array. Otherwise in Ruby 1.8
+                    # a `nil` args will actually pass `nil` into the class. Not what
+                    # we want!
+                    args ||= []
+
+                    if klass.is_a?(Class)
+                        # If the klass actually is a class, then instantiate it with
+                        # the app and any other arguments given.
+                        klass.new(next_middleware, *args, &block)
+                    elsif klass.respond_to?(:call)
+                        # Make it a lambda which calls the item then forwards up
+                        # the chain.
+                        lambda do |env|
+                            klass.call(env)
+                            next_middleware.call(env)
+                        end
+                    else
+                        raise "Invalid middleware, doesn't respond to `call`: #{klass.inspect}"
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/woolen_common/action_pool_proxy.rb

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+require 'singleton'
+require "#{File.join(File.dirname(__FILE__), 'actionpool')}"
+require "#{File.join(File.dirname(__FILE__), 'logger')}"
+# 防止1.8.7不存在
+class BasicObject
+end
+module WoolenCommon
+    class ActionPoolProxy < BasicObject
+        MAX_THREAD = 10
+
+        class << self
+            include WoolenCommon::ToolLogger
+            def get_pool
+                @action_pool ||= ::ActionPool::Pool.new(:min_thread => 1, :max_thread => MAX_THREAD)
+            end
+
+            def process(*args,&block)
+                trace "invoke the action pool process,args:#{args}"
+                begin
+                    self.get_pool.process(*args,&block)
+                rescue Exception => e
+                    error "we get the invoke process error::#{e.message}",e
+                end
+            end
+        end
+    end
+end

data/lib/woolen_common/actionpool.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+begin
+    require 'fastthread'
+rescue LoadError
+    # we don't care if it's available
+    # just load it if it's around
+end
+require "#{File.join(File.dirname(__FILE__), 'splib')}"
+Splib.load :Array, :Monitor
+require "#{File.join(File.dirname(__FILE__),'actionpool', 'pool')}"

data/lib/woolen_common/actionpool/pool.rb

@@ -0,0 +1,295 @@
+require "#{File.join(File.dirname(__FILE__), 'thread')}"
+require "#{File.join(File.dirname(__FILE__), 'queue')}"
+require 'logger'
+require 'thread'
+
+module ActionPool
+    # Raised when pool is closed
+    class PoolClosed < StandardError
+    end
+    class Pool
+
+        # :min_threads:: minimum number of threads in pool
+        # :max_threads:: maximum number of threads in pool
+        # :t_to:: thread timeout waiting for action to process
+        # :a_to:: maximum time action may be worked on before aborting
+        # :logger:: logger to print logging messages to
+        # Creates a new pool
+        def initialize(args={})
+            raise ArgumentError.new('Hash required for initialization') unless args.is_a?(Hash)
+            @logger = args[:logger] && args[:logger].is_a?(Logger) ? args[:logger] : Logger.new(nil)
+            @queue = ActionPool::Queue.new
+            @threads = []
+            @lock = Splib::Monitor.new
+            @thread_timeout = args[:t_to] ? args[:t_to] : 0
+            @action_timeout = args[:a_to] ? args[:a_to] : 0
+            @max_threads = args[:max_threads] ? args[:max_threads] : 100
+            @min_threads = args[:min_threads] ? args[:min_threads] : 10
+            @min_threads = @max_threads if @max_threads < @min_threads
+            @respond_to = args[:respond_thread] || ::Thread.current
+            @open = true
+            fill_pool
+        end
+
+        # Pool is closed
+        def pool_closed?
+            !@open
+        end
+
+        # Pool is open
+        def pool_open?
+            @open
+        end
+
+        # arg:: :open or :closed
+        # Set pool status
+        def status(arg)
+            @open = arg == :open
+            fill_pool if @open
+        end
+
+        # args::    :force forces a new thread. 
+        #           :nowait will create a thread if threads are waiting
+        # Create a new thread for pool.
+        # Returns newly created thread or nil if pool is at maximum size
+        def create_thread(*args)
+            return if pool_closed?
+            thread = nil
+            @lock.synchronize do
+                if(((size == working || args.include?(:nowait)) && @threads.size < @max_threads) || args.include?(:force))
+                    thread = ActionPool::Thread.new(:pool => self, :respond_thread => @respond_to, :a_timeout => @action_timeout,
+                        :t_timeout => @thread_timeout, :logger => @logger, :autostart => false)
+                    @threads << thread
+                end
+            end
+            thread.start if thread
+            thread
+        end
+
+        # Fills the pool with the minimum number of threads
+        # Returns array of created threads
+        def fill_pool
+            threads = []
+            if(@open)
+                @lock.synchronize do
+                    required = min - size
+                    if(required > 0)
+                        required.times do
+                            thread = ActionPool::Thread.new(:pool => self, :respond_thread => @respond_to,
+                                :a_timeout => @action_timeout, :t_timeout => @thread_timeout, :logger => @logger,
+                                :autostart => false)
+                            @threads << thread
+                            threads << thread
+                        end
+                    end
+                end
+            end
+            threads.each{|t|t.start}
+            threads
+        end
+
+        # force:: force immediate stop
+        # Stop the pool
+        def shutdown(force=false)
+            status(:closed)
+            args = []
+            args.push(:force) if force
+            @logger.info("Pool is now shutting down #{force ? 'using force' : ''}")
+            @queue.clear if force
+            @queue.wait_empty
+            while(t = @threads.pop) do
+                t.stop(*args)
+            end
+            unless(force)
+                flush
+                @threads.each{|t|t.join}
+            end
+            nil
+        end
+
+        # action:: proc to be executed or array of [proc, [*args]]
+        # Add a new proc/lambda to be executed (alias for queue)
+        def <<(action)
+            case action
+                when Proc
+                    queue(action)
+                when Array
+                    raise ArgumentError.new('Actions to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]') unless action.size == 2 and action[0].is_a?(Proc) and action[1].is_a?(Array)
+                    queue(action[0], action[1])
+                else
+                    raise ArgumentError.new('Actions to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]')
+            end
+            nil
+        end
+
+        # action:: proc to be executed
+        # Add a new proc/lambda to be executed
+        def queue(action, *args)
+            raise PoolClosed.new("Pool #{self} is currently closed") if pool_closed?
+            raise ArgumentError.new('Expecting block') unless action.is_a?(Proc)
+            @queue << [action, args]
+            ::Thread.pass
+            create_thread
+        end
+
+        # jobs:: Array of proc/lambdas
+        # Will queue a list of jobs into the pool
+        def add_jobs(jobs)
+            raise PoolClosed.new("Pool #{self} is currently closed") if pool_closed?
+            raise ArgumentError.new("Expecting an array but received: #{jobs.class}") unless jobs.is_a?(Array)
+            @queue.pause
+            begin
+                jobs.each do |job|
+                    case job
+                    when Proc
+                        @queue << [job, []]
+                    when Array
+                        raise ArgumentError.new('Jobs to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]') unless job.size == 2 and job[0].is_a?(Proc) and job[1].is_a?(Array)
+                        @queue << [job.shift, job]
+                    else
+                        raise ArgumentError.new('Jobs to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]')
+                    end
+                end
+            ensure
+                num = jobs.size - @threads.select{|t|t.waiting?}.size
+                num.times{ create_thread(:nowait) } if num > 0
+                @queue.unpause
+            end
+            true
+        end
+
+        # block:: block to process
+        # Adds a block to be processed
+        def process(*args, &block)
+            queue(block, *args)
+            nil
+        end
+
+        # Current size of pool
+        def size
+            @threads.size
+        end
+
+        # Maximum allowed number of threads
+        def max
+            @max_threads
+        end
+
+        # Minimum allowed number of threads
+        def min
+            @min_threads
+        end
+
+        # m:: new max
+        # Set maximum number of threads
+        def max=(m)
+            m = m.to_i
+            raise ArgumentError.new('Maximum value must be greater than 0') unless m > 0
+            @max_threads = m
+            @min_threads = m if m < @min_threads
+            resize if m < size
+            m
+        end
+
+        # m:: new min
+        # Set minimum number of threads
+        def min=(m)
+            m = m.to_i
+            raise ArgumentError.new("Minimum value must be greater than 0 and less than or equal to maximum (#{max})") unless m > 0 && m <= max
+            @min_threads = m
+            m
+        end
+
+        # t:: ActionPool::Thread to remove
+        # Removes a thread from the pool
+        def remove(t)
+            raise ArgumentError.new('Expecting an ActionPool::Thread object') unless t.is_a?(ActionPool::Thread)
+            t.stop
+            del = @threads.include?(t)
+            @threads.delete(t) if del
+            fill_pool
+            del
+        end
+
+        # Maximum number of seconds a thread
+        # is allowed to idle in the pool. 
+        # (nil means thread life is infinite)
+        def thread_timeout
+            @thread_timeout
+        end
+
+        # Maximum number of seconds a thread
+        # is allowed to work on a given action
+        # (nil means thread is given unlimited
+        # time to work on action)
+        def action_timeout
+            @action_timeout
+        end
+
+        # t:: timeout in seconds (nil for infinite)
+        # Set maximum allowed time thead may idle in pool
+        def thread_timeout=(t)
+            t = t.to_f
+            raise ArgumentError.new('Value must be greater than zero or nil') unless t >= 0
+            @thread_timeout = t
+            @threads.each{|thread|thread.thread_timeout = t}
+            t
+        end
+
+        # t:: timeout in seconds (nil for infinte)
+        # Set maximum allowed time thread may work
+        # on a given action
+        def action_timeout=(t)
+            t = t.to_f
+            raise ArgumentError.new('Value must be greater than zero or nil') unless t >= 0
+            @action_timeout = t
+            @threads.each{|thread|thread.action_timeout = t}
+            t
+        end
+
+        # Returns the next action to be processed
+        def action
+            @queue.pop
+        end
+
+        # Number of actions in the queue
+        def action_size
+            @queue.size
+        end
+
+        # Flush the thread pool. Mainly used for forcibly resizing
+        # the pool if existing threads have a long thread life waiting
+        # for input.
+        def flush
+            mon = Splib::Monitor.new
+            @threads.size.times{ queue{ mon.wait } }
+            @queue.wait_empty
+            sleep(0.01)
+            mon.broadcast
+        end
+
+        # Returns current number of threads in the pool working
+        def working
+            @threads.select{|t|t.running?}.size
+        end
+
+        def thread_stats
+            @threads.map{|t|[t.object_id,t.status]}
+        end
+
+        private
+
+        # Resize the pool
+        def resize
+            @logger.info("Pool is being resized to stated maximum: #{max}")
+            until(size <= max) do
+                t = nil
+                t = @threads.find{|t|t.waiting?}
+                t = @threads.shift unless t
+                t.stop
+            end
+            flush
+            nil
+        end
+    end
+end