def initGlobalInfos():
"""
function: init global infos
input: NA
output: NA
"""
global g_logger
global g_clusterInfo
g_logger = GaussLog(g_opts.logFile, "CheckUpgrade")
try:
if g_opts.action in [Const.ACTION_CHECK_VERSION]:
g_logger.log("No need to init cluster info under action %s" %
g_opts.action)
return
g_clusterInfo = dbClusterInfo()
if g_opts.xmlFile == "" or not os.path.exists(g_opts.xmlFile):
if g_opts.appPath == "" or not os.path.exists(g_opts.appPath):
raise Exception(ErrorCode.GAUSS_500["GAUSS_50001"] % "R")
staticConfigFile = "%s/bin/cluster_static_config" % g_opts.appPath
g_clusterInfo.initFromStaticConfig(g_opts.user, staticConfigFile)
else:
g_clusterInfo.initFromXml(g_opts.xmlFile)
except Exception as e:
g_logger.log(traceback.format_exc())
g_logger.logExit(str(e))
def initGlobal():
"""
function: Init global variables
input : NA
output: NA
"""
global g_logger
global g_perfChecker
try:
g_logger = GaussLog(g_opts.logFile, g_opts.action)
# Modify log File Permissions
DefaultValue.modifyFileOwner(g_opts.user, g_logger.logFile)
g_perfChecker = LocalPerformanceCheck()
except Exception as e:
g_logger.logExit(str(e))
class CleanOsUser(LocalBaseOM):
'''
This class is for cleaning os user, it will not cleaning group.
'''
def __init__(self):
'''
Constructor
'''
self.userProfile = ""
self.user = ""
self.logger = None
##########################################################################
# Help context.
##########################################################################
def usage(self):
"""
function: usage
input : NA
output : NA
"""
print("CleanOsUser.py is a utility to clean OS user.")
print(" ")
print("Usage:")
print(" python3 CleanOsUser.py --help")
print(" python3 CleanOsUser.py -U user")
print(" ")
print("Common options:")
print(" -U the database program and cluster owner")
print(" --help show this help, then exit")
print(" ")
def __checkParameters(self):
"""
function: Check parameter from command line
input : NA
output: NA
"""
try:
opts, args = getopt.getopt(sys.argv[1:], "U:l:", ["help"])
except getopt.GetoptError as e:
GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50000"] % str(e))
if (len(args) > 0):
GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50000"] %
str(args[0]))
logFile = ""
for key, value in opts:
if (key == "-U"):
self.user = value
elif (key == "-l"):
logFile = value
elif (key == "--help"):
self.usage()
sys.exit(0)
else:
GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50000"] %
key)
Parameter.checkParaVaild(key, value)
if (self.user == ""):
GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % 'U' +
".")
try:
DefaultValue.checkUser(self.user, False)
except Exception as e:
GaussLog.exitWithError(str(e))
if (logFile == ""):
logFile = DefaultValue.getOMLogPath(DefaultValue.LOCAL_LOG_FILE,
self.user, "")
self.logger = GaussLog(logFile, "CleanOsUser")
self.logger.ignoreErr = True
##########################################################################
# This is the main clean OS user flow.
##########################################################################
def cleanOsUser(self):
"""
function: Clean OS user
input : NA
output: NA
"""
self.__checkParameters()
self.logger.log("Cleaning crash OS user.")
try:
# clean semaphore
subprocess.getstatusoutput("ipcs -s|awk '/ %s /{print $2}'|"
"xargs -n1 ipcrm -s" % self.user)
# get install path
cmd = "su - %s -c 'echo $GAUSSHOME' 2>/dev/null" % self.user
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_518["GAUSS_51802"] %
"$GAUSSHOME" + " Error:\n%s" % output)
gaussHome = output.strip()
if (gaussHome == ""):
self.logger.debug("$GAUSSHOME is null. This means you may "
"must clean crash install path manually.")
self.logger.debug("The installation path is %s." % gaussHome)
# delete user
status, output = subprocess.getstatusoutput("userdel -f %s" %
self.user)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_503["GAUSS_50314"] %
self.user + " Error: \n%s" % output)
# delete path
status, output = subprocess.getstatusoutput("rm -rf '%s'" %
gaussHome)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50209"] %
gaussHome + " Error: \n%s" % output)
except Exception as e:
self.logger.logExit(str(e))
self.logger.log("Successfully cleaned OS user.")
def removeAllowUsers(self):
"""
function: Remove the specific user from 'AllowUsers'
in /etc/ssh/sshd_config
input : NA
output: NA
"""
sshd_config = "/etc/ssh/sshd_config"
try:
cmd = "cat %s | grep -E '\\<AllowUsers\\>'" % sshd_config
(status, output) = subprocess.getstatusoutput(cmd)
# Not found, or there is an error.
if status != 0:
if output is None or len(output.lstrip()) == 0:
self.logger.debug("No 'AllowUsers' configuration found"
" in %s" % sshd_config)
else:
# Error occurred, but there is no need to report.
self.logger.debug("Failed to get 'AllowUsers' from %s" %
sshd_config)
return
allowUsersLineBefore = output.lstrip()
userList = allowUsersLineBefore.split()
userList.remove(self.user)
allowUsersLineRemoved = ' '.join(userList)
cmd = "sed -i 's/%s/%s/g' %s" % (
allowUsersLineBefore, allowUsersLineRemoved, sshd_config)
(status, output) = subprocess.getstatusoutput(cmd)
# Not found, or there is an error.
if status != 0:
self.logger.debug(
"Failed to remove user '%s' from "
"'AllowUsers' in %s. Command: %s, Error: %s" %
(self.user, sshd_config, cmd, output))
except Exception as e:
self.logger.debug("Failed to remove user '%s' from 'AllowUsers'"
" in %s. Error: %s" %
(self.user, sshd_config, str(e)))
class Postuninstall(LocalBaseOM):
"""
execute unPreInstall
"""
def __init__(self):
self.action = ""
self.userInfo = ""
self.user = ""
self.group = ""
self.clusterConfig = ""
self.preparePath = ""
self.checkEmpty = False
self.envParams = []
self.userProfile = ""
self.logFile = ""
self.clusterToolPath = ""
self.tmpFile = ""
self.component = []
self.clusterComponent = []
self.logger = None
self.userHome = ""
def initGlobals(self):
"""
init global variables
input : NA
output: NA
"""
global g_nodeInfo
self.logger = GaussLog(self.logFile, self.action)
if self.clusterConfig != "":
if os.path.isfile(self.clusterConfig):
self.clusterToolPath = DefaultValue.getPreClusterToolPath(
self.user, self.clusterConfig)
self.readConfigInfoByXML()
hostName = DefaultValue.GetHostIpOrName()
g_nodeInfo = self.clusterInfo.getDbNodeByName(hostName)
if (g_nodeInfo is None):
self.logger.logExit(
ErrorCode.GAUSS_516["GAUSS_51620"] % "local" +
" There is no host named %s!" % hostName)
else:
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50210"] %
("config file [%s]" % self.clusterConfig))
elif self.action != ACTION_CLEAN_DEPENDENCY:
try:
self.clusterToolPath = DefaultValue.getClusterToolPath(
self.user)
except Exception as e:
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50219"] %
"the cluster tool path" +
" Error: \n%s" % str(e))
if not self.clusterToolPath:
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50219"] %
"cluster tool path")
# make sure if we are using env seperate version,
# and get the right profile
# we can not check mppenvfile exists here
mppenvFile = DefaultValue.getEnv(DefaultValue.MPPRC_FILE_ENV)
if (mppenvFile != "" and mppenvFile is not None):
self.userProfile = mppenvFile
else:
self.userProfile = "/home/%s/.bashrc" % self.user
def usage(self):
"""
Usage:
python3 UnPreInstallUtility.py -t action -u user [-X xmlfile] [-l log]
Common options:
-t the type of action
-u the os user of cluster
-X the xml file path
-l the path of log file
--help show this help, then exit
"""
print(self.usage.__doc__)
def parseCommandLine(self):
"""
function: Check parameter from command line
input : NA
output: NA
"""
try:
opts, args = getopt.getopt(sys.argv[1:], "t:u:X:l:f:Q:P:",
["help"])
except Exception as e:
self.usage()
GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50000"] % str(e))
if (len(args) > 0):
GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50000"] %
str(args[0]))
for (key, value) in opts:
if (key == "--help"):
self.usage()
sys.exit(0)
elif (key == "-t"):
self.action = value
elif (key == "-u"):
self.user = value
elif (key == "-X"):
self.clusterConfig = value
elif (key == "-l"):
self.logFile = os.path.realpath(value)
elif (key == "-f"):
self.tmpFile = value
elif key == "-Q":
self.clusterToolPath = value
elif key == "-P":
self.userHome = value
else:
GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50000"] %
key)
Parameter.checkParaVaild(key, value)
def checkParameter(self):
"""
function: Check parameter from command line
input : NA
output: NA
"""
if self.action == "":
GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % "t" +
".")
if self.logFile == "":
self.logFile = DefaultValue.getOMLogPath(
DefaultValue.LOCAL_LOG_FILE, self.user, "")
if self.user == "" and self.action != ACTION_CLEAN_DEPENDENCY:
GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % "u" +
".")
def getSyslogType(self):
"""
function: judge syslog type
input : NA
output: str
"""
self.logger.debug("Judging the syslog type is rsyslog or syslog-ng.")
if (os.path.isfile(RSYSLOG_CONFIG_FILE)):
return RSYSLOG
elif (os.path.isfile(SYSLOG_NG_CONFIG_FILE)):
return SYSLOG_NG
else:
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50219"] %
"rsyslog or syslog-ng" +
" \nError: Failed to judge the syslog type.")
def cleanWarningConfig(self):
"""
function: clean syslog-ng/rsyslog config
input : NA
output: NA
"""
self.logger.debug("Cleaning syslog-ng configuration.")
# judge the installed syslog type on the local host is rsyslog
# or syslog-ng
syslogType = self.getSyslogType()
if (syslogType == SYSLOG_NG):
self.cleanWarningConfigForSyslogng()
elif (syslogType == RSYSLOG):
self.cleanWarningConfigForRsyslog()
self.logger.debug("Successfully cleaned system log.")
def cleanWarningConfigForSyslogng(self):
"""
function: clean syslog-ng config
input : NA
output: NA
"""
# clean client syslog-ng configure
cmd = "(if [ -s '%s' ]; then " % SYSLOG_NG_CONFIG_FILE
cmd += \
"sed -i -e '/^filter f_gaussdb.*$/d' %s " % SYSLOG_NG_CONFIG_FILE
cmd += "-e '/^destination d_gaussdb.*$/d' %s " % SYSLOG_NG_CONFIG_FILE
cmd += \
"-e '/^log { source(src); filter(f_gaussdb); " \
"destination(d_gaussdb); };$/d' %s;fi;) " % SYSLOG_NG_CONFIG_FILE
self.logger.debug("Command for cleaning client system log: %s" % cmd)
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
" Error:\n%s" % output)
# clean server syslog-ng configure
cmd = "(if [ -s '%s' ]; then " % SYSLOG_NG_CONFIG_FILE
cmd += \
"sed -i -e '/^template t_gaussdb.*$/d' %s " % SYSLOG_NG_CONFIG_FILE
cmd += "-e '/^source s_gaussdb.*$/d' %s " % SYSLOG_NG_CONFIG_FILE
cmd += "-e '/^filter f_gaussdb.*$/d' %s " % SYSLOG_NG_CONFIG_FILE
cmd += "-e '/^destination d_gaussdb.*$/d' %s " % SYSLOG_NG_CONFIG_FILE
cmd += \
"-e '/^log { source(s_gaussdb); " \
"filter(f_gaussdb); destination(d_gaussdb); };$/d' %s;" \
"fi; " % SYSLOG_NG_CONFIG_FILE
cmd += "if [ -s '%s' ]; then " % SYSLOG_NG_CONFIG_FILE_SERVER
cmd += \
"sed -i -e '/^SYSLOGD_OPTIONS=\\\"-r -m 0\\\"/d' %s " \
% SYSLOG_NG_CONFIG_FILE_SERVER
cmd += "-e '/^KLOGD_OPTIONS=\\\"-x\\\"/d' %s; " \
% SYSLOG_NG_CONFIG_FILE_SERVER
cmd += "fi) "
self.logger.debug("Command for cleaning server system log: %s" % cmd)
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
" Error:\n%s" % output)
# restart the syslog service
(status, output) = g_service.manageOSService("syslog", "restart")
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_508["GAUSS_50802"] %
"restart syslog" + " Error: \n%s" % output)
def cleanWarningConfigForRsyslog(self):
"""
function: clean rsyslog config
input : NA
output: NA
"""
# clean rsyslog config on client and server
cmd = "(if [ -s '%s' ]; then " % RSYSLOG_CONFIG_FILE
cmd += \
"sed -i -e '/^$ModLoad imjournal.*$/d' %s " % RSYSLOG_CONFIG_FILE
cmd += "-e '/^$ModLoad imudp.*$/d' %s " % RSYSLOG_CONFIG_FILE
cmd += "-e '/^$UDPServerRun 514.*$/d' %s " % RSYSLOG_CONFIG_FILE
cmd += \
"-e '/^$imjournalRatelimitInterval.*$/d' %s " % RSYSLOG_CONFIG_FILE
cmd += "-e '/^$imjournalRatelimitBurst.*$/d' %s " % RSYSLOG_CONFIG_FILE
cmd += "-e '/^%s.*$/d' %s; " % (AP_RSYSLOG_FACILITY_LEVEL,
RSYSLOG_CONFIG_FILE)
cmd += "fi) "
self.logger.debug("Command for cleaning crash rsyslog: %s." % cmd)
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50207"] %
'crash rsyslog' + " Error: \n%s" % output)
# restart the rsyslog service
(status, output) = g_service.manageOSService("rsyslog", "restart")
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_508["GAUSS_50802"] %
"restart rsyslog" + " Error: \n%s" % output)
def cleanEnvSoftware(self):
"""
function: clean environment software and variable
Gauss-MPPDB* & sctp_patch is came from R5 upgrade R7
input : NA
output: NA
"""
self.logger.debug("Cleaning the environmental software and variable.")
# clean environment software
path = "%s/%s" % (self.clusterToolPath, PSSHDIR)
g_file.removeDirectory(path)
path = "%s/lib" % self.clusterToolPath
g_file.removeDirectory(path)
path = "%s/script" % self.clusterToolPath
g_file.removeDirectory(path)
path = "%s/sudo" % self.clusterToolPath
g_file.removeDirectory(path)
path = "%s/upgrade.sh" % self.clusterToolPath
g_file.removeFile(path)
path = "%s/version.cfg" % self.clusterToolPath
g_file.removeFile(path)
path = "%s/GaussDB.py" % self.clusterToolPath
g_file.removeFile(path)
path = "%s/libcgroup" % self.clusterToolPath
g_file.removeDirectory(path)
path = "%s/server.key.cipher" % self.clusterToolPath
g_file.removeFile(path)
path = "%s/server.key.rand" % self.clusterToolPath
g_file.removeFile(path)
path = "%s/%s*" % (self.clusterToolPath, VersionInfo.PRODUCT_NAME)
g_file.removeDirectory(path)
path = "%s/Gauss*" % (self.clusterToolPath)
g_file.removeDirectory(path)
path = "%s/sctp_patch" % (self.clusterToolPath)
g_file.removeDirectory(path)
path = "%s/unixodbc" % self.clusterToolPath
g_file.removeDirectory(path)
path = "%s/%s" % (self.clusterToolPath, Const.UPGRADE_SQL_FILE)
g_file.removeFile(path)
path = "%s/%s" % (self.clusterToolPath, Const.UPGRADE_SQL_SHA)
g_file.removeFile(path)
self.logger.debug(
"Successfully cleaned the environmental software and variable.")
self.logger.debug("Cleaning environmental software.")
# clean environment variable
cmd = "(if [ -s '%s' ]; then " % PROFILE_FILE
cmd += "sed -i -e '/^export GPHOME=%s$/d' %s " % (
self.clusterToolPath.replace('/', '\/'), PROFILE_FILE)
cmd += \
"-e '/^export PATH=\$GPHOME\/pssh-2.3.1\/bin:" \
"\$GPHOME\/script:\$PATH$/d' %s " % PROFILE_FILE
cmd += \
"-e '/^export PATH=\$GPHOME\/script\/gspylib\/pssh\/bin:" \
"\$GPHOME\/script:\$PATH$/d' %s " % PROFILE_FILE
cmd += \
"-e '/^export LD_LIBRARY_PATH=\$GPHOME\/lib:" \
"\$LD_LIBRARY_PATH$/d' %s " % PROFILE_FILE
cmd += \
"-e '/^export PYTHONPATH=\$GPHOME\/lib$/d' %s; fi) " % PROFILE_FILE
self.logger.debug("Command for cleaning environment variable: %s." %
cmd)
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
" Error:\n%s" % output)
self.logger.debug(
"Successfully cleaned environmental software and variable.")
def checkUnPreInstall(self):
"""
function: check whether do uninstall before unpreinstall
input : NA
output: NA
"""
self.logger.debug("Checking UnPreInstall.")
# check if user exist
try:
DefaultValue.getUserId(self.user)
except Exception as e:
self.logger.logExit(str(e))
# check if user profile exist
if (not os.path.exists(self.userProfile)):
self.logger.debug("The %s does not exist." % self.userProfile +
" Please skip to check UnPreInstall.")
return
# check $GAUSSHOME
cmd = "su - %s -c 'source %s && echo $GAUSS_ENV' 2>/dev/null" % (
self.user, self.userProfile)
self.logger.debug("Command for getting $GAUSSHOME: %s" % cmd)
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
" Error:\n%s" % output)
gaussEnv = output.strip()
if (gaussEnv == "2"):
self.logger.logExit(ErrorCode.GAUSS_525["GAUSS_52501"] %
"gs_uninstall")
# check $GAUSS_ENV
cmd = "su - %s -c 'source %s && echo $GAUSS_ENV' 2>/dev/null" % (
self.user, self.userProfile)
self.logger.debug("Command for getting $GAUSS_ENV: %s" % cmd)
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
" Error:\n%s" % output)
gaussEnv = output.strip()
if (str(gaussEnv) != "1"):
self.logger.logExit(ErrorCode.GAUSS_525["GAUSS_52501"] %
"gs_preinstall")
self.logger.debug("Successfully checked UnPreInstall.")
def cleanGaussEnv(self):
"""
function: clean $GAUSS_ENV
input : NA
output: NA
"""
self.logger.debug("Cleaning $GAUSS_ENV.")
# check if user profile exist
if (self.userProfile is not None and self.userProfile != ""):
userProfile = self.userProfile
else:
userProfile = "/home/%s/.bashrc" % self.user
if (not os.path.exists(userProfile)):
self.logger.debug("The %s does not exist." % userProfile +
" Please skip to clean $GAUSS_ENV.")
return
# clean user's environmental variable
DefaultValue.cleanUserEnvVariable(userProfile,
cleanGAUSS_WARNING_TYPE=True)
# clean $GAUSS_ENV
envContent = "^\\s*export\\s*GAUSS_ENV=.*$"
g_file.deleteLine(userProfile, envContent)
self.logger.debug("Cleaned $GAUSS_ENV.")
def cleanNetworkfile(self, backIpNIC, virtualIp):
"""
function: clean configured IP in Network file
input : NA
output: NA
"""
self.logger.debug("Cleaning network file.")
try:
# read information from networkfile
networkfile = "/etc/sysconfig/network/ifcfg-" + backIpNIC
networkinfo = []
# check if the file is a link
g_OSlib.checkLink(networkfile)
with open(networkfile, "r") as fp:
networkinfo = fp.readlines()
LABEL = self.getLABEL(virtualIp, networkfile)
if (LABEL is not None):
# init linenum for delete
del_1 = 0
del_2 = 0
linenum = 1
for line in networkinfo:
if (line.split("=")[1].strip() == virtualIp):
# find if the netmask exist, if exist, delete this line
cmd_g = "grep -n 'NETMASK_%s=' %s" % (LABEL,
networkfile)
(status, output) = subprocess.getstatusoutput(cmd_g)
if (status == 0):
linenum_net = int(output.split(":")[0])
if (linenum + 1 == linenum_net):
del_1 = linenum_net
# find if the LABEL number exist,
# if exist, delete this line
cmd_g = "grep -n 'LABEL_%s=' %s " % (LABEL,
networkfile)
(status, output) = subprocess.getstatusoutput(cmd_g)
if (status == 0):
linenum_net = int(output.split(":")[0])
if (linenum + 2 == linenum_net):
del_2 = linenum_net
# delete issues which exist
if (del_1 != 0 and del_2 != 0):
cmd = "sed -i '%dd;%dd;%dd' %s" % (
linenum, del_1, del_2, networkfile)
elif (del_1 != 0 and del_2 == 0):
cmd = "sed -i '%dd;%dd' %s" % (linenum, del_1,
networkfile)
elif (del_1 == 0 and del_2 != 0):
cmd = "sed -i '%dd;%dd' %s" % (linenum, del_2,
networkfile)
else:
cmd = "sed -i '%dd' %s" % (linenum, networkfile)
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
raise Exception(
ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
"Error:\n%s" % output)
linenum += 1
self.logger.log(
"Successfully clean virtual Ip from network file")
else:
raise Exception(ErrorCode.GAUSS_502["GAUSS_50204"] %
("the LABEL number of %s " % virtualIp))
self.logger.debug("Successfully cleaned network file.")
except Exception as e:
self.logger.log("Error: Write networkfile failed." + str(e))
def IsSuSE12SP0(self):
"""
function:Check is OS SuSE12.0
input :NA
output :bool
"""
if (os.path.isfile("/etc/SuSE-release")):
cmd = "grep -i 'PATCHLEVEL' /etc/SuSE-release " \
"| awk -F '=' '{print $2}'"
(status, output) = subprocess.getstatusoutput(cmd)
if (status == 0 and output != ""):
if (output.strip().isdigit() and int(output.strip()) == 0):
return True
else:
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
" Error: \n%s " % output)
return False
def getLABEL(self, virtualIp, networkfile):
"""
function: get LABEL number of virtual ip from network file
input : fp, virtualIp
output: int
"""
# check if the file is a link
g_OSlib.checkLink(networkfile)
with open(networkfile, "r") as fp:
for line in fp:
if line.split("=")[1].strip() == virtualIp:
if line.split("IPADDR_")[1].split("=%s" % virtualIp)[0]:
return line.split("IPADDR_")[1].split("=%s" %
virtualIp)[0]
else:
return None
return None
def cleanGroup(self):
"""
function: clean group
input : NA
output: NA
"""
self.logger.debug("Cleaning user group.")
hostName = DefaultValue.GetHostIpOrName()
groupname = self.user
try:
groupid = grp.getgrnam(groupname).gr_gid
except Exception:
self.logger.debug("group %s has been deleted." % groupname)
sys.exit(0)
cmd = "cat /etc/passwd | awk -F [:] '{print $1 \" \"$4}'" \
"|grep ' %s$'" % groupid
(status, output) = subprocess.getstatusoutput(cmd)
if status == 0:
self.logger.logExit(
"Warning: There are other users in the group %s on %s,"
" skip to delete group." % (groupname, hostName))
elif status == 1:
cmd = "groupdel %s" % groupname
(status, output) = subprocess.getstatusoutput(cmd)
if status != 0:
self.logger.logExit("Warning: Failed to delete group "
"%s by cmd:%s. Error: \n%s" %
(groupname, cmd, output))
else:
self.logger.logExit("Warning: Failed to delete group "
"%s by cmd:%s. Error: \n%s" %
(groupname, cmd, output))
self.logger.debug("Successfully cleaned user group.")
def cleanScript(self):
"""
function: clean script
"""
# clean lib
libPath = os.path.join(self.clusterToolPath, LIBPATH)
if os.path.exists(libPath):
g_file.removeDirectory(libPath)
# clean om script
scriptPath = os.path.join(self.clusterToolPath, SCRIPTPATH)
if os.path.exists(scriptPath):
g_file.removeDirectory(scriptPath)
# clean root script path
root_script_path = os.path.join(DefaultValue.ROOT_SCRIPTS_PATH,
self.user)
if os.path.exists(root_script_path):
g_file.removeDirectory(root_script_path)
# if /root/gauss_om has no files, delete it.
if not os.listdir(DefaultValue.ROOT_SCRIPTS_PATH):
g_file.removeDirectory(DefaultValue.ROOT_SCRIPTS_PATH)
# clean others
if os.path.exists(self.clusterToolPath):
g_file.cleanDirectoryContent(self.clusterToolPath)
if self.userHome != "":
if os.path.exists(self.userHome):
g_file.removeDirectory(self.userHome)
def cleanEnv(self):
"""
function: clean envriment variable
"""
self.logger.debug("Begin clean envrionment variable")
if not self.userProfile:
self.logger.logExit("Clean Env failed: can not get user profile.")
for comp in self.clusterComponent:
comp.cleanEnv(self.userProfile)
# clean user's environment variable
self.logger.debug("Clean user environment variable.")
DefaultValue.cleanUserEnvVariable(self.userProfile,
cleanGAUSS_WARNING_TYPE=True)
# clean GAUSS_ENV
self.logger.debug("Clean GAUSS_ENV.")
g_file.deleteLine(self.userProfile, "^\\s*export\\s*GAUSS_ENV=.*$")
self.logger.debug("Clean envrionment variable successfully.")
def cleanPath(self):
"""
function: clean path
input: NA
output: NA
"""
self.logger.debug("Begin clean path")
if os.path.exists(self.clusterInfo.appPath):
self.logger.debug("Deleting the install directory.")
cleanPath = os.path.join(self.clusterInfo.appPath, "./*")
g_file.removeDirectory(cleanPath)
self.logger.debug("Successfully deleted the install directory.")
for i in self.component:
i.cleanPath()
gsdbHomePath = "/home/%s/gsdb_home" % self.user
if os.path.exists(gsdbHomePath):
self.logger.debug("Deleting the gsdb home path.")
g_file.removeDirectory(gsdbHomePath)
self.logger.debug("Successfully deleted the gsdb home path.")
self.logger.debug("Clean Path successfully.")
def run(self):
try:
self.parseCommandLine()
self.checkParameter()
self.initGlobals()
except Exception as e:
GaussLog.exitWithError(str(e))
try:
if (self.action == ACTION_CLEAN_SYSLOG_CONFIG):
self.cleanWarningConfig()
elif (self.action == ACTION_CLEAN_TOOL_ENV):
self.cleanEnvSoftware()
elif (self.action == ACTION_CHECK_UNPREINSTALL):
self.checkUnPreInstall()
elif (self.action == ACTION_CLEAN_GAUSS_ENV):
self.cleanGaussEnv()
elif (self.action == ACTION_DELETE_GROUP):
self.cleanGroup()
elif (self.action == ACTION_CLEAN_DEPENDENCY):
self.cleanScript()
elif (self.action == ACTION_CLEAN_ENV):
self.cleanEnv()
elif (self.action == ACTION_CLEAN_INSTANCE_PATHS):
self.cleanPath()
else:
self.logger.logExit(ErrorCode.GAUSS_500["GAUSS_50000"] %
self.action)
except Exception as e:
self.logger.logExit(str(e))
class LocalBaseOM(object):
"""
Base class for local command
"""
def __init__(self,
logFile=None,
user=None,
clusterConf=None,
dwsMode=False,
initParas=None,
gtmInitParas=None):
'''
Constructor
'''
if (logFile is not None):
self.logger = GaussLog(logFile, self.__class__.__name__)
else:
self.logger = None
self.clusterInfo = None
self.dbNodeInfo = None
self.clusterConfig = clusterConf
self.user = user
self.group = ""
self.dws_mode = dwsMode
if initParas is None:
initParas = []
self.initParas = initParas
if gtmInitParas is None:
gtmInitParas = []
self.gtmInitParas = gtmInitParas
self.etcdCons = []
self.cmCons = []
self.gtmCons = []
self.cnCons = []
self.dnCons = []
self.gtsCons = []
def initComponent(self):
"""
function: Init component
input : NA
output: NA
"""
self.initKernelComponent()
def initComponentAttributes(self, component):
"""
function: Init component attributes on current node
input : Object component
output: NA
"""
component.logger = self.logger
component.binPath = "%s/bin" % self.clusterInfo.appPath
component.dwsMode = self.dws_mode
def initKernelComponent(self):
"""
function: Init kernel component on current node
input : Object nodeInfo
output: NA
"""
for inst in self.dbNodeInfo.datanodes:
component = DN_OLAP()
# init component cluster type
component.clusterType = self.clusterInfo.clusterType
component.instInfo = inst
component.instInfo.peerInstanceInfos = \
self.clusterInfo.getPeerInstance(component.instInfo)
self.initComponentAttributes(component)
component.initParas = self.initParas
self.dnCons.append(component)
def readConfigInfo(self):
"""
function: Read config from static config file
input : NA
output: NA
"""
try:
self.clusterInfo = dbClusterInfo()
hostName = DefaultValue.GetHostIpOrName()
dynamicFileExist = False
if self.__class__.__name__ == "Start":
dynamicFileExist = \
self.clusterInfo.dynamicConfigExists(self.user)
if dynamicFileExist:
self.clusterInfo.readDynamicConfig(self.user)
self.dbNodeInfo = self.clusterInfo.getDbNodeByName(hostName)
else:
self.clusterInfo.initFromStaticConfig(self.user)
self.dbNodeInfo = self.clusterInfo.getDbNodeByName(hostName)
if self.dbNodeInfo is None:
self.logger.logExit(ErrorCode.GAUSS_516["GAUSS_51619"] %
hostName)
except Exception as e:
self.logger.logExit(str(e))
self.logger.debug("Instance information on local node:\n%s" %
str(self.dbNodeInfo))
def readConfigInfoByXML(self):
"""
function: Read config from xml config file
input : NA
output: NA
"""
try:
if (self.clusterConfig is None):
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50201"] %
"XML configuration file")
static_config_file = "%s/bin/cluster_static_config" % \
DefaultValue.getInstallDir(self.user)
self.clusterInfo = dbClusterInfo()
self.clusterInfo.initFromXml(self.clusterConfig,
static_config_file)
hostName = DefaultValue.GetHostIpOrName()
self.dbNodeInfo = self.clusterInfo.getDbNodeByName(hostName)
if (self.dbNodeInfo is None):
self.logger.logExit(ErrorCode.GAUSS_516["GAUSS_51619"] %
hostName)
except Exception as e:
self.logger.logExit(str(e))
self.logger.debug("Instance information on local node:\n%s" %
str(self.dbNodeInfo))
def getUserInfo(self):
"""
Get user and group
"""
if os.path.islink(self.clusterInfo.appPath):
appPath = os.path.realpath(self.clusterInfo.appPath)
elif os.path.exists(self.clusterInfo.appPath):
appPath = self.clusterInfo.appPath
else:
commitid = VersionInfo.getCommitid()
appPath = self.clusterInfo.appPath + "_" + commitid
self.logger.debug("Get the install path %s user info." % appPath)
(self.user, self.group) = g_OSlib.getPathOwner(appPath)
if (self.user == "" or self.group == ""):
self.logger.logExit(ErrorCode.GAUSS_503["GAUSS_50308"])
