woolen_common 0.0.1

data/lib/woolen_common/system_monitor/linux_monitor.rb

@@ -0,0 +1,250 @@
+# -*- encoding : utf-8 -*-
+module WoolenCommon
+    module LinuxMonitor
+        include WoolenCommon::ToolLogger
+        LINUX_CPU_STAT='/proc/stat'
+        LINUX_MEM_STAT='/proc/meminfo'
+        LINUX_DISK_STAT='/proc/diskstats'
+        LINUX_DISK_PARTITION_STAT='/proc/partitions'
+        SYS_NET_PATH = '/sys/class/net'
+
+        CPU_STAT_FORMAT = %w{cpu user nice system idle io_wait irq soft_irq steal guest}
+        DISK_STAT_FORMAT = %w{disk r_io/s w_io/s r_kB/s w_kB/s r_size w_size}
+
+        # cpu 432661    13295   86656       422145968   171474      233     5346        0               0
+        # cpu {user}    {nice}  {system}    {idle}      {iowait}    {irq}   {softirq}   {stealstolen}   {guest}
+        # user (432661) 从系统启动开始累计到当前时刻，用户态的CPU时间（单位：jiffies） ，不包含 nice值为负进程。1jiffies=0.01秒
+        #nice (13295) 从系统启动开始累计到当前时刻，nice值为负的进程所占用的CPU时间（单位：jiffies）
+        #system (86656) 从系统启动开始累计到当前时刻，核心[系统调用]时间（单位：jiffies）
+        #idle (422145968) 从系统启动开始累计到当前时刻，除硬盘IO等待时间以外其它等待时间（单位：jiffies）
+        #iowait (171474) 从系统启动开始累计到当前时刻，硬盘IO等待时间（单位：jiffies） ，
+        #irq (233) 从系统启动开始累计到当前时刻，硬中断时间（单位：jiffies）
+        #softirq (5346) 从系统启动开始累计到当前时刻，软中断时间（单位：jiffies）
+        #stealstolen(0)     which is the time spent in other operating systems when running in a virtualized environment(since 2.6.11)
+        #guest(0)        which is the time spent running a virtual  CPU  for  guest operating systems under the control of the Linux kernel(since 2.6.24)
+        def get_one_cpu_usage(old, new)
+            ret_hash = {}
+            old_array = old.split(/\s+/)
+            new_array = new.split(/\s+/)
+            # trace "old[#{old}] split #{old_array}"
+            # trace "new[#{new}] split #{new_array}"
+            old_sum = 0
+            new_sum = 0
+            old_array.each { |str| old_sum += str.to_i }
+            new_array.each { |str| new_sum += str.to_i }
+            delta_sum = (new_sum - old_sum).to_f
+            ideal_delta = new_array[4].to_i - old_array[4].to_i
+            # debug "length #{new_array.length} old sum[#{old_sum}] new_sum[#{new_sum}] delta_sum[#{delta_sum}] ideal_delta[#{ideal_delta}]"
+            ret_hash['total'] = ((1 - (ideal_delta) / (delta_sum)) * 100).round(3)
+            0.upto CPU_STAT_FORMAT.length-1 do |cnt|
+                # debug "checking cnt[#{cnt}]"
+                if new_array[cnt]
+                    if cnt == 0
+                        ret_hash[CPU_STAT_FORMAT[cnt]] = new_array[cnt]
+                    else
+                        delta = new_array[cnt].to_i - old_array[cnt].to_i
+                        # debug "cpu [#{CPU_STAT_FORMAT[cnt]}] delta #{delta}"
+                        ret_hash[CPU_STAT_FORMAT[cnt]] = (((delta) / (delta_sum)) * 100).round(3)
+                    end
+                else
+                    debug "not have #{CPU_STAT_FORMAT[cnt]} cnt[#{cnt}]"
+                end
+            end
+            ret_hash
+        end
+
+        def get_system_cpu_usage(time=1)
+            result = []
+            old_arry = File.open(LINUX_CPU_STAT, 'r') { |f| f.read.split("\n") }
+            sleep time
+            new_arry = File.open(LINUX_CPU_STAT, 'r') { |f| f.read.split("\n") }
+            0.upto old_arry.length do |cnt|
+                if old_arry[cnt] =~ /^cpu/
+                    the_cpu_usage = get_one_cpu_usage old_arry[cnt].strip, new_arry[cnt].strip
+                    result << the_cpu_usage
+                end
+            end
+            result
+        end
+
+        def get_system_mem_usage
+            mem_array = File.open(LINUX_MEM_STAT, 'r') { |f| f.read.split("\n") }
+            total_mem = 0
+            available_mem = 0
+            mem_array.each do |one_line|
+                line = one_line.strip.downcase
+                case line
+                    when /MemTotal/i
+                        total_mem = line.gsub(/\D/, '').to_i
+                        debug "total mem #{total_mem}"
+                    when /MemFree/i
+                        available_mem = line.gsub(/\D/, '').to_i
+                        debug "available_mem #{available_mem}"
+                    else
+                        trace "line[#{line}]"
+                end
+            end
+
+            if total_mem > 0
+                ((total_mem - available_mem) / total_mem.to_f * 100).round 3
+            else
+                error "can not get total mem from #{mem_array}"
+                nil
+            end
+        end
+
+
+        def get_one_disk_status(old_line, new_line, delta_time)
+            old_arr = old_line.split(/\s+/)
+            new_arr = new_line.split(/\s+/)
+            new = new_arr.drop(2)
+            old = old_arr.drop(2)
+            block_size = File.open("/sys/dev/block/#{new_arr[0]}:#{new_arr[1]}/queue/logical_block_size", 'r') { |f| f.read }.to_i
+            if old[0] != new[0]
+                error "wrong dis check line old[#{old_line}] new[#{new_line}]"
+            end
+            r_iops = ((new[1].to_i - old[1].to_i) / delta_time).round(2)
+            w_iops = ((new[5].to_i - old[5].to_i) / delta_time).round(2)
+            r_sec_s = ((new[3].to_i - old[3].to_i) / delta_time).round(2)
+            w_sec_s = ((new[7].to_i - old[7].to_i) / delta_time).round(2)
+            debug "r_iops[#{r_iops}],w_iops[#{w_iops}],r_sec_s[#{r_sec_s}],w_sec_s[#{w_sec_s}],block_size[#{block_size}]"
+            r_kb_s = r_sec_s * block_size / 8
+            w_kb_s = w_sec_s * block_size / 8
+            if r_iops == 0
+                r_size = 0
+            else
+                r_size = r_kb_s / r_iops
+            end
+            if w_iops == 0
+                w_size = 0
+            else
+                w_size = w_kb_s / w_iops
+            end
+            {
+                'disk' => new[0],
+                'r_io/s' => r_iops,
+                'w_io/s' => w_iops,
+                'r_kB/s' => r_kb_s,
+                'w_kB/s' => w_kb_s,
+                'r_size' => r_size,
+                'w_size' => w_size
+            }
+        end
+
+        def get_disk_hash
+            real_disk = {}
+            disk_array = File.open(LINUX_DISK_PARTITION_STAT, 'r') { |f| f.read.split("\n") }
+            0.upto(disk_array.length-1) do |cnt|
+                unless cnt == 0
+                    one_arr = disk_array[cnt].strip.split(/\s+/)
+                    trace "str[#{disk_array[cnt].strip}]one arr #{one_arr}"
+                    if one_arr[1] == '0'
+                        if real_disk[one_arr[3]]
+                            warn "already get disk #{one_arr[3]} id #{real_disk[one_arr[3]]}"
+                        else
+                            real_disk[one_arr[3]] = one_arr[0]
+                        end
+                    end
+                end
+            end
+            real_disk
+        end
+
+        def get_io_status(time=5)
+            result = []
+            disk_hash = get_disk_hash
+            old_disk_arr = File.open(LINUX_DISK_STAT, 'r') { |f| f.read.split("\n") }.each { |one| one.strip! }
+            old_time = Time.now.to_i
+            sleep time
+            new_disk_arr = File.open(LINUX_DISK_STAT, 'r') { |f| f.read.split("\n") }.each { |one| one.strip! }
+            new_time = Time.now.to_i
+            disk_hash.each do |one_disk, disk_id|
+                0.upto(old_disk_arr.length - 1) do |cnt|
+                    if old_disk_arr[cnt] =~ Regexp.new("^#{disk_id}\\s+0\\s+#{one_disk}")
+                        result << get_one_disk_status(old_disk_arr[cnt], new_disk_arr[cnt], (new_time - old_time))
+                    end
+                end
+            end
+            result
+        end
+
+        def get_net_name(filepath=SYS_NET_PATH)
+            net_name = []
+            if File.directory?(filepath)
+                Dir.foreach(filepath) do |filename|
+                    if filename != "." and filename != ".." and filename != "lo"
+                        net_name << filename
+                    end
+                end
+            else
+                puts "Files:" + filepath
+            end
+            net_name
+        end
+
+
+        def get_net_bytes
+            net_name = get_net_name
+            hash_tmp = {}
+            net_name.each do |one_name|
+                hash_tmp[one_name] = {}
+                File.open("/sys/class/net/#{one_name}/statistics/tx_bytes", 'r') do |f|
+                    hash_tmp[one_name]['tx_bytes'] = f.read.strip
+                end
+                File.open("/sys/class/net/#{one_name}/statistics/rx_bytes", 'r') do |f|
+                    hash_tmp[one_name]['rx_bytes'] = f.read.strip
+                end
+            end
+            hash_tmp
+        end
+
+        def get_system_net_speed
+            old_hash = get_net_bytes
+            puts old_hash
+
+            sleep 1
+            new_hash = get_net_bytes
+            puts new_hash
+            hash_tmp = {}
+            new_hash.each do |key, value|
+                hash_tmp[key] = {}
+                hash_tmp[key]['tx_bytes'] = value['tx_bytes'].to_i - old_hash[key]['tx_bytes'].to_i
+                hash_tmp[key]['rx_bytes'] = value['rx_bytes'].to_i - old_hash[key]['rx_bytes'].to_i
+            end
+            hash_tmp
+        end
+
+        def get_common_performance(monitor_cfg)
+            performance_hash = {}
+            performance_hash['cpu'] = get_system_cpu_usage[0]['total']
+            performance_hash['memory'] = get_system_mem_usage
+
+            ret_disk_arr = get_io_status
+            if ret_disk_arr
+                performance_hash['r_iops'] = ret_disk_arr[0]['r_io/s']
+                performance_hash['w_iops'] = ret_disk_arr[0]['w_io/s']
+                performance_hash['r_kBps'] = ret_disk_arr[0]['r_kB/s']
+                performance_hash['w_kBps'] = ret_disk_arr[0]['w_kB/s']
+            end
+
+            #get_system_net_speed获取所有网卡的传输速率，前台仅显示eth0的速率
+            ret_net_hash = get_system_net_speed
+            if ret_net_hash
+                monitor_cfg['net_if_ids'].each do |one_if_id|
+                    if ret_net_hash["eth#{one_if_id}"]
+                        performance_hash['net_tx_bytes'] = ret_net_hash["eth#{one_if_id}"]['tx_bytes']
+                        performance_hash['net_rx_bytes'] = ret_net_hash["eth#{one_if_id}"]['rx_bytes']
+                    end
+                end
+            end
+            performance_hash
+        end
+
+
+        def self.included(base)
+            base.extend self
+        end
+
+        module_function :get_system_cpu_usage
+    end
+end

data/lib/woolen_common/system_monitor/windows_monitor.rb

@@ -0,0 +1,145 @@
+# -*- encoding : utf-8 -*-
+require "#{File.join(File.dirname(__FILE__), '../ffi', 'win32_kernel32')}"
+module WoolenCommon
+    module WindowsMonitor
+
+        MIB_IFROW = 4
+        MIB_IFROW_SIZE = 860 #MIB_IFROW结构体大小
+        MIB_IFROW_dwIndex = 512
+        MIB_IFROW_OutOctets = 576 #dwOutOctets位置偏移
+        MIB_IFROW_InOctets = 552 #dwInOctets位置偏移
+
+        MIB_IFTABLE_SIZE = 28392 #MIB_IFTABLE结构体大小
+
+        IP_ADAPTER_ADDRESSES_SIZE = 4044 #IP_ADAPTER_ADDRESSES结构体大小
+        FRIENDLY_NAME = 26412 #本地连接字符串转成short
+        IP_ADAPTER_ADDRESSES_FriendlyName = 40 #接口名称偏移
+        IP_ADAPTER_ADDRESSES_IfIndex = 4 #接口索引偏移
+        IP_ADAPTER_ADDRESSES_Next = 8 #下一个结构体Next字段偏移
+		
+
+        def compare_file_time(time1, time2)
+            a = time1[:dwHighDateTime] << 32 | time1[:dwLowDateTime]
+            b = time2[:dwHighDateTime] << 32 | time2[:dwLowDateTime]
+            b - a
+        end
+
+        def get_system_cpu_usage(time=1)
+            p_idle_time = FFI::MemoryPointer.new(Win32Kernel32::Filetime.size)
+            p_kernel_time = FFI::MemoryPointer.new(Win32Kernel32::Filetime.size)
+            p_user_time = FFI::MemoryPointer.new(Win32Kernel32::Filetime.size)
+            idle_time = Win32Kernel32::Filetime.new p_idle_time
+            kernel_time = Win32Kernel32::Filetime.new p_kernel_time
+            usr_time = Win32Kernel32::Filetime.new p_user_time
+            p_pre_idle_time = FFI::MemoryPointer.new(Win32Kernel32::Filetime.size)
+            p_pre_kernel_time = FFI::MemoryPointer.new(Win32Kernel32::Filetime.size)
+            p_pre_user_time = FFI::MemoryPointer.new(Win32Kernel32::Filetime.size)
+            pre_idle_time = Win32Kernel32::Filetime.new p_pre_idle_time
+            pre_kernel_time = Win32Kernel32::Filetime.new p_pre_kernel_time
+            pre_usr_time = Win32Kernel32::Filetime.new p_pre_user_time
+            Win32Kernel32.getSystemTimes(p_pre_idle_time, p_pre_kernel_time, p_pre_user_time)
+            sleep time
+            Win32Kernel32.getSystemTimes(p_idle_time, p_kernel_time, p_user_time)
+            idle = compare_file_time(pre_idle_time, idle_time)
+            ker = compare_file_time(pre_kernel_time, kernel_time)
+            usr = compare_file_time(pre_usr_time, usr_time)
+            (ker + usr - idle) *100 / (ker + usr)
+        end
+
+        def get_system_mem_usage
+            p_ms_adder= FFI::MemoryPointer.new(Win32Kernel32::MemoryStatus.size)
+            p_ms = Win32Kernel32::MemoryStatus.new p_ms_adder
+            Win32Kernel32.globalMemoryStatus(p_ms);
+            p_ms[:dwMemoryLoad]
+        end
+
+        def get_system_disk_info
+            sz_driver = FFI::MemoryPointer.from_string('\\\\.\\PhysicalDrive0')
+            ptr1 = FFI::MemoryPointer.new(:uint)
+            ptr2 = FFI::MemoryPointer.new(:uint)
+            junk1 = 0
+            junk2 = 0
+            p_disk_perform_adder1= FFI::MemoryPointer.new(Win32Kernel32::Disk_Perfomance.size)
+            p_disk_perform1 = Win32Kernel32::Disk_Perfomance.new p_disk_perform_adder1
+            h_device = Win32Kernel32.createFileA(sz_driver, 0, Win32Kernel32::OPEN_EXISTING, 0, Win32Kernel32::OPEN_EXISTING, 0, 0)
+            Win32Kernel32.deviceIoControl(h_device, Win32Kernel32::IOCTL_DISK_PERFORMANCE, 0, 0, p_disk_perform1, Win32Kernel32::Disk_Perfomance.size, ptr1, 0);
+            puts "BytesRead:#{p_disk_perform1[:BytesRead]} BytesWritten:#{p_disk_perform1[:BytesWritten]} ReadCount:#{p_disk_perform1[:ReadCount]} WriteCount:#{p_disk_perform1[:WriteCount]}"
+            sleep 1
+            p_disk_perform_adder2= FFI::MemoryPointer.new(Win32Kernel32::Disk_Perfomance.size)
+            p_disk_perform2 = Win32Kernel32::Disk_Perfomance.new p_disk_perform_adder2
+            Win32Kernel32.deviceIoControl(h_device, Win32Kernel32::IOCTL_DISK_PERFORMANCE, 0, 0, p_disk_perform2, Win32Kernel32::Disk_Perfomance.size, ptr2, 0);
+            #puts "BytesRead:#{p_disk_perform2[:BytesRead]} BytesWritten:#{p_disk_perform2[:BytesWritten]} ReadCount:#{p_disk_perform2[:ReadCount]} WriteCount:#{p_disk_perform2[:WriteCount]}"
+            ret_disk_arr =[]
+            ret_disk_arr << (p_disk_perform2[:BytesRead] - p_disk_perform1[:BytesRead])/1000.to_f
+            ret_disk_arr << (p_disk_perform2[:BytesWritten] - p_disk_perform1[:BytesWritten])/1000.to_f
+            ret_disk_arr << p_disk_perform2[:ReadCount] - p_disk_perform1[:ReadCount]
+            ret_disk_arr << p_disk_perform2[:WriteCount] - p_disk_perform1[:WriteCount]
+            ret_disk_arr
+        end
+
+
+        #返回数组发送字节/S和接受字节每秒
+        def get_system_network_info(net_if_ids)
+            ret_arr = []
+            net_if_ids.each do |one_if_id|
+                pre_net_arr = get_network_info_by_index(one_if_id.to_i)
+                sleep 1
+                next_net_arr = get_network_info_by_index(one_if_id.to_i)
+                ret_arr << (next_net_arr[0] - pre_net_arr[0]) #发送字节数/秒
+                ret_arr << (next_net_arr[1] - pre_net_arr[1]) #接收字节数/秒
+            end
+            ret_arr
+        end
+
+        #通过本地连接的索引获取本地连接接口发送和接受字节数组
+        def get_network_info_by_index(index=14)
+            net_arr = []
+            ptr_iftable = FFI::MemoryPointer.new(MIB_IFTABLE_SIZE)
+            iftable_size_ptr = FFI::MemoryPointer.new(:uint)
+            iftable_size = MIB_IFTABLE_SIZE
+            iftable_size_ptr.write_uint iftable_size
+            iftable_size_ptr.read_uint
+            dw_ret = Win32Kernel32.getIfTable(ptr_iftable, iftable_size_ptr, 0)
+            dw_num = ptr_iftable.read_uint
+            pifrow_start = (ptr_iftable + MIB_IFROW)
+            pifrow_end = pifrow_start + dw_num * MIB_IFROW_SIZE
+            while pifrow_start.address < pifrow_end.address do
+                if_index = (pifrow_start + MIB_IFROW_dwIndex).read_uint
+                if if_index == index
+                    out_bytes = (pifrow_start + MIB_IFROW_OutOctets).read_uint
+                    in_bytes = (pifrow_start + MIB_IFROW_InOctets).read_uint
+                    net_arr << out_bytes
+                    net_arr << in_bytes
+                    break
+                end
+                pifrow_start = pifrow_start + MIB_IFROW_SIZE
+            end
+            net_arr
+
+        end
+
+        def get_common_performance(monitor_cfg)
+            performance_hash = {}
+            performance_hash['cpu'] = get_system_cpu_usage
+            performance_hash['memory'] = get_system_mem_usage
+
+            ret_disk = get_system_disk_info
+            if ret_disk
+                performance_hash['r_kBps'] = ret_disk[0]
+                performance_hash['w_kBps'] = ret_disk[1]
+                performance_hash['r_iops'] = ret_disk[2]
+                performance_hash['w_iops'] = ret_disk[3]
+            end
+            net_disk = get_system_network_info(monitor_cfg['net_if_ids'])
+            if net_disk
+                performance_hash['net_tx_bytes'] = net_disk[0]
+                performance_hash['net_rx_bytes'] = net_disk[1]
+            end
+            performance_hash
+        end
+
+        def self.included(base)
+            base.extend self
+        end
+    end
+end

data/lib/woolen_common/type_helper.rb

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+require "#{File.join(File.dirname(__FILE__), 'logger')}"
+module WoolenCommon
+    class TypeHelper
+        class << self
+            include WoolenCommon::ToolLogger
+            def to_signed(number, bits)
+                mask = (1 << (bits - 1))
+                (number & ~mask) - (number & mask)
+            end
+
+            def to_unsigned(number, bits)
+                mask_high = (1 << (bits - 1))
+                mask_low = 0
+                (bits-1).times do |step_bit|
+                    mask_low += (1 << (step_bit))
+                end
+                high = number & mask_high
+                low = number & mask_low
+                #debug "to unsigned #{high},#{low}"
+                high + low
+            end
+
+            def get_high_bit_num(number,all_bits,high_start_bits)
+                bits_mask = 0
+                (high_start_bits..all_bits-1).each do |step_bit|
+                    bits_mask += (1 << (step_bit))
+                end
+                number & bits_mask
+            end
+
+
+            def get_low_bit_num(number,hight_start_bits)
+                bits_mask = 0
+                (0..hight_start_bits-1).each do |step_bit|
+                    bits_mask += (1 << (step_bit))
+                end
+                number & bits_mask
+            end
+        end
+    end
+end

data/lib/woolen_common/ver_ctrl_middle_ware.rb

@@ -0,0 +1,92 @@
+# -*- encoding : utf-8 -*-
+require "#{File.join(File.dirname(__FILE__), 'abstract_middleware','builder')}"
+require "#{File.join(File.dirname(__FILE__), 'abstract_middleware','runner')}"
+require "#{File.join(File.dirname(__FILE__), 'logger')}"
+module WoolenCommon
+    #  根据某个目录下的源程序，生成中间件调用队列
+    class VerCtrlMiddleWare
+        include WoolenCommon::ToolLogger
+        attr_accessor :ver_match_hash
+        def initialize(class_file_dir,&ver_ctrl_block)
+            debug "init the AbstractMiddleWare with class dir ::#{class_file_dir}"
+            @ver_match_hash = {}
+            if File.directory? class_file_dir
+                @class_dir = Dir.new(class_file_dir)
+            else
+                fatal "目录:#{class_file_dir}不存在,无法从中加载相关中间件代码"
+            end
+            @class_dir.each do |one_file|
+                file_str = File.join(File.realdirpath(@class_dir),one_file)
+                if File.directory? file_str
+                    trace "file_str :#{file_str} 是个目录"
+                    next
+                end
+                # 只加载ruby源程序
+                if File.extname(file_str) == '.rb' || File.extname(file_str) == '.ruby'
+                    base_file_name = File.basename(file_str,(File.extname(file_str)))
+                    class_name = base_file_name.split('_').map!{|k| k.capitalize}.join ''
+                    trace "加载文件:#{file_str},获得的类名是:#{class_name}"
+                    File.open(file_str,'r') do |file|
+                        self.instance_eval file.read,file_str
+                    end
+                    #self.instance_eval "load '#{file_str}',true;"
+                    k_class = self.instance_eval class_name
+                    if block_given?
+                        int_ver = ver_ctrl_block.call k_class::VERSION
+                    else
+                        int_ver = k_class::VERSION.to_i
+                    end
+                    trace "file:#{file_str},version:#{k_class::VERSION},int_version:#{int_ver}"
+                    if @ver_match_hash[int_ver]
+                        warn "int_version :#{int_ver} 已经有类了：#{@ver_match_hash[int_ver]},略过当前类的加入：#{k_class}"
+                        next
+                    else
+                        @ver_match_hash[int_ver] = k_class
+                    end
+                else
+                    warn "目录:#{@class_dir.to_s}下的文件:#{file_str}不是ruby代码"
+                end
+            end
+            trace "获取到的hash sort后是：#{@ver_match_hash.sort}"
+        end
+
+        def add_ver_class(int_ver,k_class,force=false)
+            if int_ver.is_a? Integer
+                if @ver_match_hash[int_ver]
+                    warn "尝试添加一个ver:#{int_ver}已经存在的k_clas:#{@ver_match_hash[int_ver]},尝试添加的class:#{k_class}"
+                    if force
+                        info "需要强制添加类:#{k_class}"
+                        @ver_match_hash[int_ver] = k_class
+                    end
+                else
+                    @ver_match_hash[int_ver] = k_class
+                end
+            else
+                warn "ver 不是integen：#{int_ver},要添加的class:#{k_class}"
+            end
+        end
+
+        def del_ver_class_by_ver(int_ver)
+            if int_ver.is_a? Integer
+                if @ver_match_hash[int_ver]
+                    debug "删除一个ver:#{int_ver}"
+                    @ver_match_hash.delete int_ver
+                else
+                    debug "ver :#{int_ver} 不存在"
+                end
+            else
+                warn "ver不是integen：#{int_ver}"
+            end
+        end
+
+        def call(*args,&block)
+            middle_ware_stack = Middleware::Builder.new
+            sort_middle_ware_array = @ver_match_hash.sort
+            sort_middle_ware_array.reverse.each do |int_ver,k_class|
+                trace "添加ver:#{int_ver} 的class:#{k_class}"
+                middle_ware_stack.use k_class,*args,&block
+            end
+            middle_ware_stack.call binding
+        end
+    end
+end