分析目录下所有Eudemon防火墙配置的Python脚本


分析目录下所有Eudemon防火墙配置的Python脚本:

  1. # coding=gb2312   
  2.   
  3. ''''' 
  4. Created on 2011-8-26 
  5.  
  6. @author: piky 
  7. '''  
  8.   
  9. from os.path import walk, join, normpath  
  10. import sys  
  11. import os.path  
  12. from os import getcwd  
  13. import re  
  14. import MySQLdb  
  15. import time  
  16.   
  17. #判断str是否符合正则表达式regex，符合则返回符合的部分   
  18. def match_sepcial_str(regex, str):  
  19.     p = re.compile(regex)  
  20.     t = p.match(str)  
  21.     if t != None:  
  22.         return t.group()  
  23.     return None  
  24.   
  25. #查找str中符合正则表达式regex，符合则返回符合的部分   
  26. def search_sepcial_str(regex, str):  
  27.     p = re.compile(regex)  
  28.     t = p.search(str)  
  29.     if t != None:  
  30.         return t.group()  
  31.     return None  
  32.   
  33. def time_change_format(time_str):  
  34.     tm1 = search_sepcial_str("[0-9]+:[0-9]+:[0-9]+", time_str)  
  35.     tm2 = search_sepcial_str("[0-9]+/[0-9]+/[0-9]+", time_str)  
  36.     tm2 = tm2.replace("/", "-")  
  37.     tm = tm2 + " " + tm1  
  38.     return tm  
  39.   
  40. class Database():  
  41.     def __init__(self):  
  42.         self.conn = MySQLdb.connect('localhost', 'root', '123456', 'smart_analyzer')  
  43.         self.cur = self.conn.cursor()  
  44.         return  
  45.       
  46.     def commit(self):  
  47.         self.conn.commit()  
  48.         return  
  49.   
  50. database = Database()  
  51.   
  52. class AnylyzerToolTemplate(object):  
  53.     def __init__(self):  
  54.         return  
  55.       
  56.     def anylyze(self, line):  
  57.         key = ""  
  58.         value = ""  
  59.         return key,value  
  60.   
  61. #获取时间   
  62. class AnylyzerToolGetTime(object):  
  63.     def __init__(self):  
  64.         return  
  65.       
  66.     def anylyze(self, line):  
  67.         r = "[0-9]+:[0-9]+:[0-9]+  [0-9]+/[0-9]+/[0-9]+"  
  68.         value = match_sepcial_str(r, line)  
  69.         if value != None:  
  70.             #print "time:",value   
  71.             return "time",value  
  72.         return None,None      
  73.       
  74. class AnylyzerToolStat(object):  
  75.     def __init__(self):  
  76.         self.database = None  
  77.         self.project_id = 0  
  78.         self.key = []  
  79.         self.file = ""  
  80.         self.project_name = ""  
  81.         self.project_dir_name = ""  
  82.         self.time = ""  
  83.         self.start = ""  
  84.         return  
  85.       
  86.     def anylyze(self, line):  
  87.         #print line   
  88.         if len(self.key) == 0:  
  89.             self.get_key_list()  
  90.             #print self.key   
  91.               
  92.         if line.find('System statistic information') != -1:  
  93.             self.start = self.time  
  94.               
  95.         if self.start != "" and self.start != self.time:  
  96.             #for key in self.key:   
  97.             #    print key   
  98.             self.add_data(self.time)  
  99.             self.start = ""  
  100.               
  101.           
  102.         for key in self.key:  
  103.             if line.find(key[1]) != -1:  
  104.                 value = search_sepcial_str("[0-9]+",line)  
  105.                 if value != None:  
  106.                     key[2] = value  
  107.                     return  
  108.         return  
  109.   
  110.     def get_key_list(self):  
  111.         sql = 'select name, name_desc from system_stat_type'  
  112.         self.database.cur.execute(sql)  
  113.         results = self.database.cur.fetchall()  
  114.         for key in results:  
  115.             item = [key[0], key[1], '0']  
  116.             self.key.append(item)  
  117.         return  
  118.       
  119.     def add_data1(self, key, data, time_str):  
  120.         sql = 'select * from system_stat_data where type="%s" and data=%s and time="%s" and project_id =%d' % (key, data, time_str, self.project_id)  
  121.         self.database.cur.execute(sql)  
  122.         results = self.database.cur.fetchall()  
  123.         if results != None and len(results) != 0:  
  124.             return  
  125.         else:  
  126.             sql = 'insert into system_stat_data (type,data,time,project_id) values ("%s", %s, "%s", %d)'%(key, data, time_str, self.project_id)  
  127.             print sql  
  128.             self.database.cur.execute(sql)  
  129.             self.database.commit()  
  130.         return  
  131.       
  132.     def add_data(self, time_str):  
  133.         sql = 'select * from system_stat where time="%s" and project_id =%d' % (time_str, self.project_id)  
  134.         self.database.cur.execute(sql)  
  135.         results = self.database.cur.fetchall()  
  136.         if results != None and len(results) != 0:  
  137.             return  
  138.         else:  
  139.             items = ""  
  140.             for key in self.key:  
  141.                 items = items + key[0] + ","  
  142.             #items = items[0:len(items)-1]   
  143.             values = ""  
  144.             for key in self.key:  
  145.                 values = values + key[2] + ','  
  146.             #values = values[0:len(values)-1]   
  147.             sql = 'insert into system_stat (%s time, project_id) values (%s "%s", %d)'%(items, values, time_str, self.project_id)  
  148.             print sql  
  149.             self.database.cur.execute(sql)  
  150.             self.database.commit()              
  151.         return  
  152.   
  153.   
  154. class AnylyzerToolVersion(object):  
  155.     def __init__(self):  
  156.         self.database = None  
  157.         self.project_id = 0  
  158.         self.time = ""  
  159.         return  
  160.       
  161.     def anylyze(self, line):  
  162.         if line.find('Software Version') == -1:  
  163.             return  
  164.         tmp1 = line.split(':')  
  165.         tmp2 = tmp1[1].split('(')  
  166.         version = tmp2[0].strip()   
  167.         self.add_data(self.time, version)  
  168.         return  
  169.       
  170.     def add_data(self, time_str, version):  
  171.         sql = 'select * from version where version="%s" and project_id =%d' % (version, self.project_id)  
  172.         self.database.cur.execute(sql)  
  173.         results = self.database.cur.fetchall()  
  174.         if results != None and len(results) != 0:  
  175.             return  
  176.         sql = 'insert into version (version, time, project_id) values ("%s", "%s", %d)'%(version, time_str, self.project_id)  
  177.         print sql  
  178.         self.database.cur.execute(sql)  
  179.         self.database.commit()              
  180.         return  
  181.   
  182.   
  183. class AnylyzerToolInterface(object):  
  184.     def __init__(self):  
  185.         self.database = None  
  186.         self.project_id = 0  
  187.         self.time = ""  
  188.         self.start = ""  
  189.         self.name = ""  
  190.         self.data = [  
  191.                      ['outpps', 'output rate', '[0-9]*[ ]*packets/sec', '0'],  
  192.                      ['outBps', 'output rate', '[0-9]*[ ]*bytes/sec', '0'],  
  193.                      ['inpps', 'input rate', '[0-9]*[ ]*packets/sec', '0'],  
  194.                      ['inBps', 'input rate', '[0-9]*[ ]*bytes/sec', '0']  
  195.                      ]  
  196.         ''''' 
  197.                      {'outpps':'0', 
  198.                      'outBps':'0', 
  199.                      'inpps':'0', 
  200.                      'inBps':'0', 
  201.                      }'''  
  202.         self.status = ""  
  203.         return  
  204.       
  205.     def set_data(self, key, data):  
  206.         print key,data  
  207.         for tmp in self.data:  
  208.             if tmp[0] == key:  
  209.                 tmp[3] = data  
  210.                 return  
  211.       
  212.     def anylyze(self, line):  
  213.         #Ethernet1/0/0 current state   
  214.         #GigabitEthernet0/0/0 current state   
  215.         #Ethernet1/0 current state   
  216.           
  217.         if self.start != "":  
  218.             for tmp in self.data:  
  219.                 if line.find(tmp[1]) != -1:  
  220.                     tmp1 = search_sepcial_str(tmp[2], line)  
  221.                     tmp2 = match_sepcial_str('[0-9]*', tmp1)  
  222.                     if tmp2 != None:  
  223.                         tmp[3] = tmp2  
  224.             if line.find('Input:') != -1:  
  225.                 print self.data  
  226.                 self.add_data(self.time, self.name)  
  227.                 self.start = ""      
  228.              
  229.         ''''' 
  230.         if self.start != "": 
  231.             if line.find('input') != -1: 
  232.                 print line 
  233.                 inpps = search_sepcial_str('[0-9]*[ ]*packets/sec', line) 
  234.                 if inpps != None: 
  235.                     inpps_str = match_sepcial_str('[0-9]*', inpps) 
  236.                     if inpps_str != None: 
  237.                         self.set_data('inpps', inpps_str) 
  238.                 inBps = search_sepcial_str('[0-9]*[ ]*bytes/sec', line) 
  239.                 if inBps != None: 
  240.                     inBps_str = match_sepcial_str('[0-9]*', inBps) 
  241.                     if inBps_str != None: 
  242.                         self.set_data('inBps', inBps_str) 
  243.             if line.find('output rate') != -1: 
  244.                 outpps = search_sepcial_str('[0-9]*[ ]*packets/sec', line) 
  245.                 if outpps != None: 
  246.                     outpps_str = match_sepcial_str('[0-9]*', outpps) 
  247.                     if outpps_str != None: 
  248.                         self.set_data('outpps', outpps_str) 
  249.                 outBps = search_sepcial_str('[0-9]*[ ]*bytes/sec', line) 
  250.                 if outBps != None: 
  251.                     outBps_str = match_sepcial_str('[0-9]*', outBps) 
  252.                     if outBps_str != None: 
  253.                         self.set_data('outBps', outBps_str) 
  254.             if line.find('Output') != -1: 
  255.                 print self.data 
  256.                 self.add_data(self.time, self.name) 
  257.                 self.start = "" 
  258.         '''  
  259.         name = match_sepcial_str("(Ethernet|GigabitEthernet)[0-9]/[0-9]/[0-9][ ]*current state", line)  
  260.         if name != None:  
  261.             name = name.split(' ')[0]  
  262.             self.name = name  
  263.             self.start = self.name  
  264.             tmp = line.split(':')  
  265.             self.status = tmp[1].strip()  
  266.             print self.name, self.status  
  267.         return  
  268.       
  269.     def add_data(self, time_str, name):  
  270.         sql = 'select id from interface where name="%s" and time="%s" and project_id=%d'%(name, time_str, self.project_id)  
  271.         self.database.cur.execute(sql)  
  272.         results = self.database.cur.fetchall()  
  273.         if results != None and len(results) != 0:  
  274.             return  
  275.         items = ""  
  276.         for key in self.data:  
  277.             items = items + key[0] + ","  
  278.         #items = items[0:len(items)-1]   
  279.         values = ""  
  280.         for key in self.data:  
  281.             values = values + key[3] + ','  
  282.         #values = values[0:len(values)-1]   
  283.         sql = 'insert into interface (%s name, status, time, project_id) values (%s "%s", "%s", "%s", %d)'%(items, values, self.name, self.status, time_str, self.project_id)  
  284.         print sql  
  285.         self.database.cur.execute(sql)  
  286.         self.database.commit()           
  287.   
  288. class AnylyzerToolProject(object):  
  289.     def __init__(self):  
  290.         self.database = None  
  291.         return  
  292.       
  293.     def add_data(self, project_name, project_dir, anylyze_file_name):  
  294.         sql = 'select id from project where path="%s" and file_name="%s"'%(project_dir, anylyze_file_name)  
  295.         self.database.cur.execute(sql)  
  296.         results = self.database.cur.fetchall()  
  297.         if results != None and len(results) != 0:  
  298.             id = results[0][0]  
  299.             return id  
  300.         else:  
  301.             sql = 'insert into project (name, path, file_name) values ("%s", "%s", "%s")'%(project_name, project_dir, anylyze_file_name)  
  302.             sql.encode("utf-8")  
  303.             print sql  
  304.             self.database.cur.execute(sql)  
  305.             self.database.commit()  
  306.         sql = 'select id from project where path="%s" and file_name="%s"'%(project_dir, anylyze_file_name)  
  307.         self.database.cur.execute(sql)  
  308.         results = self.database.cur.fetchall()  
  309.         if results != None:  
  310.             id = results[0][0]  
  311.             return id  
  312.         return None  
  313.       
  314. class Anylyzer(object):  
  315.     def __init__(self, project_name, project_dir_name, anylyze_file_name):  
  316.         self.anylyze_file_name = anylyze_file_name  
  317.         self.analyze_file_type = []  
  318.         self.project_name = project_name  
  319.         self.project_dir = project_dir_name  
  320.         self.analyze_class = []  
  321.         self.init_analyze_class()  
  322.         self.database = Database()  
  323.         self.project_id = 0  
  324.         return  
  325.       
  326.     def register_analyze_tool(self, class_name):  
  327.         tool = class_name()  
  328.         tool.file = self.anylyze_file_name  
  329.         tool.project_name = self.project_name  
  330.         tool.project_dir_name = self.project_dir  
  331.         self.analyze_class.append(tool)  
  332.         return  
  333.   
  334.     def anylyzer_file(self):  
  335.         file = self.anylyze_file_name  
  336.         #print file   
  337.   
  338.         #过滤空文件   
  339.         if 0 == os.path.getsize(file):  
  340.             return  
  341.   
  342.         #将本文件记录的数据库中   
  343.         anylyzer_tool_project = AnylyzerToolProject()  
  344.         anylyzer_tool_project.database = self.database  
  345.         self.project_id = anylyzer_tool_project.add_data(self.project_name, self.project_dir, self.anylyze_file_name)  
  346.   
  347.         print "begin anylyze file=%s， id=%d"%(file, self.project_id)  
  348.   
  349.         #开始读取文件   
  350.         try:  
  351.             tm = ""  
  352.             fp = open(file)  
  353.             while True:  
  354.                 line = fp.readline()  
  355.                 if line == None or len(line) == 0:  
  356.                     break  
  357.                 anylyzer_tool_get_time = AnylyzerToolGetTime()  
  358.                 key,value = anylyzer_tool_get_time.anylyze(line)  
  359.                 if key != None:  
  360.                     tm = time_change_format(value)  
  361.                 for anylyzer_tool in self.analyze_class:  
  362.                     anylyzer_tool.time = tm  
  363.                     anylyzer_tool.database = self.database  
  364.                     anylyzer_tool.project_id = self.project_id  
  365.                     anylyzer_tool.anylyze(line)  
  366.             fp.close()  
  367.         except BaseException, e:  
  368.             print "can't open",file  
  369.             print str(e)  
  370.             return          
  371.         print "end anylyze file:",file  
  372.         return  
  373.       
  374.     def init_analyze_class(self):  
  375.         self.register_analyze_tool(AnylyzerToolStat)  
  376.         self.register_analyze_tool(AnylyzerToolVersion)  
  377.         self.register_analyze_tool(AnylyzerToolInterface)  
  378.         return  
  379.   
  380. class Collector(object):  
  381.     ''''' 
  382.     classdocs 
  383.     '''  
  384.     def __init__(self):  
  385.         self.project_root_dir_depth = 0  
  386.         self.collector_project = []  
  387.         self.analyze_file_type = []  
  388.         return  
  389.       
  390.     def set_project_root_dir_depth(self, depth):  
  391.         self.project_root_dir_depth = depth  
  392.         return  
  393.       
  394.     def get_dir_depth(self, dir1, dir2):  
  395.         dir1_len = len(dir1)  
  396.         dir2_len = len(dir2)  
  397.         depth = 0  
  398.         if dir1_len > dir2_len:  
  399.             return -1  
  400.         if dir2[0:dir1_len] != dir1:  
  401.             return -1  
  402.         for c in dir2[dir1_len:dir2_len]:  
  403.             if "\\" == c:  
  404.                 depth = depth + 1  
  405.         return depth  
  406.       
  407.     def register_analyze_file_type(self, type):  
  408.         self.analyze_file_type.append(type)  
  409.         return  
  410.       
  411.     def get_dir_name(self, dir):  
  412.         names = os.path.split(dir)  
  413.         return names[1]  
  414.       
  415.     def read_file(self, file, project_name, project_dir_name):  
  416.         #过滤文件扩展名，如果没有设置过滤器，则不作判断   
  417.           
  418.         file = file.replace("\\", "/")  
  419.         project_name = project_name.replace("\\", "/")  
  420.         project_dir_name = project_dir_name.replace("\\", "/")  
  421.         print file, project_name, project_dir_name  
  422.           
  423.         can_read = True  
  424.         tmp1 = os.path.splitext(file)  
  425.         if len(self.analyze_file_type) > 0:  
  426.             can_read = False  
  427.             for tmp2 in self.analyze_file_type:  
  428.                 if tmp1[1] == tmp2:  
  429.                     can_read = True  
  430.                     break  
  431.         if False == can_read:  
  432.             return          
  433.           
  434.         a = Anylyzer(project_name, project_dir_name, file)  
  435.         a.anylyzer_file()  
  436.         return  
  437.       
  438.     #遍历指定目录中的所有子目录和文件   
  439.     def walk_dir(self, path=None):  
  440.         if path == None:  
  441.             path =getcwd() #current path   
  442.         alldir = os.walk(path)  
  443.         project_name = ""  
  444.         project_dir_name = ""  
  445.         for sub_path in alldir:  
  446.             #print self.get_dir_depth(path, sub_path[0]), sub_path[0]   
  447.             #print sub_path   
  448.             if (self.project_root_dir_depth == self.get_dir_depth(path, sub_path[0]) - 1):  
  449.                 project_name = self.get_dir_name(sub_path[0])  
  450.                 project_dir_name = sub_path[0]  
  451.                 #print "project_dir_name:",project_dir_name   
  452.                 #print "project_name:",project_name   
  453.             for file in sub_path[2]:  
  454.                 self.read_file(sub_path[0]+"\\"+file, project_name, project_dir_name)  
  455.         return  
  456.   
  457.   
  458. c = Collector()  
  459. c.set_project_root_dir_depth(0)  
  460. c.register_analyze_file_type(".txt")  
  461. c.walk_dir()  

相关内容