def __writeHostFiles(self):
"""
function: Write all hostname to a file
input : NA
output: NA
"""
try:
g_file.createFileInSafeMode(self.__hostsFile)
with open(self.__hostsFile, "w") as fp:
for host in self.hostNames:
fp.write("%s\n" % host)
fp.flush()
subprocess.getstatusoutput(
"chmod %s '%s'" % (DefaultValue.FILE_MODE, self.__hostsFile))
except Exception as e:
g_file.removeFile(self.__hostsFile)
raise Exception(ErrorCode.GAUSS_502["GAUSS_50205"] % "host file" +
" Error: \n%s" % str(e))
# change the mode
# if it created by root user,and permission is 640, then
# install user will have no permission to read it, so we should set
# its permission 644.
g_file.changeMode(DefaultValue.KEY_HOSTS_FILE, self.__hostsFile, False,
"python")
def createServerCa(self, hostList=None):
"""
function: create grpc ca file
input : NA
output: NA
"""
self.logger.debug("Generating CA files.")
if hostList is None:
hostList = []
appPath = DefaultValue.getInstallDir(self.user)
caPath = os.path.join(appPath, "share/sslcert/om")
self.logger.debug("The ca file dir is: %s." % caPath)
if (len(hostList) == 0):
for dbNode in self.clusterInfo.dbNodes:
hostList.append(dbNode.name)
# Create CA dir and prepare files for using.
self.logger.debug("Create CA file directory.")
try:
DefaultValue.createCADir(self.sshTool, caPath, hostList)
self.logger.debug("Add hostname to config file.")
DefaultValue.createServerCA(DefaultValue.SERVER_CA, caPath,
self.logger)
# Clean useless files, and change permission of ca file to 600.
DefaultValue.cleanServerCaDir(caPath)
self.logger.debug("Scp CA files to all nodes.")
except Exception as e:
certFile = caPath + "/demoCA/cacert.pem"
if os.path.exists(certFile):
g_file.removeFile(certFile)
DefaultValue.cleanServerCaDir(caPath)
raise Exception(str(e))
for certFile in DefaultValue.SERVER_CERT_LIST:
scpFile = os.path.join(caPath, "%s" % certFile)
self.sshTool.scpFiles(scpFile, caPath, hostList)
self.logger.debug("Successfully generated server CA files.")
def __cleanMonitor(self):
"""
function: clean om_monitor process and delete cron
input : NA
output: NA
"""
self.logger.log("Deleting monitor.")
try:
# get all content by crontab command
(status, output) = g_OSlib.getAllCrontab()
# overwrit crontabFile, make it empty.
crontabFile = "%s/gauss_crontab_file_%d" \
% (DefaultValue.getTmpDirFromEnv(), os.getpid())
g_file.createFile(crontabFile, True)
content_CronTabFile = [output]
g_file.writeFile(crontabFile, content_CronTabFile)
g_file.deleteLine(crontabFile, "\/bin\/om_monitor")
g_OSlib.execCrontab(crontabFile)
g_file.removeFile(crontabFile)
# clean om_monitor,cm_agent,cm_server process
for progname in ["om_monitor", "cm_agent", "cm_server"]:
g_OSlib.killallProcess(self.user, progname, '9')
except Exception as e:
if os.path.exists(crontabFile):
g_file.removeFile(crontabFile)
raise Exception(str(e))
self.logger.log("Successfully deleted OMMonitor.")
def __decompressBinPackage(self):
"""
function: Install database binary file.
input : NA
output: NA
"""
if self.dws_mode:
self.logger.log("Copying bin file.")
bin_image_path = DefaultValue.DWS_APP_PAHT
srcPath = "'%s'/*" % bin_image_path
destPath = "'%s'/" % self.installPath
cmd = g_file.SHELL_CMD_DICT["copyFile"] % (srcPath, destPath)
self.logger.debug("Copy command: " + cmd)
status, output = subprocess.getstatusoutput(cmd)
if status != 0:
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50214"] %
srcPath + " Error: " + output)
else:
self.logger.log("Decompressing bin file.")
tarFile = g_OSlib.getBz2FilePath()
# let bin executable
g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, tarFile)
cmd = "export LD_LIBRARY_PATH=$GPHOME/script/gspylib/clib:" \
"$LD_LIBRARY_PATH && "
# decompress tar file.
strCmd = cmd + "tar -xpf \"" + tarFile + "\" -C \"" + \
self.installPath + "\""
self.logger.log("Decompress command: " + strCmd)
status, output = subprocess.getstatusoutput(strCmd)
if status != 0:
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50217"] %
tarFile + " Error: \n%s" % str(output))
# mv $GPHOME/script/transfer.py to $GAUSSHOME/bin/
dirName = os.path.dirname(os.path.realpath(__file__))
transferFile = dirName + "/../../script/transfer.py"
if os.path.exists(transferFile):
g_file.cpFile(transferFile, self.installPath + "/bin/")
g_file.removeFile(transferFile)
# cp $GPHOME/script to $GAUSSHOME/bin/
g_file.cpFile(dirName + "/../../script",
self.installPath + "/bin/")
# cp $GAUSSHOME/bin/script/gspylib/etc/sql/pmk to /share/postgresql
destPath = self.installPath + "/share/postgresql/"
pmkPath = self.installPath + "/bin/script/gspylib/etc/sql/"
pmkFile = pmkPath + "pmk_schema.sql"
if os.path.exists(pmkFile):
g_file.cpFile(pmkFile, destPath)
pmkSingeInstFile = pmkPath + "pmk_schema_single_inst.sql"
if os.path.exists(pmkSingeInstFile):
g_file.cpFile(pmkSingeInstFile, destPath)
# change owner for tar file.
g_file.changeOwner(self.user, self.installPath, True)
self.logger.log("Successfully decompressed bin file.")
def __init__(self,
hostNames,
logFile=None,
timeout=DefaultValue.TIMEOUT_PSSH_COMMON,
key=""):
'''
Constructor
'''
self.hostNames = hostNames
self.__logFile = logFile
self.__pid = os.getpid()
self.__timeout = timeout + 10
self._finalizer = weakref.finalize(self, self.clenSshResultFiles)
currentTime = str(datetime.datetime.now()).replace(" ", "_").replace(
".", "_")
randomnum = ''.join(sample('0123456789', 3))
# can tmp path always access?
if key == "":
self.__hostsFile = "/tmp/gauss_hosts_file_%d_%s_%s" % (
self.__pid, currentTime, randomnum)
self.__resultFile = "/tmp/gauss_result_%d_%s_%s.log" % (
self.__pid, currentTime, randomnum)
self.__outputPath = "/tmp/gauss_output_files_%d_%s_%s" % (
self.__pid, currentTime, randomnum)
self.__errorPath = "/tmp/gauss_error_files_%d_%s_%s" % (
self.__pid, currentTime, randomnum)
else:
self.__hostsFile = "/tmp/gauss_hosts_file_%d_%s_%s_%s" % (
self.__pid, key, currentTime, randomnum)
self.__resultFile = "/tmp/gauss_result_%d_%s_%s_%s.log" % (
self.__pid, key, currentTime, randomnum)
self.__outputPath = "/tmp/gauss_output_files_%d_%s_%s_%s" % (
self.__pid, key, currentTime, randomnum)
self.__errorPath = "/tmp/gauss_error_files_%d_%s_%s_%s" % (
self.__pid, key, currentTime, randomnum)
self.__resultStatus = {}
if logFile is None:
self.__logFile = "/dev/null"
# before using, clean the old ones
g_file.removeFile(self.__hostsFile)
g_file.removeFile(self.__resultFile)
if os.path.exists(self.__outputPath):
g_file.removeDirectory(self.__outputPath)
if os.path.exists(self.__errorPath):
g_file.removeDirectory(self.__errorPath)
self.__writeHostFiles()
def cleanTempFile(self):
"""
function: clean temp file
input: NA
output: NA
"""
filename = "/tmp/temp.%s" % self.user
try:
if os.path.isfile(filename):
g_file.removeFile(filename)
except Exception as e:
raise Exception(ErrorCode.GAUSS_502["GAUSS_50207"]
% ("file [%s]" % filename))
def clenSshResultFiles(self):
"""
function: Delete file
input : NA
output: NA
"""
if os.path.exists(self.__hostsFile):
g_file.removeFile(self.__hostsFile)
if os.path.exists(self.__resultFile):
g_file.removeFile(self.__resultFile)
if os.path.exists(self.__outputPath):
g_file.removeDirectory(self.__outputPath)
if os.path.exists(self.__errorPath):
g_file.removeDirectory(self.__errorPath)
def run(self):
"""
function: the real interface that execute the check method
input : NA
output: NA
"""
try:
outputInfo = None
# check output file
if self.opts.outFile != "":
self.opts.outFile_tmp = os.path.join(
DefaultValue.getTmpDirFromEnv(self.opts.user),
(os.path.split(self.opts.outFile)[1] +
"_tmp_%s" % os.getpid()))
outputInfo = self.setOutFile()
else:
outputInfo = sys.stdout
# check check item
for key in self.opts.checkItem:
if key == "PMK":
# check PMK
self.CheckPMKPerf(outputInfo)
elif key == "SSD":
# check SSD
self.CheckSSDPerf(outputInfo)
# Follow-up
self.closeFile(outputInfo)
except Exception as e:
# close file handle if outputInfo is out file
if self.opts.outFile and outputInfo:
outputInfo.flush()
outputInfo.close()
if os.path.isfile(self.opts.outFile_tmp):
g_file.removeFile(self.opts.outFile_tmp)
# modify the log file's owner
g_file.changeOwner(self.opts.user, self.logger.logFile)
self.logger.error(str(e))
sys.exit(1)
def checkSingleSysTable(self, Instance):
tablelist = [
"pg_attribute", "pg_class", "pg_constraint", "pg_partition",
"pgxc_class", "pg_index", "pg_stats"
]
localPath = os.path.dirname(os.path.realpath(__file__))
resultMap = {}
try:
for i in tablelist:
sqlFile = "%s/sqlFile_%s_%s.sql" % (self.tmpPath, i,
Instance.instanceId)
resFile = "%s/resFile_%s_%s.out" % (self.tmpPath, i,
Instance.instanceId)
g_file.createFile(sqlFile, True, DefaultValue.SQL_FILE_MODE)
g_file.createFile(resFile, True, DefaultValue.SQL_FILE_MODE)
g_file.changeOwner(self.user, sqlFile)
g_file.changeOwner(self.user, resFile)
sql = "select * from pg_table_size('%s');" % i
sql += "select count(*) from %s;" % i
sql += "select * from pg_column_size('%s');" % i
g_file.writeFile(sqlFile, [sql])
cmd = "gsql -d %s -p %s -f %s --output %s -t -A -X" % (
self.database, Instance.port, sqlFile, resFile)
if (self.mpprcFile != "" and self.mpprcFile is not None):
cmd = "source '%s' && %s" % (self.mpprcFile, cmd)
SharedFuncs.runShellCmd(cmd, self.user)
restule = g_file.readFile(resFile)
g_file.removeFile(sqlFile)
g_file.removeFile(resFile)
size = restule[0].strip()
line = restule[1].strip()
width = restule[2].strip()
Role = ""
if (Instance.instanceRole == INSTANCE_ROLE_COODINATOR):
Role = "CN"
elif (Instance.instanceRole == INSTANCE_ROLE_DATANODE):
Role = "DN"
instanceName = "%s_%s" % (Role, Instance.instanceId)
resultMap[i] = [instanceName, size, line, width]
return resultMap
except Exception as e:
if os.path.exists(sqlFile):
g_file.removeFile(sqlFile)
if os.path.exists(resFile):
g_file.removeFile(resFile)
raise Exception(str(e))
def cleanLocalNodeEnvSoftware(self):
"""
function: clean local node environment software and variable
input : NA
output: NA
in this function, Gauss-MPPDB* & sctp_patch is came from R5 upgrade R7
"""
self.logger.log("Deleting software packages "
"and environmental variables of the local node.")
try:
self.clusterToolPath = DefaultValue.getClusterToolPath()
# clean local node environment software
path = "%s/%s" % (self.clusterToolPath, PSSHDIR)
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/unixodbc" % 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/server.key.rand" % self.clusterToolPath
g_file.removeFile(path)
path = "%s/Gauss*" % (self.clusterToolPath)
g_file.removeDirectory(path)
path = "%s/sctp_patch" % (self.clusterToolPath)
g_file.removeDirectory(path)
self.logger.debug(
"Deleting environmental software of local nodes.")
# clean local node 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\/script" \
"\/gspylib\/clib:\$LD_LIBRARY_PATH$/d' %s " % PROFILE_FILE
cmd += \
"-e '/^export LD_LIBRARY_PATH=\$GPHOME\/lib:" \
"\$LD_LIBRARY_PATH$/d' %s " % PROFILE_FILE
cmd += \
"-e '/^export PATH=\/root\/gauss_om\/%s\/script:" \
"\$PATH$/d' %s " % (self.user, PROFILE_FILE)
cmd += \
"-e '/^export PYTHONPATH=\$GPHOME\/lib$/d' %s; fi) " \
% PROFILE_FILE
self.logger.debug("Command for deleting environment variable: %s" %
cmd)
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50207"] %
"environment variables of the local node" +
" Error: \n%s" % output)
# check if user profile exist
userProfile = ""
if (self.mpprcFile is not None and self.mpprcFile != ""):
userProfile = self.mpprcFile
else:
userProfile = "/home/%s/.bashrc" % self.user
if (not os.path.exists(userProfile)):
self.logger.debug("The %s does not exist. "
"Please skip to clean $GAUSS_ENV." %
userProfile)
return
# clean user's environmental variable
DefaultValue.cleanUserEnvVariable(userProfile,
cleanGAUSS_WARNING_TYPE=True)
# clean $GAUSS_ENV
if (not self.deleteUser):
envContent = "^\\s*export\\s*GAUSS_ENV=.*$"
g_file.deleteLine(userProfile, envContent)
self.logger.debug("Command for deleting $GAUSS_ENV: %s" % cmd,
"constant")
except Exception as e:
self.logger.logExit(str(e))
self.logger.log("Successfully deleted software packages "
"and environmental variables of the local nodes.")
def createTrust(self,
user,
pwd,
ips=None,
mpprcFile="",
skipHostnameSet=False,
preMode=False):
"""
function: create trust for specified user with both ip and hostname,
when using N9000 tool create trust failed
do not support using a normal user to create trust for
another user.
input : user, pwd, ips, mpprcFile, skipHostnameSet
output: NA
"""
tmp_hosts = "/tmp/tmp_hosts_%d" % self.__pid
cnt = 0
status = 0
output = ""
if ips is None:
ips = []
try:
g_file.removeFile(tmp_hosts)
# 1.prepare hosts file
for ip in ips:
cmd = "echo %s >> %s 2>/dev/null" % (ip, tmp_hosts)
(status, output) = subprocess.getstatusoutput(cmd)
if status != 0:
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] %
tmp_hosts + " Error:\n%s." % output +
"The cmd is %s" % cmd)
g_file.changeMode(DefaultValue.KEY_HOSTS_FILE, tmp_hosts, False,
"python")
# 2.call createtrust script
create_trust_file = "gs_sshexkey"
if pwd is None or len(str(pwd)) == 0:
GaussLog.printMessage("Please enter password for current"
" user[%s]." % user)
pwd = getpass.getpass()
if (mpprcFile != ""
and g_file.checkFilePermission(mpprcFile, True)
and self.checkMpprcfile(user, mpprcFile)):
cmd = "source %s; %s -f %s -l '%s'" % (
mpprcFile, create_trust_file, tmp_hosts, self.__logFile)
elif (mpprcFile == ""
and g_file.checkFilePermission('/etc/profile', True)):
cmd = "source /etc/profile;" \
" %s -f %s -l '%s'" % (create_trust_file,
tmp_hosts, self.__logFile)
if skipHostnameSet:
cmd += " --skip-hostname-set"
cmd += " 2>&1"
tempcmd = ["su", "-", user, "-c"]
tempcmd.append(cmd)
cmd = tempcmd
p = subprocess.Popen(cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if os.getuid() != 0:
time.sleep(5)
p.stdin.write((pwd + "\n").encode(encoding="utf-8"))
time.sleep(10)
p.stdin.write((pwd + "\n").encode(encoding="utf-8"))
(output, err) = p.communicate()
# 3.delete hosts file
g_file.removeFile(tmp_hosts)
if output is not None:
output = str(output, encoding='utf-8')
if re.search("\[GAUSS\-", output):
if re.search("Please enter password", output):
GaussLog.printMessage(
ErrorCode.GAUSS_503["GAUSS_50306"] % user)
else:
GaussLog.printMessage(output.strip())
sys.exit(1)
else:
GaussLog.printMessage(output.strip())
else:
sys.exit(1)
except Exception as e:
g_file.removeFile(tmp_hosts)
raise Exception(str(e))
def installToolsPhase1(self):
"""
function: install tools to local machine
input: NA
output: NA
"""
self.context.logger.log("Installing the tools on the local node.",
"addStep")
try:
# Determine if the old version of the distribution package
# is in the current directory
oldPackName = "%s-Package-bak.tar.gz" \
% VersionInfo.PRODUCT_NAME_PACKAGE
oldPackPath = os.path.join(self.context.clusterToolPath,
oldPackName)
if os.path.exists(self.context.clusterToolPath):
versionFile = os.path.join(self.context.clusterToolPath,
"version.cfg")
if os.path.isfile(versionFile):
version, number, commitid = VersionInfo.get_version_info(
versionFile)
newPackName = "%s-Package-bak_%s.tar.gz" % (
VersionInfo.PRODUCT_NAME_PACKAGE, commitid)
newPackPath = os.path.join(self.context.clusterToolPath,
newPackName)
if os.path.isfile(oldPackPath):
cmd = "(if [ -f '%s' ];then mv -f '%s' '%s';fi)" % (
oldPackPath, oldPackPath, newPackPath)
self.context.logger.debug(
"Command for rename bak-package: %s." % cmd)
DefaultValue.execCommandWithMode(
cmd, "backup bak-package files",
self.context.sshTool, self.context.localMode
or self.context.isSingle, self.context.mpprcFile)
if (self.context.mpprcFile != ""):
# check mpprc file
self.checkMpprcFile()
# check the package is not matches the system
DefaultValue.checkPackageOS()
# get the package path
dirName = os.path.dirname(os.path.realpath(__file__))
packageDir = os.path.join(dirName, "./../../../../")
packageDir = os.path.normpath(packageDir)
# change logPath owner
self.context.logger.debug("Modifying logPath owner")
dirName = os.path.dirname(self.context.logFile)
topDirFile = "%s/topDirPath.dat" % dirName
keylist = []
if (self.context.localMode):
if (os.path.exists(topDirFile)):
keylist = g_file.readFile(topDirFile)
if (keylist != []):
for key in keylist:
if (os.path.exists(key.strip())):
g_file.changeOwner(self.context.user,
key.strip(), True, "shell")
else:
self.context.logger.debug(
"Warning: Can not find the "
"path in topDirPath.dat.")
g_file.removeFile(topDirFile)
self.context.logger.debug("Successfully modified logPath owner")
# Delete the old bak package in GPHOME before copy the new one.
for bakPack in DefaultValue.PACKAGE_BACK_LIST:
bakFile = os.path.join(self.context.clusterToolPath, bakPack)
if (os.path.isfile(bakFile)):
self.context.logger.debug("Remove old bak-package: %s." %
bakFile)
g_file.removeFile(bakFile)
DefaultValue.makeCompressedToolPackage(packageDir)
# check and create tool package dir
global toolTopPath
ownerPath = self.context.clusterToolPath
clusterToolPathExistAlready = True
# if clusterToolPath exist,
# set the clusterToolPathExistAlready False
if (not os.path.exists(ownerPath)):
clusterToolPathExistAlready = False
ownerPath = DefaultValue.getTopPathNotExist(ownerPath)
toolTopPath = ownerPath
# append clusterToolPath to self.context.needFixOwnerPaths
# self.context.needFixOwnerPaths will be checked the ownet
self.context.needFixOwnerPaths.append(ownerPath)
# if clusterToolPath is not exist, then create it
if not os.path.exists(self.context.clusterToolPath):
g_file.createDirectory(self.context.clusterToolPath)
g_file.changeMode(DefaultValue.MAX_DIRECTORY_MODE,
self.context.clusterToolPath, True, "shell")
# change the clusterToolPath permission
if not clusterToolPathExistAlready:
#check the localMode
if self.context.localMode:
#local mode,change the owner
g_file.changeMode(DefaultValue.DIRECTORY_MODE,
ownerPath,
recursive=True,
cmdType="shell")
g_file.changeOwner(self.context.user,
ownerPath,
recursive=True,
cmdType="shell")
#not localMode, only change the permission
else:
g_file.changeMode(DefaultValue.MAX_DIRECTORY_MODE,
ownerPath,
recursive=True,
cmdType="shell")
else:
g_file.changeMode(DefaultValue.DIRECTORY_MODE,
ownerPath,
recursive=False,
cmdType="shell")
# Send compressed package to local host
if (packageDir != self.context.clusterToolPath):
# copy the package to clusterToolPath
g_file.cpFile(
os.path.join(packageDir,
DefaultValue.get_package_back_name()),
self.context.clusterToolPath)
# Decompress package on local host
g_file.decompressFiles(
os.path.join(self.context.clusterToolPath,
DefaultValue.get_package_back_name()),
self.context.clusterToolPath)
# change mode of packages
g_file.changeMode(DefaultValue.DIRECTORY_MODE,
self.context.clusterToolPath,
recursive=True,
cmdType="shell")
# get the top path of mpprc file need to be created on local node
# this is used to fix the newly created path owner later
if self.context.mpprcFile != "":
ownerPath = self.context.mpprcFile
if (not os.path.exists(self.context.mpprcFile)):
while True:
# find the top path to be created
(ownerPath, dirName) = os.path.split(ownerPath)
if os.path.exists(ownerPath) or dirName == "":
ownerPath = os.path.join(ownerPath, dirName)
break
self.context.needFixOwnerPaths.append(ownerPath)
# check the current storage package path is legal
Current_Path = os.path.dirname(os.path.realpath(__file__))
DefaultValue.checkPathVaild(os.path.normpath(Current_Path))
# set ENV
cmd = "%s -t %s -u %s -l %s -X '%s' -Q %s" % (
OMCommand.getLocalScript("Local_PreInstall"),
ACTION_SET_TOOL_ENV, self.context.user, self.context.localLog,
self.context.xmlFile, self.context.clusterToolPath)
if self.context.mpprcFile != "":
cmd += " -s '%s' " % self.context.mpprcFile
#check the localmode,if mode is local then modify user group
if self.context.localMode:
cmd += "-g %s" % self.context.group
(status, output) = subprocess.getstatusoutput(cmd)
# if cmd failed, then exit
if status != 0:
self.context.logger.debug(
"Command for setting %s tool environment variables: %s" %
(VersionInfo.PRODUCT_NAME, cmd))
raise Exception(output)
except Exception as e:
raise Exception(str(e))
self.context.logger.log(
"Successfully installed the tools on the local node.", "constant")
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 cleanDir(self, instDir):
"""
function: Clean the dirs
input : instDir
output: NA
"""
if (not os.path.exists(instDir)):
return
dataDir = []
dataDir = os.listdir(instDir)
if (os.getuid() == 0):
pglDir = '%s/pg_location' % instDir
isPglDirEmpty = False
if (os.path.exists(pglDir) and len(os.listdir(pglDir)) == 0):
isPglDirEmpty = True
if (len(dataDir) == 0 or isPglDirEmpty):
g_file.cleanDirectoryContent(instDir)
else:
for info in dataDir:
if (str(info) == "pg_location"):
resultMount = []
resultFile = []
resultDir = []
pglDir = '%s/pg_location' % instDir
# delete all files in the mount point
cmd = "%s | %s '%s' | %s '{printf $3}'" % \
(g_Platform.getMountCmd(), g_Platform.getGrepCmd(),
pglDir, g_Platform.getAwkCmd())
(status, outputMount) = subprocess.getstatusoutput(cmd)
if (status != 0):
raise Exception(ErrorCode.GAUSS_502["GAUSS_50207"] %
instDir +
" Error:\n%s." % str(outputMount) +
"The cmd is %s" % cmd)
else:
if (len(outputMount) > 0):
resultMount = str(outputMount).split()
for infoMount in resultMount:
g_file.cleanDirectoryContent(infoMount)
else:
g_file.cleanDirectoryContent(instDir)
continue
# delete file in the pg_location directory
if (not os.path.exists(pglDir)):
continue
cmd = "cd '%s'" % pglDir
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] %
cmd + " Error: \n%s " % output)
outputFile = g_file.findFile(".", "f", "type")
if (len(outputFile) > 0):
for infoFile in outputFile:
tmpinfoFile = pglDir + infoFile[1:]
for infoMount in resultMount:
if (tmpinfoFile.find(infoMount) < 0
and infoMount.find(tmpinfoFile) < 0):
realFile = "'%s/%s'" % (pglDir, infoFile)
g_file.removeFile(realFile, "shell")
# delete directory in the pg_location directory
cmd = "if [ -d '%s' ]; then cd '%s' && find -type d; fi" \
% \
(pglDir, pglDir)
(status, outputDir) = subprocess.getstatusoutput(cmd)
if (status != 0):
raise Exception(ErrorCode.GAUSS_502["GAUSS_50207"] %
instDir +
" Error:\n%s." % str(outputDir) +
"The cmd is %s" % cmd)
else:
resultDir = g_file.findFile(".", "d", "type")
resultDir.remove(".")
if (len(resultDir) > 0):
for infoDir in resultDir:
tmpinfoDir = pglDir + infoDir[1:]
for infoMount in resultMount:
if (tmpinfoDir.find(infoMount) < 0 and
infoMount.find(tmpinfoDir) < 0):
realPath = "'%s/%s'" % (pglDir,
infoDir)
g_file.removeDirectory(realPath)
cmd = "if [ -d '%s' ];then cd '%s' && find . ! -name " \
"'pg_location' " \
"! -name '..' ! -name '.' -print0 |xargs -r -0 -n100 rm " \
"-rf; " \
"fi" % (instDir, instDir)
(status, output) = subprocess.getstatusoutput(cmd)
if (status != 0):
raise Exception(ErrorCode.GAUSS_502["GAUSS_50207"] % instDir +
" Error:\n%s." % str(output) +
"The cmd is %s" % cmd)
def removeSocketFile(self, fileName):
"""
"""
g_file.removeFile(fileName, "shell")
