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
