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"])