修复日志模块方法命名错误

apps/api/views/mysql_api.py

@@ -12,8 +12,9 @@
 from rest_framework.response import Response
 from rest_framework.decorators import api_view
 from django.contrib.auth.decorators import permission_required
-from dao.base import MySQLPool,DataHandle
-from dao.mysql import MySQLARCH,DBManage,DBConfig, DBUser
+from dao.base import DataHandle
+from databases.service.mysql_base import MySQLBase,MySQLARCH
+from dao.mysql import DBManage,DBConfig, DBUser
 from django.http import JsonResponse
 from utils.logger import logger
 from utils.base import method_decorator_adaptor,file_iterator
@@ -59,7 +60,7 @@ def db_detail(request, id,format=None):
 
 class DB_CUSTOM_SQL(APIView,DBConfig):
     @method_decorator_adaptor(permission_required, "databases.database_can_read_sql_custom_high_risk_sql","/403/")     
-    def get(self,request,format=None):
+    def get(self, request, format=None):
         snippets = Custom_High_Risk_SQL.objects.all()
         serializer = serializers.CustomSQLSerializer(snippets, many=True)
         return Response(serializer.data) 
@@ -175,8 +176,8 @@ def db_org(request, id,format=None):
     except DataBase_MySQL_Server_Config.DoesNotExist:
         return Response(status=status.HTTP_404_NOT_FOUND)    
     if request.method == 'POST':
-        MYSQL = MySQLPool(dbServer.to_connect())
-        ARCH_INFO = MySQLARCH(MYSQL,dbServer.to_connect())
+        MYSQL = MySQLBase(dbServer.to_connect())
+        ARCH_INFO = MySQLARCH(MYSQL, dbServer.to_connect())
         if dbServer.db_mode == 'pxc':data = ARCH_INFO.pxc()
         elif dbServer.db_mode == 'slave':data = ARCH_INFO.master_slave()
         else:
@@ -286,7 +287,7 @@ def db_server_db_detail(request, sid, id,format=None):
         return Response(status=status.HTTP_204_NO_CONTENT) 
 
 
-class DB_DATA_DICT(APIView,DBConfig,DataHandle):
+class DB_DATA_DICT(APIView, DBConfig, DataHandle):
     def get_db_server(self, sid):
         try:
             return DataBase_MySQL_Server_Config.objects.get(id=sid)
@@ -392,7 +393,7 @@ def db_user_db_table_list(request, uid, did, format=None):
         except Database_MySQL_Detail.DoesNotExist:
             return Response(status=status.HTTP_404_NOT_FOUND)
 
-        result= MySQLPool(dbServer=db_info.to_connect()).queryMany('show tables',10000) 
+        result= MySQLBase(dbServer=db_info.to_connect()).get_tables()
 
         if not isinstance(result, str):
             count,tableList,colName = result[0],result[1],result[2]

apps/databases/service/__init__.py

@@ -1,4 +1,4 @@
-import inspect
+import inspect, time
 from . import mysql_base, mysql_pxc, mysql_status, mysql_variables, mysql_innodb_status, mysql_replication, mysql_innodb_trx
 
 class MySQLMgrApi:
@@ -84,6 +84,26 @@ def innodb_block_trx(self, dbServer):
     def processlist(self, dbServer):
         return mysql_base.MySQLBase(dbServer).get_processlists()
 
+    def status_per(self, dbServer, second=1):            
+        before_status = self.status(dbServer)
+        time.sleep(second)
+        current_status = self.status(dbServer)
+        dataList = []
+        for i in range(0, len(current_status)):
+            current_value = current_status[i].get('value')
+            if not isinstance(current_value, float):
+                per_value = int(current_value) - int(before_status[i].get('value'))
+                dataList.append({
+                                    "name":current_status[i].get("name"),
+                                    "value":per_value,
+                                    "metric":current_status[i].get("metric"),
+                                    "desc":current_status[i].get("desc"),
+                                    "level":current_status[i].get("level"),                               
+                                })
+            else:
+                dataList.append(current_status[i])
+        return dataList   
+
     def allowcator(self, sub, args):
         if hasattr(self,sub):
             func= getattr(self,sub)

apps/databases/service/mysql_base.py

@@ -6,10 +6,193 @@
 
 class MySQLBase(MySQLPool):
 
+    slave_key_list = [
+                  'slave_io_state','master_host','master_user','master_port','connect_retry','master_log_file',
+                  'read_master_log_pos','relay_master_log_file','exec_master_log_pos','seconds_behind_master',
+                  'slave_io_running','slave_sql_running','replicate_do_db','slave_sql_running_state','replicate_ignore_db',
+                  'relay_log_pos'
+            ]
+
     def get_processlists(self):
         try:
             sql = """select id,user,host,db,time,state,command,info from information_schema.processlist;"""
             return self.queryMany(sql)
         except Exception as ex:
-            logger.exor(ex.__str__())
-            return -1 
+            logger.error(ex.__str__())
+            return -1 
+
+    def get_db_size(self):
+        dataList = []
+        db_size = self.execute_for_query(sql="""SELECT table_schema, Round(Sum(data_length + index_length) / 1024 / 1024, 1) as size,count(TABLE_NAME) as total_table
+                                            FROM information_schema.tables where table_schema not in ("performance_schema","information_schema","mysql","sys")
+                                            GROUP BY table_schema;""") 
+        for ds in db_size[1]:
+            dataList.append({"db_name":ds[0],"size":ds[1],"total_table":ds[2]})
+        return dataList   
+
+    def get_db_tables(self,dbname):
+        dataList = []
+        data = self.execute_for_query(sql="""SELECT TABLE_NAME,TABLE_COMMENT,ENGINE,ROW_FORMAT,CREATE_TIME,TABLE_ROWS FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='{dbname}';""".format(dbname=dbname)) 
+        for ds in data[1]:
+            dataList.append({"TABLE_NAME":ds[0],"TABLE_COMMENT":ds[1],"ENGINE":ds[2],"ROW_FORMAT":ds[3],"CREATE_TIME":ds[4],"TABLE_ROWS":ds[5]})
+        return dataList        
+
+    def get_db_table_info(self,dbname):
+        dataList = []
+        data = self.execute_for_query(sql="""select table_schema,table_name,table_rows,round((DATA_LENGTH+INDEX_LENGTH)/1024/1024,2) as size 
+                                            from information_schema.tables where table_schema = '{dbname}' order by table_rows desc;""".format(dbname=dbname))
+        for ds in data[1]:
+            dataList.append({"db_name":ds[0],"table_name":ds[1],"table_rows":ds[2],"table_size":ds[3]})
+        return dataList  
+
+    def get_db_table_columns(self,dbname, table_name):
+        dataList = []
+        data = self.execute_for_query(sql="""SELECT COLUMN_NAME,COLUMN_TYPE,ifnull(COLUMN_DEFAULT,''),IS_NULLABLE,EXTRA,COLUMN_KEY,COLUMN_COMMENT
+                                             FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA='{dbname}' AND TABLE_NAME='{table_name}';""".format(dbname=dbname,table_name=table_name))
+        for ds in data[1]:
+            dataList.append({"COLUMN_NAME":ds[0],"COLUMN_TYPE":ds[1],"COLUMN_DEFAULT":ds[2],"IS_NULLABLE":ds[3],"EXTRA":ds[4],"COLUMN_KEY":ds[5],"COLUMN_COMMENT":ds[6]})
+        return dataList      
+
+    def get_tables(self):
+        data = self.queryMany('show tables',10000) 
+        return data        
+
+    def get_table_schema(self, dbname, table): 
+        data = self.queryMany(sql="""SELECT TABLE_SCHEMA,TABLE_NAME,TABLE_TYPE,ENGINE,VERSION,ROW_FORMAT,
+                                                    TABLE_ROWS,concat(round(sum(DATA_LENGTH/1024/1024),2),'MB') AS DATA_LENGTH,
+                                                    MAX_DATA_LENGTH,concat(round(sum(INDEX_LENGTH/1024/1024),2),'MB') AS INDEX_LENGTH,
+                                                    DATA_FREE,AUTO_INCREMENT,CREATE_TIME,TABLE_COLLATION,TABLE_COMMENT FROM information_schema.TABLES 
+                                                    WHERE  TABLE_SCHEMA='{db}' AND TABLE_NAME='{table}';""".format(db=dbname,table=table),num=1000)
+        return data  
+
+    def get_table_index(self, table):
+        data = self.queryMany(sql="""SHOW index FROM `{table}`;""".format(table=table),num=1000)
+        return data         
+
+
+    def get_table_desc(self, table):
+        data = self.queryMany(sql="""show create table `{table}`;""".format(table=table),num=1000)
+        return data   
+
+    def get_status(self):
+        status = self.execute_for_query(sql='show status;')
+        dataList = []
+        for ds in status[1]:
+            data = {}
+            data['value'] = ds[1]
+            data['name'] = ds[0].capitalize() 
+            dataList.append(data)     
+        return dataList
+
+    def get_global_status(self):
+        dataList = []
+        logs = self.execute_for_query(sql='show global variables;')
+        for ds in logs[1]:
+            data = {}
+            data['value'] = ds[1]
+            data['name'] = ds[0].capitalize()
+            dataList.append(data)        
+        return dataList
+
+    def get_master_status(self):
+        masterList = []
+        master_status = self.execute_for_query(sql='show master status;')
+        slave_host = self.execute_for_query(sql="SELECT host FROM INFORMATION_SCHEMA.PROCESSLIST WHERE COMMAND='Binlog Dump';")
+        if master_status[1]:
+            count = 0
+            for ds in master_status[2]:
+                data = {}
+                data["name"] = ds
+                data["value"] = master_status[1][0][count]
+                count = count + 1
+                masterList.append(data)
+        if slave_host[1]:
+            sList = []
+            for ds in slave_host[1]:
+                sList.append(ds[0])
+            masterList.append({"name":"Slave","value":sList})    
+        return  masterList      
+
+    def get_slave_status(self):
+        slaveList = []
+        slave_status = self.execute_for_query(sql="show slave status;")  
+        if slave_status[1]:
+            count = 0
+            for ds in slave_status[2]:
+                data = {}
+                if ds.lower() in self.slave_key_list:
+                    data["name"] = ds
+                    data["value"] = slave_status[1][0][count]
+                    slaveList.append(data)
+                count = count + 1 
+        return  slaveList                     
+
+
+class MySQLARCH(object):
+    def __init__(self, mysql, db_server):
+        super(MySQLARCH,self).__init__()  
+        self.mysql = mysql
+        self.mysql_status = self.mysql.get_status()
+        self.db_server = db_server
+        self.arch_info = {
+                    'title': self.db_server.get("db_mark"),
+                    'className': 'product-dept',
+                    'children': []                   
+                }
+
+    def slave(self):
+        slave_data = {}
+        for ds in self.mysql.get_master_status():
+            if ds.get('name') == 'Slave':slave_data[self.db_server.self.db_server.get("ip")+':'+str(self.db_server.get("db_port"))] = ds.get('value')  
+        return slave_data
+
+    def pxc(self):
+        self.arch_info["name"] = 'PXC模式'
+        pxc_server_list =  []
+        for ds in self.mysql_status[1]:
+            if ds.get('name') == 'Wsrep_incoming_addresses':pxc_server_list = ds.get('value').split(',')
+        for s in pxc_server_list:
+            data = {}
+            host = s.split(':')[0]
+            port = s.split(':')[1]
+            data['name'] = host
+            data['title'] = port
+            data['children'] = []
+            if s in self.slave().keys():
+                data['name'] = 'master'
+                data['title'] = host+':'+port
+                count = 1
+                for d in self.slave().get(s):
+                    x = {}
+                    host = d.split(':')[0]
+                    port = d.split(':')[1]
+                    x['name'] = 'slave-' + str(count)
+                    x['title'] =  host+':'+port
+                    count = count + 1
+                    data['children'].append(x)                                                             
+            self.arch_info['children'].append(data) 
+        return  self.arch_info  
+
+    def master_slave(self):
+        count = 1
+        self.arch_info["name"] = '主从模式'
+        for m in self.mysql.get_slave_status():
+            if m.get('name') == 'Master_Host':
+                self.arch_info['children'].append({"name":'Master-' + str(count),"title":m.get('value')})
+                count = count + 1
+        for ds in self.mysql.get_master_status():
+            if ds.get('name') == 'Slave':
+                count = 1
+                for s in ds.get('value'):
+                    x = {}
+                    host = s.split(':')[0]
+                    port = s.split(':')[1]
+                    x['name'] = 'slave-' + str(count)
+                    x['title'] =  host+':'+port 
+                    count = count + 1  
+                    self.arch_info['children'].append(x)   
+        return  self.arch_info  
+
+    def single(self):
+        self.arch_info["name"] = '单例模式'
+        return  self.arch_info         

apps/databases/service/mysql_innodb_status.py

@@ -153,7 +153,7 @@ def get_value(self):
                 return 0
             return round(pages/requests,2)
         except Exception as ex:
-            logger.exor(ex.__str__())
+            logger.error(ex.__str__())
             return -1
 
 class MySQLInnodbBufferPoolHitRate(MySQLStatus):
@@ -174,7 +174,7 @@ def get_value(self):
                 return 0
             return round((hit_read / total_read) * 100,2)
         except Exception as ex:
-            logger.exor(ex.__str__())
+            logger.error(ex.__str__())
             return -1
 
 class MySQLInnodbBufferPoolFreePagePercent(MySQLStatus):
@@ -192,7 +192,7 @@ def get_value(self):
             free_page = float(row[1][1])
             return round((free_page / total_page) * 100,2)
         except Exception as ex:
-            logger.exor(ex.__str__())
+            logger.error(ex.__str__())
             return -1
 
 class MySQLInnodbBufferPoolDirtyPercent(MySQLStatus):
@@ -210,7 +210,7 @@ def get_value(self):
             dirty_page = float(row[1][1])
             return round((dirty_page / total_page) * 100,2)
         except Exception as ex:
-            logger.exor(ex.__str__())
+            logger.error(ex.__str__())
             return -1    
 
 
@@ -223,7 +223,7 @@ def get_value(self):
         try:
             sql = """SELECT ((@@key_buffer_size+@@innodb_buffer_pool_size+@@innodb_log_buffer_size)/1024/1024)+((@@read_rnd_buffer_size+@@read_buffer_size+@@myisam_sort_buffer_size+@@sort_buffer_size+@@join_buffer_size)/1024/1024*@@max_connections) as usedMem;"""
             row = self.queryOne(sql)
-            return row[1][1]
+            return round(row[1][0],2)
         except Exception as ex:
-            logger.exor(ex.__str__())
+            logger.error(ex.__str__())
             return -1            

apps/databases/service/mysql_innodb_trx.py

@@ -11,7 +11,7 @@ def get_locked_trx(self):
             sql = """select trx_id,trx_state,trx_started,trx_query,trx_tables_in_use,trx_tables_locked,trx_concurrency_tickets from information_schema.innodb_trx where trx_id in (select blocking_trx_id  from `information_schema`.`innodb_lock_waits`);"""
             return self.queryMany(sql)
         except Exception as ex:
-            logger.exor(ex.__str__())
+            logger.error(ex.__str__())
             return []
 
     def get_block_trx(self, second=10):
@@ -25,6 +25,6 @@ def get_block_trx(self, second=10):
                         where (UNIX_TIMESTAMP() - UNIX_TIMESTAMP(c.trx_started))>{second};""".format(second=second)
             return self.queryMany(sql)
         except Exception as ex:
-            logger.exor(ex.__str__())
+            logger.error(ex.__str__())
             return []           
 

apps/databases/service/mysql_pxc.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python  
 # _#_ coding:utf-8 _*_ 
 #coding: utf8
-from dao.base import MySQLPool
 from databases.service.mysql_status import MySQLStatus