def doCheck(self): global dbList self.result.rst = ResultStatus.OK sqldb = "select datname from pg_database;" output = SharedFuncs.runSqlCmd(sqldb, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) dbList = output.split("\n") dbList.remove("template0") sql = "select (pg_table_size(1259)/count(*)/247.172)::numeric(10,3)" \ " from pg_class;" result = [] for db in dbList: # Calculate the size with sql cmd output = SharedFuncs.runSqlCmd(sql, self.user, "", self.port, self.tmpPath, db, self.mpprcFile) if (float(output) > self.Threshold_NG): self.result.rst = ResultStatus.NG result.append(db) elif (float(output) > self.Threshold_Warning): result.append(db) if (self.result.rst == ResultStatus.OK): self.result.rst = ResultStatus.WARNING if (self.result.rst == ResultStatus.OK): self.result.val = "no system table dilate" else: self.result.val = "there is system table dilate in" \ " databases:\n%s" % "\n".join(result)
def checkSysTable(self): primaryDNidList = [] nodeInfo = self.cluster.getDbNodeByName(self.host) CN = nodeInfo.coordinators masterDnList = SharedFuncs.getMasterDnNum(self.user, self.mpprcFile) for DnInstance in nodeInfo.datanodes: if (DnInstance.instanceId in masterDnList): primaryDNidList.append(DnInstance) if (len(CN) < 1 and len(primaryDNidList) < 1): raise CheckNAException( "There is no primary database node instance in the " "current node.") # test database Connection for Instance in (CN + primaryDNidList): if not Instance: continue sqlcmd = "select pg_sleep(1);" SharedFuncs.runSqlCmd(sqlcmd, self.user, "", Instance.port, self.tmpPath, self.database, self.mpprcFile) outputList = [] pool = ThreadPool(DefaultValue.getCpuSet()) results = pool.map(self.checkSingleSysTable, CN + primaryDNidList) pool.close() pool.join() for result in results: if (result): outputList.append(result) outputList.sort() return outputList
def doCheck(self): sqlcmd1 = "show max_connections;" sqlcmd2 = "SELECT count(*) FROM pg_stat_activity;" self.result.raw = sqlcmd1 + sqlcmd2 output1 = SharedFuncs.runSqlCmd(sqlcmd1, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) output2 = SharedFuncs.runSqlCmd(sqlcmd2, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if (not (output1.isdigit() and output2.isdigit())): self.result.rst = ResultStatus.ERROR self.result.val = "max_connections: %s\nCurConnCount: %s" % ( output1, output2) maxConnections = float(output1) usedConnections = float(output2) if (maxConnections > 0 and usedConnections > 0): OccupancyRate = (usedConnections // maxConnections) self.result.val = "%.2f%%" % (OccupancyRate * 100) if (OccupancyRate < 0.9): self.result.rst = ResultStatus.OK else: self.result.rst = ResultStatus.NG else: self.result.rst = ResultStatus.ERROR self.result.val = "max_connections: %s\nCurConnCount: %s" % ( maxConnections, usedConnections)
def doCheck(self): global g_setDict databaseListSql = "select datname from pg_database where datname != " \ "'template0';" sqlCmd = "select group_name from pgxc_group where length(group_name)" \ " != length(group_name::bytea, 'SQL_ASCII');" output = SharedFuncs.runSqlCmd(databaseListSql, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) dbList = output.split("\n") resultStr = "" for databaseName in dbList: output = SharedFuncs.runSqlCmd(sqlCmd, self.user, "", self.port, self.tmpPath, databaseName, self.mpprcFile, True) if not output: continue else: g_setDict[databaseName] = output resultStr += "The node group name of %s with non-SQL_ASCII " \ "characters.\n " % databaseName if (resultStr): self.result.rst = ResultStatus.NG self.result.val = resultStr else: self.result.rst = ResultStatus.OK self.result.val = "The node group name with SQL_ASCII characters" \ " in all databases."
def doCheck(self): sql1 = """select distinct rt.relname from PG_ATTRDEF ad, ( select c.oid,c.relname from pg_class c, pgxc_class xc where c.oid = xc.pcrelid and c.relkind = 'r' and xc.pclocatortype = 'R' ) as rt(oid,relname) where ad.adrelid = rt.oid and ad.adsrc like '%nextval%'; """ sql2 = """select relname from pg_class c, pg_namespace n where relkind = 'S' and c.relnamespace = n.oid and n.nspname like 'pg_temp%'; """ sqldb = "select datname from pg_database;" output = SharedFuncs.runSqlCmd(sqldb, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) dbList = output.split("\n") dbList.remove("template0") result = "" for db in dbList: output1 = SharedFuncs.runSqlCmd(sql1, self.user, "", self.port, self.tmpPath, db, self.mpprcFile) tmptablist = [] if (output1): for tab in output1.splitlines(): tmpsql = "select * from %s limit 1" % tab tmpout = SharedFuncs.runSqlCmd(tmpsql, self.user, "", self.port, self.tmpPath, db, self.mpprcFile) if (tmpout): tmptablist.append(tab) else: pass output2 = SharedFuncs.runSqlCmd(sql2, self.user, "", self.port, self.tmpPath, db, self.mpprcFile) if (output2): for tab in output2.splitlines(): if (tab not in tmptablist): tmptablist.append(tab) if (tmptablist): result += "%s:\n%s\n" % (db, "\n".join(tmptablist)) if (result): self.result.val = "there is some default expression " \ "contains nextval(sequence):\n%s" % result self.result.rst = ResultStatus.NG else: self.result.val = "no default expression " \ "contains nextval(sequence)" self.result.rst = ResultStatus.OK
def doCheck(self): databaseListSql = "select datname from pg_database " \ "where datcompatibility = 'TD';" self.result.raw = databaseListSql output = SharedFuncs.runSqlCmd(databaseListSql, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if (not output.strip()): self.result.val = "The database with TD mode does not exist." self.result.rst = ResultStatus.OK return dbList = output.strip().split("\n") self.result.raw = "The database of TD mode is: %s\n" % ','.join( output.split('\n')) resultStr = "" sqlcmd = """ select ns.nspname as namespace, c.relname as table_name, attr.attname as column_name from pg_attribute attr, pg_class c , pg_namespace ns where attr.attrelid = c.oid and ns.oid = c.relnamespace and array_to_string(c.reloptions, ', ') like '%orientation=orc%' and attr.atttypid = (select oid from pg_type where typname='date') union all select ns.nspname as namespace, c.relname as table_name, attr.attname as column_name from pg_attribute attr, pg_class c , pg_namespace ns, pg_foreign_table ft where attr.attrelid = c.oid and c.oid = ft.ftrelid and ns.oid = c.relnamespace and array_to_string(ft.ftoptions, ', ') like '%format=orc%' and attr.atttypid = (select oid from pg_type where typname='date'); """ for databaseName in dbList: output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, databaseName, self.mpprcFile, True) if (output): self.result.raw += "%s: %s" % (databaseName, output) tableList = output.split('\n') resultStr += "database[%s]: %s\n" % (databaseName, ",".join(tableList)) if (resultStr): self.result.rst = ResultStatus.NG self.result.val = resultStr else: self.result.rst = ResultStatus.OK self.result.val = "The orc table with the date column " \ "in the TD schema database does not exist."
def doSet(self): sqlcmd = "drop schema pmk cascade;" output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) self.result.val = output
def doCheck(self): global g_value dataNum = int(self.nodeCount) * int(self.dnCount) sqlcmd = "SELECT setting FROM pg_settings WHERE " \ "name='comm_max_datanode';" self.result.raw = sqlcmd comm_max_datanode = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if comm_max_datanode.isdigit() and dataNum > int(comm_max_datanode): if (dataNum < 256): g_value = 256 elif (dataNum < 512): g_value = 512 elif (dataNum < 1024): g_value = 1024 else: value = 2048 self.result.rst = ResultStatus.WARNING self.result.val = "Invalid value for GUC parameter " \ "comm_max_datanode: %s. Expect value: %s" % ( comm_max_datanode, g_value) else: self.result.rst = ResultStatus.OK self.result.val = "dataNum: %s, comm_max_datanode: %s" % ( dataNum, comm_max_datanode) self.result.raw = sqlcmd
def doCheck(self): sql1 = """select a.relname, b.attname ,n.nspname||'.'||a.relname from pg_class a, pg_attribute b, pg_namespace n where a.oid = b.attrelid and b.attisdropped and n.oid = a.relnamespace;""" sqldb = "select datname from pg_database;" output = SharedFuncs.runSqlCmd(sqldb, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) dbList = output.split("\n") dbList.remove("template0") result = "" for db in dbList: output1 = SharedFuncs.runSqlSimplely(sql1, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if (output1.find("(0 rows)") < 0): result += "%s:\n%s\n" % (db, output1) if (result): self.result.val = "Alter table drop column operation " \ "is did in :\n%s" % result self.result.rst = ResultStatus.NG self.result.raw = sql1 else: self.result.val = "No alter table drop column operation" self.result.rst = ResultStatus.OK
def doCheck(self): sqlcmd = "select count(*) from pg_cursors;" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) self.result.rst = ResultStatus.OK self.result.val = output.strip()
def doSet(self): resultStr = "" for db in g_result.keys(): for table in g_result[db]: sql = "analyze %s;" % table output = SharedFuncs.runSqlCmd(sql, self.user, "", self.port, self.tmpPath, db, self.mpprcFile) resultStr += "%s:%s Result: %s.\n" % (db, table, output) self.result.val = "Analyze %s successfully." % resultStr
def doCheck(self): sqlcmd = "show default_transaction_read_only;" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if (output == "off"): self.result.rst = ResultStatus.OK else: self.result.rst = ResultStatus.NG self.result.val = output
def doCheck(self): databaseListSql = "select datname from pg_database " \ "where datname != 'template0';" output = SharedFuncs.runSqlCmd(databaseListSql, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) dbList = output.split("\n") residue = False residueTableSql = "select * from pg_tables " \ "where tablename='pgxc_redistb';" residueSchemaSql = "select * from pg_namespace " \ "where nspname='data_redis';" self.result.raw = residueTableSql + residueSchemaSql for dbName in dbList: # Check temporary table residue output = SharedFuncs.runSqlCmd(residueTableSql, self.user, "", self.port, self.tmpPath, dbName, self.mpprcFile) if output: residue = True self.result.val += "Redistributed " \ "temporary table pgxc_redistb has " \ "existed in database %s." % dbName # Check temporary schema residues output = SharedFuncs.runSqlCmd(residueSchemaSql, self.user, "", self.port, self.tmpPath, dbName, self.mpprcFile) if output: residue = True self.result.val += "Redistributed temporary schema " \ "data_redis has existed " \ "in database %s." % dbName if (residue): self.result.rst = ResultStatus.NG else: self.result.rst = ResultStatus.OK self.result.val += "Residue Table pgxc_redistb " \ "and residue schema data_redis " \ "do not exist in the cluster."
def doCheck(self): sqlcmd = "SELECT * FROM pg_catalog.pgxc_prepared_xacts;" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if (output != ""): self.result.rst = ResultStatus.NG else: self.result.rst = ResultStatus.OK self.result.val = output
def doCheck(self): databaseListSql = "select datname from pg_database " \ "where datname != 'template0';" sqlcmd = """ SELECT n.nspname AS schemaname, c.relname AS tablename, i.relname AS indexname, o.amname AS indexmethod, pg_get_indexdef(i.oid) AS indexdef FROM pg_index x JOIN pg_class c ON c.oid = x.indrelid JOIN pg_class i ON i.oid = x.indexrelid JOIN pg_am o ON o.oid = i.relam LEFT JOIN pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind = 'r'::"char" AND i.relkind = 'i'::"char" AND o.amname not in ('btree','gin','psort','cbtree'); """ output = SharedFuncs.runSqlCmd(databaseListSql, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) dbList = output.split("\n") resultStr = "" for databaseName in dbList: output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, databaseName, self.mpprcFile, True) if (output): self.result.raw += "%s: %s" % (databaseName, output) tableList = output.split('\n') resultStr += "database[%s]: %s\n" % (databaseName, ",".join(tableList)) if (resultStr): self.result.rst = ResultStatus.NG self.result.val = resultStr else: self.result.rst = ResultStatus.OK self.result.val = "There is no hash index in all databases."
def doCheck(self): sqlcmd = "select proname,pronamespace from pg_proc " \ "where pronamespace not in (select oid from pg_namespace);" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if (output == ""): self.result.rst = ResultStatus.OK self.result.val = "No exception data in PMK." else: self.result.rst = ResultStatus.NG self.result.val = "PMK contains exception data: \n%s" % output
def doCheck(self): """ """ global g_gucDist # get ignore list dirName = os.path.dirname(os.path.realpath(__file__)) configFile = "%s/../../config/check_list_%s.conf" % (dirName, self.version) self.getIgnoreParameters(configFile, 'guc_ignore', 'guc_logic') DNidList = [] result = [] logicCluster = False nodeInfo = self.cluster.getDbNodeByName(self.host) masterDnList = SharedFuncs.getMasterDnNum(self.user, self.mpprcFile) for DnInstance in nodeInfo.datanodes: if (DnInstance.instanceType != DUMMY_STANDBY_INSTANCE): DNidList.append(DnInstance) if len(DNidList) < 1: raise Exception(ErrorCode.GAUSS_512["GAUSS_51249"]) # get information of logicCluster on current node (lcName, dbnode) = self.checkLogicCluster() if (dbnode): logicCluster = True for DnInstance in dbnode.datanodes: if (DnInstance.instanceType != DUMMY_STANDBY_INSTANCE): if (DnInstance.instanceId in masterDnList): needm = False else: needm = True result.append( self.checkInstanceGucValue(DnInstance, needm, lcName, logicCluster)) g_gucDist[lcName] = result # test database Connection for Instance in DNidList: if not Instance: continue sqlcmd = "select pg_sleep(1);" if Instance.instanceId in masterDnList: needm = False else: needm = True output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", Instance.port, self.tmpPath, 'postgres', self.mpprcFile, needm) self.checkInstanceGucValue(Instance, needm, "", logicCluster) self.result.val = json.dumps(g_gucDist) self.result.raw = str(g_gucDist) self.result.rst = ResultStatus.OK
def doCheck(self): sqlcmd = "select count(1) from pg_stat_activity " \ "where instr( query, 'pgxc_lock_for_backup()') > 0 " \ "or instr( query, 'pg_advisory_lock(65535,65535)') > 0;" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if ((int(output.strip()) - 1) != 0): self.result.rst = ResultStatus.NG else: self.result.rst = ResultStatus.OK self.result.val = output
def doCheck(self): sqlcmd = "select txid_current();" output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) num = int(output) self.result.raw = sqlcmd self.result.val = "The xid value is %s" % output if (num <= 1000000000): self.result.rst = ResultStatus.OK elif (num <= 1800000000): self.result.rst = ResultStatus.WARNING else: self.result.rst = ResultStatus.NG
def doCheck(self): sqlcmd = "select rolname from pg_roles where rolsystemadmin=True and" \ " rolname !='%s';" % self.user self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if (output): self.result.rst = ResultStatus.NG self.result.val = "There are sysadmin users except %s:\n%s" % ( self.user, output) else: self.result.rst = ResultStatus.OK self.result.val = "Sysadmin user does not exist except %s." \ % self.user
def doCheck(self): sqlcmd = "show archive_mode;" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if output.strip() == "on": sqlcmd = "show archive_command;" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) cooInst = self.cluster.getDbNodeByName(self.host).coordinators[0] dataInst = self.cluster.getDbNodeByName(self.host).datanodes[0] if ((self.cluster.isSingleInstCluster() and not (output.find("%s" % dataInst.datadir) >= 0)) and not (output.find("%s" % cooInst.datadir) >= 0)): self.result.rst = ResultStatus.NG else: self.result.rst = ResultStatus.OK else: self.result.rst = ResultStatus.OK self.result.val = output
def doCheck(self): global g_max sqlcmd = "show max_connections;" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) max_connections = int(output.strip()) g_max['conn'] = max_connections sqlcmd = "show max_prepared_transactions;" self.result.raw += sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) max_prepared_transactions = int(output.strip()) g_max['pre'] = max_prepared_transactions sqlcmd = "show max_locks_per_transaction;" self.result.raw += sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) max_locks_per_transaction = int(output.strip()) g_max['locks'] = max_locks_per_transaction max_value = int(max_locks_per_transaction) * ( int(max_connections) + int(max_prepared_transactions)) g_max['value'] = max_value self.result.val = "max_locks_per_transaction[%d] * (max_connections[" \ "%d] + max_prepared_transactions[%d]) = %d" % ( max_locks_per_transaction, max_connections, max_prepared_transactions, max_value) if (int(max_value) < int(1000000)): self.result.rst = ResultStatus.NG self.result.val += " Must be lager than 1000000" else: self.result.rst = ResultStatus.OK
def doCheck(self): sqlcmd = "select proname from pg_proc, pg_type " \ "where pg_proc.prorettype=pg_type.oid " \ "and pg_type.typisdefined=false;" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if not output: self.result.rst = ResultStatus.OK self.result.val = "User-defined functions " \ "do not contain illegal return types." else: self.result.rst = ResultStatus.NG self.result.val = "User-defined function contains " \ "illegal return type."
def doSet(self): resultStr = "" i = 2 for dbname in g_setDict.keys(): for groupname in g_setDict[dbname]: sqlCmd = "set xc_maintenance_mode=on;" sqlCmd += "alter node group '%s' rename to " \ "'groupversion%d';" % ( groupname, i) sqlCmd += "set xc_maintenance_mode=off;" output = SharedFuncs.runSqlCmd(sqlCmd, self.user, "", self.port, self.tmpPath, dbname, self.mpprcFile, True) i += 1 resultStr += output self.result.val = resultStr
def doCheck(self): """ """ global g_gucDist global RecommendedMaxMem DNidList = [] nodeInfo = self.cluster.getDbNodeByName(self.host) CN = nodeInfo.coordinators for DnInstance in nodeInfo.datanodes: if (self.checkMaster(DnInstance.instanceId)): DNidList.append(DnInstance) if (len(CN) < 1 and len(DNidList) < 1): self.result.rst = ResultStatus.NA self.result.val = "NA" return # test database Connection for Instance in (CN + DNidList): if not Instance: continue sqlcmd = "select pg_sleep(1);" output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", Instance.port, self.tmpPath, 'postgres', self.mpprcFile) self.checkInstanceGucValue(Instance) cmd = "/sbin/sysctl -a |grep vm.min_free_kbytes|awk '{print $3}'" min_free_kbytes = int(SharedFuncs.runShellCmd(cmd).splitlines()[-1]) cmd = "free -k | grep 'Mem'| grep -v 'grep'|awk '{print $2}'" raw = int(SharedFuncs.runShellCmd(cmd)) if (min_free_kbytes * 100 > raw * 5): RecommendedMaxMem = int((raw * 0.7) // (len(DNidList) + 1)) else: RecommendedMaxMem = int((raw * 0.8) // (len(DNidList) + 1)) self.result.rst = ResultStatus.OK result = "RecommendedMaxMem is %s\n" % RecommendedMaxMem for key, value in g_gucDist.items(): if (int(value) > RecommendedMaxMem): self.result.rst = ResultStatus.NG result += "%s : %s\n" % (key, value) if (self.result.rst == ResultStatus.OK): self.result.val = "parameter max_process_memory setting is ok" else: self.result.val = "parameter max_process_memory " \ "setting should not be bigger than " \ "recommended(kb):%s:\n%s" % ( RecommendedMaxMem, result)
def doSet(self): reslutStr = "" sqlCmd = "cluster pg_attribute using" \ " pg_attribute_relid_attnum_index;" \ "cluster pg_class using pg_class_oid_index;" \ "cluster pg_type using pg_type_oid_index;" \ "cluster pg_proc using pg_proc_oid_index;" \ "cluster pg_depend using pg_depend_depender_index;" \ "cluster pg_index using pg_index_indexrelid_index;" \ "cluster pg_namespace using pg_namespace_oid_index;" \ "cluster pgxc_class using pgxc_class_pcrelid_index;" \ "vacuum full pg_statistic;" for databaseName in dbList: for sql in sqlCmd.split(';'): output = SharedFuncs.runSqlCmd(sql, self.user, "", self.port, self.tmpPath, databaseName, self.mpprcFile) reslutStr += output self.result.val = reslutStr
def doCheck(self): if (self.version == "V1R7C10"): sqlcmd = "select count(group_name) from pgxc_group " \ "where in_redistribution='true' OR in_redistribution='y';" else: sqlcmd = "select count(group_name) " \ "from pgxc_group " \ "where in_redistribution='y' OR in_redistribution='t';" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if (output != '0'): self.result.rst = ResultStatus.NG self.result.val = "Cluster not completed redistribution." else: self.result.rst = ResultStatus.OK self.result.val = "The cluster has been redistributed."
def doCheck(self): dbNode = self.cluster.getDbNodeByName(self.host) sqlcmd = "select pid, query_id, application_name, query_start, " \ "state, " \ "query from pg_stat_activity where state <> 'idle' and " \ " application_name not in ('JobScheduler', " \ "'WorkloadManager', " \ "'WLMArbiter', 'workload', 'WorkloadMonitor', 'Snapshot', " \ "'PercentileJob') and " \ "query_id <> 0 and query not like '%pg_stat_activity%';" self.result.raw = sqlcmd output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", self.port, self.tmpPath, "postgres", self.mpprcFile) if (output != ''): self.result.rst = ResultStatus.NG self.result.val = output else: self.result.rst = ResultStatus.OK self.result.val = "No idle process."
def checkInstanceGucValue(self, Instance, needm, lcName="", logicCluster=False): """ get CN/DN instance guc parameters """ global g_gucDist LCInstanceGucDist = {} lcInstance = {} sqlcmd = "select name,setting from pg_settings;" InstanceGucDist = {} output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", Instance.port, self.tmpPath, "postgres", self.mpprcFile, needm) gucValueList = output.split('\n') for gucValue in gucValueList: if (len(gucValue.split('|')) == 2): (parameter, value) = gucValue.split('|') if (parameter == "transaction_read_only" and Instance.instanceRole == INSTANCE_ROLE_DATANODE): continue if (parameter not in g_ignoreList): if (not logicCluster): InstanceGucDist[parameter] = value else: if (parameter not in g_logicList): InstanceGucDist[parameter] = value elif (lcName and parameter in g_logicList): LCInstanceGucDist[parameter] = value else: continue if (lcName): instanceName = "%s_%s_%s" % (lcName, "DN", Instance.instanceId) lcInstance[instanceName] = LCInstanceGucDist return lcInstance if Instance.instanceRole == INSTANCE_ROLE_DATANODE: Role = "DN" instanceName = "%s_%s" % (Role, Instance.instanceId) g_gucDist[instanceName] = InstanceGucDist
def checkInstanceGucValue(self, Instance): """ get CN/DN instance guc parameters """ global g_gucDist Role = "" needm = False if (Instance.instanceRole == INSTANCE_ROLE_COODINATOR): needm = False elif (self.checkMaster(Instance.instanceId)): needm = False else: needm = True sqlcmd = "select setting from pg_settings " \ "where name='max_process_memory';" output = SharedFuncs.runSqlCmd(sqlcmd, self.user, "", Instance.port, self.tmpPath, "postgres", self.mpprcFile, needm) if (Instance.instanceRole == INSTANCE_ROLE_COODINATOR): Role = "CN" elif (Instance.instanceRole == INSTANCE_ROLE_DATANODE): Role = "DN" instanceName = "%s_%s" % (Role, Instance.instanceId) g_gucDist[instanceName] = output