woolen_common 0.0.1

data/lib/woolen_common/common_helper.rb

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+require "#{File.join(File.dirname(__FILE__), 'logger')}"
+module WoolenCommon
+    class CommonHelper
+        include WoolenCommon::ToolLogger
+
+        class << self
+            def wait_until_stopped
+                info 'Press ENTER or c-C to stop it'
+                $stdout.flush
+                begin
+                    loop do
+                        sleep 1
+                    end
+                rescue Interrupt
+                    info 'Interrupt'
+                end
+            end
+
+            def run_project_bin(program,param_str)
+                program_name = get_real_path(WoolenCommon::ConfigManager.project_root,'bin',program)
+                trace "need to run bin [#{program_name} #{param_str}]"
+                if WoolenCommon::SystemHelper.windows?
+                    cmd = "#{program_name} #{param_str}".to_gbk
+                    `#{cmd}`.to_utf8
+                else
+                    cmd = "#{program_name} #{param_str}"
+                    `#{cmd}`
+                end
+            end
+
+            def get_real_path(*args, &block)
+                file_path = File.expand_path(File.join(*args))
+                if block_given?
+                    yield block file_path
+                    return file_path
+                end
+                file_path
+            end
+        end
+    end
+end

data/lib/woolen_common/config_manager.rb

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+require 'yaml'
+module WoolenCommon
+    class ConfigManager
+        class << self
+            attr_accessor :project_root
+
+=begin
+	功能: 获取配置
+	描述:
+	      先设置好项目的根目录,如D:/ACAT3.1
+		  返回为YAML对象的D:/ATCAT3.1/config/xx.yml
+	参数: name 配置文件的名字
+	返回值:
+		  YAML对象
+	       未设置root,抛出RuntimeErorr
+		   配置不存在,抛出RuntimeErorr
+	举例:
+		  ConfigureManager.root = $root
+		  puts ConfigureManager.get("test")['test']
+=end
+            def get(name)
+                name += ".yml" unless name.match(/.yml$/)
+                name = name
+                raise "not set root path, please use ConfigureManager.root=() to set it" if project_root.nil?
+                path = File.join(project_root, "config", name) #File.join(root,"config",name).to_gbk
+                path = File.expand_path(path)
+                #~ path = Pathname.new(path).realpath
+                raise "The special config path #{path} not exist" unless File.exist?(path)
+                #  because empty file when get 'false' so we add {} return value.
+                YAML.load_file(path) || {}
+            end
+        end
+    end
+end
+# WoolenCommon::ConfigManager.project_root = File.expand_path(File.join(File.dirname(__FILE__),'..','..','..'))

data/lib/woolen_common/drb_helper.rb

@@ -0,0 +1,125 @@
+# -*- encoding : utf-8 -*-
+require 'drb'
+require "#{File.join(File.dirname(__FILE__), 'logger')}"
+module WoolenCommon
+    SERVER_DEFAULT_PORT = 108801
+    CLIENT_DEFAULT_PORT = 108802
+    DEFAULT_CLIENT_ADDR = '127.0.0.1'
+    module DrbHelp
+        def get_rand_port
+            rand(55534) + 8000
+        end
+        def get_drb_connect_obj(connect_str)
+            begin
+                DRbObject.new_with_uri(connect_str)
+            rescue Exception=>e
+                error "获取客户端的连接信息时出错：：#{e.message}"
+                return nil
+            end
+        end
+
+        def ip_or_iport_with_default(ip_or_iport, default_port)
+            default_port = default_port.to_s
+            if ! ip_or_iport.include?(':')
+                iport = ip_or_iport + ':' + default_port
+            else
+                iport = ip_or_iport
+            end
+            ip2druby(iport)
+        end
+
+        def ip2druby(ip)
+            unless ip.include?('://')
+                return "druby://" + ip
+            end
+            ip
+        end
+
+        def start_service(service_addr,service_obj = nil)
+            if service_obj
+                DRb.start_service(service_addr,service_obj)
+            else
+                DRb.start_service(service_addr)
+            end
+        end
+
+        module_function :get_drb_connect_obj, :ip_or_iport_with_default, :ip2druby,:start_service,:get_rand_port
+    end
+
+    module DrbServerHelper
+        include DrbHelp
+        include WoolenCommon::ToolLogger
+
+        def server_init(me='127.0.0.1')
+            me_drb_addr = ip_or_iport_with_default(me, SERVER_DEFAULT_PORT)
+            @worker_connect_array = []
+            @worker_connect_array_mutex = Mutex.new
+            debug "server need to start #{me_drb_addr}"
+            @me_service = start_service(me_drb_addr,self)
+        end
+
+        def on_one_worker_connect(worker_ip)
+            debug "get one the worker #{worker_ip}"
+            worker_connect_str = ip_or_iport_with_default worker_ip,CLIENT_DEFAULT_PORT
+            # debug "connect str #{worker_connect_str}"
+            worker_connect = get_drb_connect_obj worker_connect_str
+            worker_id = 0
+            @worker_connect_array_mutex.synchronize do
+                @worker_connect_array << worker_connect
+                worker_id = @worker_connect_array.length
+            end
+            worker_id
+        end
+
+        # 需要阻塞的时候的阻塞函数
+        def wait_until_stopped
+            puts 'Flow replay worker started.  Press ENTER or c-C to stop it'
+            $stdout.flush
+            begin
+                STDIN.gets
+            rescue Interrupt
+                puts "Interrupt"
+            end
+        end
+        module_function :server_init
+
+    end
+
+    module DrbClientHelper
+        include DrbHelp
+        include WoolenCommon::ToolLogger
+
+        def client_init(server_addr='127.0.0.1',my_port=nil)
+            the_port = my_port
+            if my_port
+                @my_url = "druby://0.0.0.0:#{my_port}"
+                @me_service = start_service(@my_url,self)
+            else
+                100.times do
+                    begin
+                        port = get_rand_port
+                        the_port = port
+                        if server_addr == '127.0.0.1'
+                            @my_url = "druby://127.0.0.1:#{port}"
+                        else
+                            @my_url = "druby://0.0.0.0:#{port}"
+                        end
+                        debug "client need to try url #{@my_url}"
+                        @me_service = start_service(@my_url,self)
+                        break
+                    rescue Exception => e
+                        error "在使用随机端口时出错了#{e.message}"
+                        retry
+                    end
+                end
+            end
+            debug "server addr ::#{server_addr},port#{SERVER_DEFAULT_PORT}"
+            server_str = ip_or_iport_with_default(server_addr,SERVER_DEFAULT_PORT)
+            @server_service = get_drb_connect_obj(server_str)
+            url = "druby://#{DEFAULT_CLIENT_ADDR}:#{the_port}"
+            debug "the server#{@server_service}need to invoke worker connect url::#{url}"
+            @server_service.on_one_worker_connect(url)
+        end
+        module_function :client_init
+    end
+end

data/lib/woolen_common/ffi/win32_kernel32.rb

@@ -0,0 +1,86 @@
+# -*- encoding : utf-8 -*-
+require 'ffi'
+module WoolenCommon
+    module Win32Kernel32
+        STD_INPUT_HANDLE = 0xfffffff6
+        STD_OUTPUT_HANDLE = 0xfffffff5
+        STD_ERROR_HANDLE = 0xfffffff4
+
+        #磁盘需要用到的常量
+        FILE_SHARE_READ = 0x00000000
+        FILE_SHARE_WRITE = 0x00000002
+        OPEN_EXISTING = 3
+        IOCTL_DISK_PERFORMANCE = 458784
+        wszDrive = "\\\\.\\PhysicalDrive0"
+
+        class Filetime < FFI::Struct
+            layout :dwLowDateTime, :uint,
+                   :dwHighDateTime, :uint
+        end
+
+        class MemoryStatus < FFI::Struct
+            layout :dwLength, :uint,
+                   :dwMemoryLoad, :uint,
+                   :dwTotalPhys, :uint,
+                   :dwAvailPhys, :uint,
+                   :dwTotalPageFile, :uint,
+                   :dwAvailPageFile, :uint,
+                   :dwTotalVirtual, :uint,
+                   :dwAvailVirtual, :uint
+        end
+
+        class Disk_Perfomance < FFI::Struct
+            layout :BytesRead, :int64,
+                   :BytesWritten, :int64,
+                   :ReadTime, :int64,
+                   :WriteTime, :int64,
+                   :IdleTime, :int64,
+                   :ReadCount, :uint,
+                   :WriteCount, :uint,
+                   :QueueDepth, :uint,
+                   :SplitCount, :uint,
+                   :QueryTime, :int64,
+                   :StorageDeviceNumber, :uint,
+                   :StorageManagerName, [:ushort, 8]
+        end
+
+
+        extend FFI::Library
+        ffi_lib 'kernel32'
+
+        # 设置输出格式
+        attach_function :setConsoleTextAttribute, # method name  (your choice)
+                        :SetConsoleTextAttribute, # DLL function name (given)
+                        [:uint, :uint], :int
+        # 获取标准输出的Handle
+        attach_function :getStdHandle, # method name  (your choice)
+                        :GetStdHandle, # DLL function name (given)
+                        [:uint], :uint # specify C param / return value types
+        # 获取标准输出的Handle
+        attach_function :getSystemTimes, # method name  (your choice)
+                        :GetSystemTimes, # DLL function name (given)
+                        [:pointer, :pointer, :pointer], :int # specify C param / return value types
+        # 查询内存状态API
+        attach_function :globalMemoryStatus, # method name  (your choice)
+                        :GlobalMemoryStatus, # DLL function name (given)
+                        [:pointer], :void # specify C param / return value types
+        #创建物理磁盘文件
+        attach_function :createFileA, # method name  (your choice)
+                        :CreateFileA, # DLL function name (given)
+                        [:pointer, :uint, :uint, :int, :uint, :uint, :int], :pointer # specify C param / return value types
+        #获取磁盘数据API
+        attach_function :deviceIoControl, # method name  (your choice)
+                        :DeviceIoControl, # DLL function name (given)
+                        [:pointer, :uint, :int, :uint, :pointer, :uint, :pointer, :int], :int # specify C param / return value types
+        ffi_lib 'iphlpapi'
+        #获取网络数据API
+        attach_function :getIfTable, # method name  (your choice)
+                        :GetIfTable, # DLL function name (given)
+                        [:pointer, :pointer, :int], :uint # specify C param / return value types
+        attach_function :getAdaptersAddresses, # method name  (your choice)
+                        :GetAdaptersAddresses, # DLL function name (given)
+                        [:uint, :uint, :int, :pointer, :pointer], :uint # specify C param / return value types
+
+
+    end
+end

data/lib/woolen_common/logger.rb

@@ -0,0 +1,419 @@
+# -*- encoding : utf-8 -*-
+require 'logger'
+require 'yaml'
+require 'fileutils'
+require 'pathname'
+require "#{File.join(File.dirname(__FILE__), 'system_helper')}"
+require "#{File.join(File.dirname(__FILE__), 'config_manager')}"
+module WoolenCommon
+    class MyLogger # :nodoc: all
+        include SystemHelper
+        LEVELS = ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL']
+        COLORS = { 'TRACE' => 'white', 'DEBUG' => 'silver', 'INFO' => 'green', 'WARN' => 'yellow', 'ERROR' => 'purple', 'FATAL' => 'red' }
+        FOREGROUND_BLUE = 1
+        FOREGROUND_GREEN = 2
+        FOREGROUND_RED = 4
+        FOREGROUND_INTENSITY = 8
+        BACKGROUND_BLUE = 16
+        BACKGROUND_GREEN = 32
+        BACKGROUND_RED = 64
+        BACKGROUND_INTENSITY = 128
+        WIN32COLORS = [
+            "default", "black", "navy", "green",
+            "teal", "maroon", "purple", "olive",
+            "silver", "gray", "blue", "lime",
+            "aqua", "red", "fuchsia", "yellow",
+            "white"
+        ]
+        WIN32_FOREGROUND_COLOR_MOD = [
+            -1, 0,
+            FOREGROUND_BLUE, FOREGROUND_GREEN, FOREGROUND_BLUE | FOREGROUND_GREEN,
+            FOREGROUND_RED, FOREGROUND_BLUE | FOREGROUND_RED, FOREGROUND_RED | FOREGROUND_GREEN,
+            FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
+        ]
+        WIN32_BACKGROUND_COLOR_MOD = [
+            -1, 0,
+            BACKGROUND_BLUE, BACKGROUND_GREEN, BACKGROUND_BLUE | BACKGROUND_GREEN,
+            BACKGROUND_RED, BACKGROUND_BLUE | BACKGROUND_RED, BACKGROUND_RED | BACKGROUND_GREEN,
+            BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED
+        ]
+        # WIN_PRINTER = Pathname.new(File.join(__FILE__, '..', '..', '..', 'bin', 'puts_color.exe')).realpath.to_s
+        attr_reader :file, :stdout, :name
+        attr_accessor :level, :log_cache, :cache_msg, :cache_count
+
+        LOGGERS = []
+
+        def linux_puts_color(message, color = nil)
+            case color
+                when 'red'
+                    color = '31;1'
+                when 'green'
+                    color = '32;1'
+                when 'yellow'
+                    color = '33;1'
+                when 'blue'
+                    color = '34;1'
+                when 'purple'
+                    color = '35;1'
+                when 'silver'
+                    color = '36;1'
+                when 'white'
+                    color = '37;1'
+                else
+                    color = ''
+            end
+            if color == ''
+                print "#{message}\n"
+            else
+                print "\e[#{color}m#{message}\e[0m\n"
+            end
+        end
+
+        def win32_puts_color(message, color)
+            require "#{File.join(File.dirname(__FILE__), 'ffi', 'win32_kernel32')}"
+            the_out_handle = Win32Kernel32.getStdHandle Win32Kernel32::STD_OUTPUT_HANDLE
+            if WIN32COLORS.include? color
+                if WIN32COLORS.index(color) >= WIN32_FOREGROUND_COLOR_MOD.length
+                    the_color_mod = WIN32_FOREGROUND_COLOR_MOD[WIN32COLORS.index(color) % WIN32_FOREGROUND_COLOR_MOD.length] | FOREGROUND_INTENSITY
+                else
+                    the_color_mod = WIN32_FOREGROUND_COLOR_MOD[WIN32COLORS.index(color)]
+                end
+            end
+            Win32Kernel32.setConsoleTextAttribute the_out_handle, 0x00ff & the_color_mod
+            printf "#{message}\n"
+            Win32Kernel32.setConsoleTextAttribute the_out_handle, 0x00ff & (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED)
+        end
+
+        def my_puts(message, color = nil)
+            if windows?
+                win32_puts_color message, color
+            else
+                linux_puts_color message, color
+            end
+        end
+
+
+        def initialize(attrs = {})
+            #puts "=> init logger with: #{attrs.inspect}"
+            @stdout = (attrs[:stdout] == 1)
+            @name = attrs[:name]
+            @filename = attrs[:file].gsub(/\.log/,".#{Process.pid}.log")
+            FileUtils.mkdir_p(File.dirname(@filename))
+            @roll_type = attrs[:roll_type]
+            @roll_param = attrs[:roll_param]
+            @log_cache = attrs[:log_cache].blank? ? 1 : attrs[:max_log_cnt].to_i
+            @max_log_cnt = attrs[:max_log_cnt].blank? ? 10 : attrs[:max_log_cnt].to_i
+            @cache_msg = {}
+            @cache_count = 0
+            @caller = attrs[:caller] || 1
+            if @roll_type == "file_size" && @roll_param && (@roll_param = @roll_param.to_s)
+                size = nil
+                if @roll_param.index("K")
+                    size = @roll_param.to_i * 1024
+                elsif @roll_param.index("M")
+                    size = @roll_param.to_i * 1024 * 1024
+                end
+                @roll_param = size
+            end
+            @level = LEVELS.index(attrs[:level].upcase) || 1
+            @last_log_time = nil
+            clean_log @filename
+            @file = File.open(@filename, "a+") if @filename
+            # clean_log
+        end
+
+
+        def self.loggers
+            return LOGGERS
+        end
+
+        def self.add_log(logger)
+            LOGGERS << logger
+        end
+
+        def self.get(name)
+            LOGGERS.each do |__log__|
+                if __log__.name == name
+                    return __log__
+                end
+            end
+        end
+
+        attr_writer :caller
+
+        def rename_and_create_new(newfilename)
+            # fix Error::EACCESS exception throw when file is opened before rename by lyf
+            begin
+                @file.flush
+                @file.close
+                FileUtils.cp(@file.path, newfilename)
+                clean_log @file.path
+                @file.reopen(@file.path, "w")
+            rescue Exception => e
+                puts "error when try to  rename_and_create_new #{newfilename}"
+            end
+            #unless (FileUtils.cp(@file.path, newfilename) and FileUtils.rm_f(@file.path) and @file.reopen(@file.path, "w"))
+            #    #puts "==> error rename #{@filename} => #{newfilename}"
+            #end
+        end
+
+        def clean_log(the_path)
+            log_patten = File.join(File.dirname(the_path), '*.log')
+            # puts "need clean #{the_path}"
+            FileUtils.rm_f(the_path)
+            sort_time_files = Dir[log_patten].sort_by { |file| test(?M, file) }
+            # puts "sort_time_files #{sort_time_files}"
+            if @max_log_cnt && @max_log_cnt > 0 && sort_time_files.length > @max_log_cnt
+                (sort_time_files.length - @max_log_cnt).times do |cnt|
+                    puts "need to del #{sort_time_files[cnt]} cnt #{cnt}"
+                    FileUtils.rm_f sort_time_files[cnt]
+                end
+            end
+        end
+
+        def check_split_file
+            begin
+                if @roll_type == "daily"
+                    if @last_log_time && @last_log_time.day != Time.now.day
+                        p = @file.path
+                        new_name = nil
+                        if p.rindex(".") > p.rindex("/")
+                            new_name = "#{p[0, p.rindex(".")]}.#{@last_log_time.strftime("%Y-%m-%d")}#{p[p.rindex("."), p.length]}"
+                        else
+                            new_name = "#{p}.#{@last_log_time.strftime("%Y-%m-%d")}"
+                        end
+                        rename_and_create_new(new_name)
+                    end
+                elsif @roll_type == "file_size"
+                    if File.size(@file) >= @roll_param
+                        p = @file.path
+                        new_name = nil
+                        if p.rindex(".") > p.rindex("/")
+                            new_name = "#{p[0, p.rindex(".")]}.#{Time.now.strftime("%Y%m%d%H%M")}#{p[p.rindex("."), p.length]}"
+                        else
+                            new_name = "#{p}.#{Time.now.strftime("%Y%m%d%H%M")}"
+                        end
+                        rename_and_create_new(new_name)
+                    end
+                end
+            rescue Exception => e
+                puts "\n============= log error msg:#{e.message}!!! =============\n"
+            end
+        end
+
+        def truncate
+            @file.truncate(0)
+            @file.flush
+        end
+
+        def log(_level, msg, err = nil)
+            begin
+                check_split_file if @file
+                err_msg = nil
+                line = ''
+                if caller[@caller].respond_to? :include?
+                    #my_puts "proj root ::#{ConfigManager.project_root}"
+                    line = find_the_project_caller_line(@caller)
+                else
+                    line = caller[1].gsub(ConfigManager.project_root, '')
+                end
+                _msg = "#{_level},Thread::#{Thread.current},#{Time.now.strftime("%y-%m-%d %H:%M:%S")}\n#{line}: #{msg}"
+                _msg += "\n" if msg[-1] != "\n"
+                if $stdouttype == "GBK"
+                    _msg = _msg.to_gbk
+                end
+                err_msg = "#{err.message}\n#{err.backtrace.join("\n\t")}" if err
+                the_key = _level.strip
+                @cache_msg[the_key] ||= ''
+                @cache_msg[the_key] << _msg
+                @cache_msg[the_key] << err_msg if err_msg
+                if @cache_count < @log_cache.to_i
+                    @cache_count += 1
+                else
+                    file_need_to_pus_cache = ''
+                    the_msg_cache = @cache_msg
+                    @cache_count = 0
+                    @cache_msg = {}
+                    the_msg_cache.each do |key, value|
+                        my_puts value, COLORS[key] if @stdout
+                        #puts "need to log with #{@file} [#{value}]"
+                        file_need_to_pus_cache << value
+                        #@file.dup if @file
+                    end
+                    if @file
+                        @file.print file_need_to_pus_cache
+                        @file.flush
+                    end
+                end
+                @last_log_time = Time.now
+            rescue Exception => e
+                puts "\n==========log error !!! err msg is [#{e.message}][stack::#{e.backtrace.join("\n")}] you need to log is \n#{_msg}\n"
+            end
+        end
+
+        def find_the_project_caller_line(the_caller)
+            line = ''
+            the_caller += 1
+            loop do
+                if caller[the_caller].respond_to? :include?
+                    #my_puts "caller::#{the_caller}====#{caller[the_caller]}"
+                    if caller[the_caller].include? ConfigManager.project_root and not caller[the_caller].include? __FILE__
+                        #my_puts "===get the caller ::#{the_caller} #{caller[the_caller]} "
+                        line = caller[the_caller].gsub(ConfigManager.project_root, '')
+                        break
+                    end
+                    the_caller += 1
+                else
+                    line = caller[3].gsub(ConfigManager.project_root, '')
+                    break
+                end
+            end
+            line
+        end
+
+        def soft(*msg)
+            log('SOFT ', msg.join(','), nil) if true
+            nil
+        end
+
+        def trace(msg, err = nil)
+            log('TRACE ', msg, err) if @level == 0
+            nil
+        end
+
+        def debug(msg, err = nil)
+            log('DEBUG ', msg, err) if @level <= 1
+            nil
+        end
+
+        def info(msg, err = nil)
+            log('INFO  ', msg, err) if @level <= 2
+            nil
+        end
+
+        def warn(msg, err = nil)
+            log('WARN  ', msg, err) if @level <= 3
+            nil
+        end
+
+        def error(msg, err = nil)
+            log('ERROR ', msg, err) if @level <= 4
+            nil
+        end
+
+        def fatal(msg, err = nil)
+            log('FATAL ', msg, err)
+            nil
+        end
+
+        def debug?
+            @level == 1
+        end
+
+        def info?
+            @level >= 2
+        end
+
+        def add(*)
+        end
+    end
+
+
+    class SingleLogger
+        class << self
+            attr_accessor :logger_config, :my_logger
+        end
+
+        def self.get_conf
+            the_cfg_file = File.expand_path(File.join(ConfigManager.project_root, 'config', 'logger.yml'))
+            if SingleLogger.logger_config.blank?
+                if File.exist?(the_cfg_file)
+                    SingleLogger.logger_config = YAML.load_file(the_cfg_file)
+                end
+            end
+            return SingleLogger.logger_config if SingleLogger.logger_config
+            {}
+        end
+
+        key = get_conf['default'] || 'dev'
+        log_cfg = get_conf[key] || {}
+        SingleLogger.my_logger ||= MyLogger.new({ :stdout => log_cfg['stdout'] || 1, :name => key,
+                                                  :file => File.join(ConfigManager.project_root, log_cfg['file'] || './log/dev.log'),
+                                                  :roll_type => log_cfg['roll_type'] || 'file_size',
+                                                  :roll_param => log_cfg['roll_param'] || '5M',
+                                                  :max_log_cnt => log_cfg['max_log_cnt'] || 10,
+                                                  :level => log_cfg['level'] || 'debug',
+                                                  :log_cache => log_cfg['log_cache'] || 0,
+                                                  :caller => 2 })
+
+        def self.new(*args)
+            SingleLogger.my_logger || super(*args)
+        end
+
+        def self.get_logger
+            SingleLogger.my_logger || self.new()
+        end
+
+        def initialize(*args)
+            SingleLogger.my_logger || super(*args)
+        end
+
+
+        def self.method_missing(*arg)
+            SingleLogger.my_logger.send(*arg)
+        end
+    end
+    module ToolLogger
+        def log(*arg)
+            SingleLogger.get_logger.log(*arg)
+        end
+
+        def trace(*arg)
+            SingleLogger.get_logger.trace(*arg)
+        end
+
+        def debug(*arg)
+            SingleLogger.get_logger.debug(*arg)
+        end
+
+        def info(*arg)
+            SingleLogger.get_logger.info(*arg)
+        end
+
+        def warn(*arg)
+            SingleLogger.get_logger.warn(*arg)
+        end
+
+        def error(*arg)
+            SingleLogger.get_logger.error(*arg)
+        end
+
+        def fatal(*arg)
+            SingleLogger.get_logger.fatal(*arg)
+            raise arg[1]
+        end
+
+        def debug?
+            SingleLogger.get_logger.debug?
+        end
+
+        def info?
+            SingleLogger.get_logger.info?
+        end
+
+        module_function :log, :trace, :debug, :info, :warn, :error, :fatal, :debug?, :info?
+
+        def self.included(base)
+            base.extend self
+        end
+
+        #def method_missing(*arg)
+        #    SingleLogger.get_logger.send(*arg)
+        #end
+
+        def self.method_missing(*arg)
+            SingleLogger.get_logger.send(*arg)
+        end
+    end
+end
+#TestTool::ToolLogger.error("123")