woolen_common 0.0.1

data/lib/woolen_common/actionpool/queue.rb

@@ -0,0 +1,41 @@
+require 'thread'
+
+module ActionPool
+    # Adds a little bit extra functionality to the Queue class
+    class Queue < ::Queue
+        # Create a new Queue for the ActionPool::Pool
+        def initialize
+            super
+            @wait = false
+            @pause_guard = Splib::Monitor.new
+            @empty_guard = Splib::Monitor.new
+        end
+        # Stop the queue from returning results to requesting
+        # threads. Threads will wait for results until signalled
+        def pause
+            @wait = true
+        end
+        # Allow the queue to return results. Any threads waiting
+        # will have results given to them.
+        def unpause
+            @wait = false
+            @pause_guard.broadcast
+        end
+        # Check if queue needs to wait before returning
+        def pop
+            @pause_guard.wait_while{ @wait }
+            o = super
+            @empty_guard.broadcast if empty?
+            return o
+        end
+        # Clear queue
+        def clear
+            super
+            @empty_guard.broadcast
+        end
+        # Park a thread here until queue is empty
+        def wait_empty
+            @empty_guard.wait_while{ size > 0 }
+        end
+    end
+end

data/lib/woolen_common/actionpool/thread.rb

@@ -0,0 +1,181 @@
+require 'timeout'
+
+module ActionPool
+    # Exception class used for waking up a thread
+    class Wakeup < StandardError
+    end
+    # Raised within a thread when the timeout is changed
+    class Retimeout < StandardError
+    end
+    class Thread
+        # :pool:: pool thread is associated with
+        # :t_timeout:: max time a thread is allowed to wait for action
+        # :a_timeout:: max time thread is allowed to work
+        # :respond_thread:: thread to send execptions to
+        # :logger:: LogHelper for logging messages
+        # :autostart:: Automatically start the thread
+        # Create a new thread
+        def initialize(args)
+            raise ArgumentError.new('Hash required for initialization') unless args.is_a?(Hash)
+            raise ArgumentError.new('ActionPool::Thread requires a pool') unless args[:pool]
+            raise ArgumentError.new('ActionPool::Thread requries thread to respond') unless args[:respond_thread]
+            @pool = args[:pool]
+            @respond_to = args[:respond_thread]
+            @thread_timeout = args[:t_timeout] ? args[:t_timeout].to_f : 0
+            @action_timeout = args[:a_timeout] ? args[:a_timeout].to_f : 0
+            args[:autostart] = true unless args.has_key?(:autostart)
+            @kill = false
+            @logger = args[:logger].is_a?(Logger) ? args[:logger] : Logger.new(nil)
+            @lock = Splib::Monitor.new
+            @action = nil
+            @thread = args[:autostart] ? ::Thread.new{ start_thread } : nil
+        end
+
+        def start
+            @thread = ::Thread.new{ start_thread } if @thread.nil?
+        end
+        
+        # :force:: force the thread to stop
+        # :wait:: wait for the thread to stop
+        # Stop the thread
+        def stop(*args)
+            @kill = true
+            if(args.include?(:force) || waiting?)
+                begin
+                    @thread.raise Wakeup.new
+                rescue Wakeup
+                    #ignore since we are the caller
+                end
+                sleep(0.01)
+                @thread.kill if @thread.alive?
+            end
+            nil
+        end
+
+        # Currently waiting
+        def waiting?
+            @action.nil?
+#             @status == :wait
+        end
+
+        # Currently running
+        def running?
+            !@action.nil?
+#             @status == :run
+        end
+
+        # Is the thread still alive
+        def alive?
+            @thread.alive?
+        end
+
+        # Current thread status
+        def status
+            @action
+        end
+
+        # Join internal thread
+        def join
+            @thread.join(@action_timeout)
+            if(@thread.alive?)
+                @thread.kill
+                @thread.join
+            end
+        end
+
+        # Kill internal thread
+        def kill
+            @thread.kill
+        end
+
+        # Seconds thread will wait for input
+        def thread_timeout
+            @thread_timeout
+        end
+
+        # Seconds thread will spend working on a given task
+        def action_timeout
+            @action_timeout
+        end
+
+        # t:: seconds to wait for input (floats allow for values 0 < t < 1)
+        # Set the maximum amount of time to wait for a task
+        def thread_timeout=(t)
+            t = t.to_f
+            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
+            @thread_timeout = t
+            @thread.raise Retimeout.new if waiting?
+            t
+        end
+
+        # t:: seconds to work on a task (floats allow for values 0 < t < 1)
+        # Set the maximum amount of time to work on a given task
+        # Note: Modification of this will not affect actions already in process
+        def action_timeout=(t)
+            t = t.to_f
+            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
+            @action_timeout = t
+            t
+        end
+
+        private
+
+        # Start our thread
+        def start_thread
+            begin
+                @logger.info("New pool thread is starting (#{self})")
+                until(@kill) do
+                    begin
+                        @action = nil
+                        if(@pool.size > @pool.min && !@thread_timeout.zero?)
+                            Timeout::timeout(@thread_timeout) do
+                                @action = @pool.action
+                            end
+                        else
+                            @action = @pool.action
+                        end
+                        run(@action[0], @action[1]) unless @action.nil?
+                    rescue Timeout::Error
+                        @kill = true
+                    rescue Wakeup
+                        @logger.info("Thread #{::Thread.current} was woken up.")
+                    rescue Retimeout
+                        @logger.warn('Thread was woken up to reset thread timeout')
+                    rescue Exception => boom
+                        @logger.error("Pool thread caught an exception: #{boom}\n#{boom.backtrace.join("\n")}")
+                        @respond_to.raise boom
+                    end
+                end
+            rescue Retimeout
+                @logger.warn('Thread was woken up to reset thread timeout')
+                retry
+            rescue Wakeup
+                @logger.info("Thread #{::Thread.current} was woken up.")
+            rescue Exception => boom
+                @logger.error("Pool thread caught an exception: #{boom}\n#{boom.backtrace.join("\n")}")
+                @respond_to.raise boom
+            ensure
+                @logger.info("Pool thread is shutting down (#{self})")
+                @pool.remove(self)
+            end
+        end
+
+        # action:: task to be run
+        # args:: arguments to be passed to task
+        # Run the task
+        def run(action, args)
+            args = args.respond_to?(:fixed_flatten) ? args.fixed_flatten(1) : args.flatten(1)
+            begin
+                unless(@action_timeout.zero?)
+                    Timeout::timeout(@action_timeout) do
+                        action.call(*args)
+                    end
+                else
+                    action.call(*args)
+                end
+            rescue Timeout::Error => boom
+                @logger.warn("Pool thread reached max execution time for action: #{boom}")
+            end
+        end
+    end
+end

data/lib/woolen_common/addr_helper.rb

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+require "#{File.join(File.dirname(__FILE__), 'logger')}"
+require "#{File.join(File.dirname(__FILE__), 'common_helper')}"
+require "#{File.join(File.dirname(__FILE__), 'type_helper')}"
+require 'ipaddr'
+module WoolenCommon
+    class AddrHelper
+        class << self
+            include WoolenCommon::ToolLogger
+            # IP地址字符串转做数值(无符号的)
+            def ip_str_to_unsigned(ip_addr_str)
+                IPAddr.new(ip_addr_str).to_i
+            end
+
+            # IP地址字符串转做数值(有符号的)
+            def ip_str_to_signed(ip_addr_str,byte_length=32)
+                begin
+                    return TypeHelper.to_signed(IPAddr.new(ip_addr_str).to_i, byte_length)
+                rescue Exception=>e
+                    debug "对IP地址[#{ip_addr_str}]，进行转换到有符号数字出错::#{e.message}"
+                    return 0
+                end
+            end
+
+            # 有符号地址值转成ip字符串
+            def signed_to_ip_str(signed,byte_length=32)
+                unsigned_32 = TypeHelper.to_unsigned(signed,byte_length)
+                IPAddr.new(unsigned_32,Socket::AF_INET).to_s
+            end
+
+            # 无符号地址值转成ip字符串
+            def unsigned_to_ip_str(unsigned_32)
+                IPAddr.new(unsigned_32,Socket::AF_INET).to_s
+            end
+
+            # mac地址字符串转成无符号数字数组
+            def mac_str_to_array(mac_str)
+                if mac_str.kind_of? String
+                    if mac_str.include? ':'
+                        split_arry = mac_str.split ':'
+                    elsif mac_str.include? '-'
+                        split_arry = mac_str.split '-'
+                    elsif mac_str.length == 12
+                        split_arry = []
+                        6.times do |cnt|
+                            split_arry << mac_str[(2 * cnt)... (2 * (cnt+1))]
+                        end
+                    else
+                        debug "not support mac format:[#{mac_str}],please use : or - format"
+                        return []
+                    end
+                    if split_arry.length != 6
+                        debug "to long format:[#{mac_str}]~"
+                        return []
+                    end
+                    return_array=[]
+                    split_arry.each do |split_str|
+                        return_array << split_str.to_i(16)
+                    end
+                    return_array
+                else
+                    error "not support not string format:[#{mac_str}],please give me a mac string"
+                end
+            end
+
+            # mac地址无符号数字数组转字符串
+            def array_to_mac_str(mac_array,str_gap=':')
+                debug "start to get mac str from mac array :: #{mac_array}"
+                if mac_array.kind_of? Array
+                    if mac_array.length != 6
+                        error "wrong long arry :[#{mac_array}]~"
+                        return ''
+                    else
+                        ret_str_array = []
+                        mac_array.each do |mac_int_x16|
+                            mac_value = TypeHelper.get_low_bit_num(mac_int_x16,8)
+                            if mac_value >= 16
+                                ret_str_array << mac_value.to_s(16)
+                            elsif mac_value >= 0 && mac_int_x16 < 16
+                                ret_str_array << "0#{mac_value.to_s(16)}"
+                            end
+                        end
+                        debug "success get mac str ::#{ret_str_array.join str_gap}"
+                        return ret_str_array.join str_gap
+                    end
+                else
+                    error "not a array mac please give me a array::#{mac_array}~"
+                    ''
+                end
+            end
+        end
+    end
+end

data/lib/woolen_common/cache.rb

@@ -0,0 +1,305 @@
+# -*- encoding : utf-8 -*-
+#! /usr/bin/env ruby
+#
+# Copyright (C) 2002  Yoshinori K. Okuji <okuji@enbug.org>
+#
+# You may redistribute it and/or modify it under the same term as Ruby.
+
+# Cache manager based on the LRU algorithm.
+require "#{File.join(File.dirname(__FILE__), 'logger')}"
+module WoolenCommon
+    class Cache
+        include ToolLogger
+
+        CACHE_OBJECT = Struct.new('CacheObject', :content, :size, :atime)
+        CACHE_VERSION = '0.3'
+
+        include Enumerable
+
+        def self.version
+            CACHE_VERSION
+        end
+
+        # initialize(max_obj_size = nil, max_size = nil, max_num = nil,
+        #            expiration = nil, &hook)
+        # initialize(hash, &hook)
+        def initialize(*args, &hook)
+            if args.size == 1 and args[0].kind_of?(Hash)
+                @max_obj_size = @max_size = @max_num = @expiration = nil
+                args[0].each do |k, v|
+                    k = k.intern if k.respond_to?(:intern)
+                    case k
+                        when :max_obj_size
+                            @max_obj_size = v
+                        when :max_size
+                            @max_size = v
+                        when :max_num
+                            @max_num = v
+                        when :expiration
+                            @expiration = v
+                        else
+                            warn "cache unknown key :#{k}=>#{v}"
+                    end
+                end
+            else
+                @max_obj_size, @max_size, @max_num, @expiration = args
+            end
+
+            # Sanity checks.
+            if @max_obj_size and @max_size and @max_obj_size > @max_size
+                raise ArgumentError, "max_obj_size exceeds max_size (#{@max_obj_size} > #{@max_size})"
+            end
+            if @max_obj_size and @max_obj_size <= 0
+                raise ArgumentError, "invalid max_obj_size `#{@max_obj_size}'"
+            end
+            if @max_size and @max_size <= 0
+                raise ArgumentError, "invalid max_size `#{@max_size}'"
+            end
+            if @max_num and @max_num <= 0
+                raise ArgumentError, "invalid max_num `#{@max_num}'"
+            end
+            if @expiration and @expiration <= 0
+                raise ArgumentError, "invalid expiration `#{@expiration}'"
+            end
+
+            @hook = hook
+
+            @objs = {}
+            @size = 0
+            @list = []
+
+            @hits = 0
+            @misses = 0
+        end
+
+        attr_reader :max_obj_size, :max_size, :max_num, :expiration
+
+        def cached?(key)
+            @objs.include?(key)
+        end
+
+        alias :include? :cached?
+        alias :member? :cached?
+        alias :key? :cached?
+        alias :has_key? :cached?
+
+        def cached_value?(val)
+            self.each_value do |v|
+                return true if v == val
+            end
+            false
+        end
+
+        alias :has_value? :cached_value?
+        alias :value? :cached_value?
+
+        def index(val)
+            self.each_pair do |k, v|
+                return k if v == val
+            end
+            nil
+        end
+
+        def keys
+            @objs.keys
+        end
+
+        def length
+            @objs.length
+        end
+
+        alias :size :length
+
+        def to_hash
+            @objs.dup
+        end
+
+        def values
+            @objs.collect { |key, obj| obj.content }
+        end
+
+        def invalidate(key)
+            obj = @objs[key]
+            if obj
+                if @hook
+                    @hook.call(key, obj.content)
+                end
+                @size -= obj.size
+                @objs.delete(key)
+                @list.each_index do |i|
+                    if @list[i] == key
+                        @list.delete_at(i)
+                        break
+                    end
+                end
+            elsif block_given?
+                return yield(key)
+            end
+            obj.content
+        end
+
+        alias :delete :invalidate
+
+        def invalidate_all
+            if @hook
+                @objs.each do |key, obj|
+                    @hook.call(key, obj)
+                end
+            end
+
+            @objs.clear
+            @list.clear
+            @size = 0
+        end
+
+        alias :clear :invalidate_all
+
+        def expire
+            if @expiration
+                now = Time.now.to_i
+                @list.each_index do |i|
+                    key = @list[i]
+
+                    break unless @objs[key].atime + @expiration <= now
+                    self.invalidate(key)
+                end
+            end
+#    GC.start
+        end
+
+        def [](key)
+            self.expire
+
+            unless @objs.include?(key)
+                @misses += 1
+                return nil
+            end
+
+            obj = @objs[key]
+            obj.atime = Time.now.to_i
+
+            @list.each_index do |i|
+                if @list[i] == key
+                    @list.delete_at(i)
+                    break
+                end
+            end
+            @list.push(key)
+
+            @hits += 1
+            obj.content
+        end
+
+        def []=(key, obj)
+            self.expire
+
+            if self.cached?(key)
+                self.invalidate(key)
+            end
+
+            size = obj.to_s.size
+            if @max_obj_size and @max_obj_size < size
+                debug("warning: `#{obj.inspect}' isn't cached because its size exceeds #{@max_obj_size}")
+                return obj
+            end
+            if @max_obj_size.nil? and @max_size and @max_size < size
+                debug("warning: `#{obj.inspect}' isn't cached because its size exceeds #{@max_size}")
+                return obj
+            end
+
+            if @max_num and @max_num == @list.size
+                self.invalidate(@list.first)
+            end
+
+            @size += size
+            if @max_size
+                while @max_size < @size
+                    self.invalidate(@list.first)
+                end
+            end
+
+            @objs[key] = CACHE_OBJECT.new(obj, size, Time.now.to_i)
+            @list.push(key)
+
+            obj
+        end
+
+        def store(key, value)
+            self[key] = value
+        end
+
+        def each_pair
+            @objs.each do |key, obj|
+                yield key, obj.content
+            end
+            self
+        end
+
+        alias :each :each_pair
+
+        def each_key
+            @objs.each_key do |key|
+                yield key
+            end
+            self
+        end
+
+        def each_value
+            @objs.each_value do |obj|
+                yield obj.content
+            end
+            self
+        end
+
+        def empty?
+            @objs.empty?
+        end
+
+        def fetch(key, default = nil)
+            val = self[key]
+            if val.nil?
+                if default
+                    val = self[key] = default
+                elsif block_given?
+                    val = self[key] = yield(key)
+                else
+                    raise IndexError, "invalid key `#{key}'"
+                end
+            end
+            val
+        end
+
+        # The total size of cached objects, the number of cached objects,
+        # the number of cache hits, and the number of cache misses.
+        def state_statics
+            [@size, @list.size, @hits, @misses]
+        end
+    end
+
+# Run a test, if executed.
+    if __FILE__ == $0
+        cache = Cache.new(100 * 1024, 100 * 1024 * 1024, 256, 13)
+        1000.times do
+            key = rand(1000)
+            cache[key] = key.to_s
+        end
+        1000.times do
+            key = rand(1000)
+            puts cache[key]
+        end
+        sleep 1
+        1000.times do
+            key = rand(1000)
+            puts cache[key]
+        end
+
+        stat = cache.state_statics
+        hits = stat[2]
+        misses = stat[3]
+        ratio = hits.to_f / (hits + misses)
+
+        puts "Total size:\t#{stat[0]}"
+        puts "Number:\t\t#{stat[1]}"
+        puts "Hit ratio:\t#{ratio * 100}% (#{hits} / #{hits + misses})"
+    end
+end