def doQuery(self): """ function: do query input : NA output : NA """ hostName = DefaultValue.GetHostIpOrName() sshtool = SshTool(self.context.clusterInfo.getClusterNodeNames()) cmd = queryCmd() if (self.context.g_opts.outFile != ""): cmd.outputFile = self.context.g_opts.outFile self.context.clusterInfo.queryClsInfo(hostName, sshtool, self.context.mpprcFile, cmd)
def distributeFiles(self): """ function: distribute package to every host input : NA output: NA """ self.logger.debug("Distributing files.") try: # get the all nodes hosts = self.clusterInfo.getClusterNodeNames() if DefaultValue.GetHostIpOrName() not in hosts: raise Exception(ErrorCode.GAUSS_516["GAUSS_51619"] % DefaultValue.GetHostIpOrName()) hosts.remove(DefaultValue.GetHostIpOrName()) # Send xml file to every host DefaultValue.distributeXmlConfFile(self.sshTool, self.xmlFile, hosts, self.mpprcFile) # Successfully distributed files self.logger.debug("Successfully distributed files.") except Exception as e: # failed to distribute package to every host raise Exception(str(e))
def is_local_node(host): """ function: check whether is or not local node input : NA output : NA """ if (host == DefaultValue.GetHostIpOrName()): return True allNetworkInfo = g_network.getAllNetworkIp() for network in allNetworkInfo: if (host == network.ipAddress): return True return False
def parseCommandLine(): """ function: parseCommandLine input: NA output: NA """ try: paraLine = sys.argv[1] paraLine = DefaultValue.encodeParaline(paraLine, DefaultValue.BASE_DECODE) paraLine = paraLine.strip() paraList = paraLine.split("*==SYMBOL==*") opts, args = getopt.getopt( paraList[1:], "U:C:D:T:P:l:hX:", ["help", "alarm=", "gucXml", "vc_mode", "dws-mode"]) except Exception as e: usage() GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50000"] % str(e)) if (len(args) > 0): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50000"] % str(args[0])) global g_opts g_opts = CmdOptions() for (key, value) in opts: if (key == "-h" or key == "--help"): usage() sys.exit(0) elif (key == "-U"): g_opts.clusterUser = value elif (key == "-D"): g_opts.dataGucParams.append(value) elif (key == "-T"): g_opts.configType = value elif (key == "-P"): g_opts.clusterStaticConfigFile = value elif (key == "-l"): g_opts.logFile = os.path.realpath(value) elif (key == "--alarm"): g_opts.alarmComponent = value elif (key == "--gucXml"): g_opts.gucXml = True elif (key == "--vc_mode"): g_opts.vcMode = True elif (key == "--dws-mode"): g_opts.dws_mode = True elif key == "-X": g_opts.clusterConf = os.path.realpath(value) Parameter.checkParaVaild(key, value)
def cleanLocalOsUser(self): """ function: Clean local os user input : NA output: NA """ if (not self.deleteUser): if (self.localMode): cmd = "rm -rf '%s'" % self.clusterInfo.appPath DefaultValue.execCommandWithMode(cmd, "delete install directory", self.sshTool, self.localMode, self.mpprcFile) return group = grp.getgrgid(pwd.getpwnam(self.user).pw_gid).gr_name # clean local user self.logger.log("Deleting local OS user.") cmd = "%s -U %s -l %s" % (OMCommand.getLocalScript( "Local_Clean_OsUser"), self.user, self.localLog) self.logger.debug("Command for deleting local OS user: %s" % cmd) (status, output) = subprocess.getstatusoutput(cmd) if (status != 0): self.logger.logExit(output) self.logger.log("Successfully deleted local OS user.") if (self.deleteGroup): # clean local user group self.logger.debug("Deleting local OS group.") cmd = "%s -t %s -u %s -l '%s' -X '%s'" % ( OMCommand.getLocalScript("Local_UnPreInstall"), ACTION_DELETE_GROUP, group, self.localLog, self.xmlFile) self.logger.debug("Command for deleting local OS group: %s" % cmd) (status, output) = subprocess.getstatusoutput(cmd) if (status != 0): self.logger.log(output.strip()) self.logger.debug("Deleting local group is completed.")
def check_cluster_version_consistency(self, clusterNodes, newNodes=None): """ """ self.logger.log("Check cluster version consistency.") if newNodes is None: newNodes = [] dic_version_info = {} # check version.cfg on every node. gp_home = DefaultValue.getEnv("GPHOME") gauss_home = DefaultValue.getEnv("GAUSSHOME") if not (os.path.exists(gp_home) and os.path.exists(gauss_home)): GaussLog.exitWithError(ErrorCode.GAUSS_502["GAUSS_50201"] % ("%s", "or %s") % (gp_home, gauss_home)) for ip in clusterNodes: if ip in newNodes: cmd = "pssh -s -H %s 'cat %s/version.cfg'" % \ (ip, DefaultValue.getEnv("GPHOME")) else: cmd = "pssh -s -H %s 'cat %s/bin/upgrade_version'" % \ (ip, DefaultValue.getEnv("GAUSSHOME")) status, output = subprocess.getstatusoutput(cmd) if (status != 0): raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd + " Error:\n%s" % str(output)) if len(output.strip().split()) < 3: raise Exception(ErrorCode.GAUSS_516["GAUSS_51623"]) dic_version_info[ip] = ",".join(output.strip().split()[1:]) self.logger.debug("The cluster version on every node.") for check_ip, version_info in dic_version_info.items(): self.logger.debug("%s : %s" % (check_ip, version_info)) if len(set(dic_version_info.values())) != 1: L_inconsistent = list(set(dic_version_info.values())) self.logger.debug("The package version on some nodes are " "inconsistent\n%s" % str(L_inconsistent)) raise Exception("The package version on some nodes are " "inconsistent,%s" % str(L_inconsistent)) self.logger.log("Successfully checked cluster version.")
def managerOperateStepDir(self, action='create', nodes=None): """ function: manager operate step directory input : NA output: currentStep """ if nodes is None: nodes = [] try: # Creating the backup directory if (action == "create"): cmd = "(if [ ! -d '%s' ];then mkdir -p '%s' -m %s;fi)" % ( self.operateStepDir, self.operateStepDir, DefaultValue.KEY_DIRECTORY_MODE) else: cmd = "(if [ -d '%s' ];then rm -rf '%s';fi)" % ( self.operateStepDir, self.operateStepDir) DefaultValue.execCommandWithMode(cmd, "%s temporary directory" % action, self.sshTool, self.localMode or self.isSingle, "", nodes) except Exception as e: raise Exception(str(e))
def checkRemoteFileExist(self, filepath): """ funciton:check file exist on remote node input:filepath output:dictionary """ existNodes = [] for nodeName in self.context.clusterInfo.getClusterNodeNames(): if (nodeName == DefaultValue.GetHostIpOrName()): continue if (self.sshTool.checkRemoteFileExist(nodeName, filepath, "")): existNodes.append(nodeName) return existNodes
def perCheck(self): """ function: 1.Check instance port 2.Check instance IP input : NA output: NA """ ipList = self.instInfo.listenIps ipList.extend(self.instInfo.haIps) portList = [] portList.append(self.instInfo.port) portList.append(self.instInfo.haPort) ipList = DefaultValue.Deduplication(ipList) portList = DefaultValue.Deduplication(portList) # check port for port in portList: self.__checkport(port, ipList) # check ip failIps = g_network.checkIpAddressList(ipList) if (len(failIps) > 0): raise Exception(ErrorCode.GAUSS_506["GAUSS_50600"] + " The IP is %s." % ",".join(failIps))
def installClusterApp(self): """ function: install cluster instance input : NA output: NA """ self.context.logger.log("Installing applications on all nodes.") # Installing applications cmd = "source %s;" % self.context.mpprcFile cmd += "%s -t %s -U %s -X %s -R %s -c %s -l %s %s" % ( OMCommand.getLocalScript("Local_Install"), ACTION_INSTALL_CLUSTER, self.context.user + ":" + self.context.group, self.context.xmlFile, self.context.clusterInfo.appPath, self.context.clusterInfo.name, self.context.localLog, self.getCommandOptions()) self.context.logger.debug("Command for installing application: %s" % cmd) # exec the cmd for install application on all nodes DefaultValue.execCommandWithMode(cmd, "Install applications", self.context.sshTool, self.context.isSingle, self.context.mpprcFile) self.context.logger.log("Successfully installed APP.")
def CleanInstanceDir(self): """ function: Clean instance directory input : NA output: NA """ self.logger.log("Deleting the instance's directory.") cmd = "%s -U %s -l '%s' -X '%s'" % (OMCommand.getLocalScript( "Local_Clean_Instance"), self.user, self.localLog, self.xmlFile) self.logger.debug("Command for deleting the instance: %s" % cmd) DefaultValue.execCommandWithMode(cmd, "delete the instances data", self.sshTool, self.localMode, self.mpprcFile) # clean upgrade temp backup path cmd = "rm -rf '%s'" % DefaultValue.getBackupDir("upgrade") self.logger.debug( "Command for deleting the upgrade temp backup path: %s" % cmd) DefaultValue.execCommandWithMode( cmd, "delete backup directory for upgrade", self.sshTool, self.localMode, self.mpprcFile) self.logger.log("Successfully deleted the instance's directory.")
def checkNode(self): """ function: check if the current node is to be uninstalled input : NA output: NA """ if (len( self.context.g_opts.nodeInfo) != 0 and self.context.g_opts.hostname == DefaultValue.GetHostIpOrName()): raise Exception( ErrorCode.GAUSS_516["GAUSS_51631"] % "coordinate" + "\nPlease perform this operation on other nodes " "because this node will be deleted.")
def doStart(self): """ function:start cluster input : NA output: NA """ self.context.logger.debug("Start the cluster.", "addStep") try: tmpGucFile = "" tmpGucPath = DefaultValue.getTmpDirFromEnv(self.context.user) tmpGucFile = "%s/tmp_guc" % tmpGucPath cmd = g_file.SHELL_CMD_DICT["deleteFile"] % (tmpGucFile, tmpGucFile) DefaultValue.execCommandWithMode(cmd, "Install applications", self.context.sshTool, self.context.isSingle, self.context.mpprcFile) # start cluster in non-native mode self.startCluster() except Exception as e: self.context.logger.logExit(str(e)) self.context.logger.debug("Successfully started the cluster.", "constant")
def getOmStatus(user): """ function : Get om status from file input : String output : NA """ # check status file statFile = os.path.join(DefaultValue.getTmpDirFromEnv(), DbClusterStatus.OM_STATUS_FILE) if (not os.path.isfile(statFile)): return DbClusterStatus.OM_STATUS_NORMAL # get om status from file status = DbClusterStatus.OM_STATUS_NORMAL return status
def doConfig(self): """ function: Do config action input : NA output: NA """ self.context.logger.log("Configuring.", "addStep") try: # prepared config cluster # AP: clean instance directory and check node config self.prepareConfigCluster() self.initNodeInstance() self.configInstance() self.distributeRackInfo() DefaultValue.enableWhiteList( self.context.sshTool, self.context.mpprcFile, self.context.clusterInfo.getClusterNodeNames(), self.context.logger) except Exception as e: # failed to clear the backup directory self.context.logger.logExit(str(e)) # Configuration is completed self.context.logger.log("Configuration is completed.", "constant")
def genCipherAndRandFile(self, hostList=None, initPwd=None): self.logger.debug("Encrypting cipher and rand files.") if hostList is None: hostList = [] appPath = DefaultValue.getInstallDir(self.user) binPath = os.path.join(appPath, "bin") retry = 0 while True: if not initPwd: sshpwd = getpass.getpass("Please enter password for database:") sshpwd_check = getpass.getpass("Please repeat for database:") else: sshpwd = sshpwd_check = initPwd if sshpwd_check != sshpwd: sshpwd = "" sshpwd_check = "" self.logger.error(ErrorCode.GAUSS_503["GAUSS_50306"] % "database" + "The two passwords are different, " "please enter password again.") else: cmd = "%s/gs_guc encrypt -M server -K %s -D %s " % ( binPath, sshpwd, binPath) (status, output) = subprocess.getstatusoutput(cmd) sshpwd = "" sshpwd_check = "" initPwd = "" if status != 0: self.logger.error(ErrorCode.GAUSS_503["GAUSS_50322"] % "database" + "Error:\n %s" % output) else: break if retry >= 2: raise Exception(ErrorCode.GAUSS_503["GAUSS_50322"] % "database") retry += 1 g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/server.key.cipher" % binPath) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/server.key.rand" % binPath) if len(hostList) == 0: for dbNode in self.clusterInfo.dbNodes: hostList.append(dbNode.name) if not self.isSingle: # localhost no need scp files for certFile in DefaultValue.BIN_CERT_LIST: scpFile = os.path.join(binPath, "%s" % certFile) self.sshTool.scpFiles(scpFile, binPath, hostList) self.logger.debug("Successfully encrypted cipher and rand files.")
def doCheck(self): parRes = "" flag = "Normal" cmd = "ls -l /lib/modules/`uname -r`/kernel/net/sctp/sctp.ko*" (status, output) = subprocess.getstatusoutput(cmd) if (status != 0 or output == "" or output.find( "No such file or directory") > 0): if DefaultValue.checkDockerEnv(): return flag = "Error" parRes += "There is no sctp service." else: cmd = "modprobe sctp;" cmd += "lsmod |grep sctp" (status, output) = subprocess.getstatusoutput(cmd) if (output == ""): flag = "Error" parRes += "sctp service is not loaded." cmd = "cat %s | grep '^insmod.*sctp.ko'" % DefaultValue.getOSInitFile() (status, output) = subprocess.getstatusoutput(cmd) if (status != 0 or output == ""): if (flag == "Normal"): flag = "Warning" parRes += "Sctp service is not set to boot from power on." self.result.val = parRes self.result.raw = output if (flag == "Error"): self.result.rst = ResultStatus.NG elif (flag == "Warning"): self.result.rst = ResultStatus.WARNING else: self.result.rst = ResultStatus.OK self.result.val = "Sctp service is Normal."
def checkSpecialChar(self): outputList = [] failList = [] pathList = [] paths = self.getDiskPath() for path in paths: if (not path or not os.path.isdir(path)): continue else: pathList.append(path) pool = ThreadPool(DefaultValue.getCpuSet()) results = pool.map(self.checkSingleSpecialChar, pathList) pool.close() pool.join() for outlist, flist in results: if (outlist): outputList.extend(outlist) if (flist): failList.extend(flist) if (len(outputList) > 0): outputList = DefaultValue.Deduplication(outputList) if (failList): failList = DefaultValue.Deduplication(failList) return outputList, failList
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 setEnvParameter(self): """ function: setting DBA environmental variables input: NA output: NA """ self.context.logger.log("Setting user environmental variables.", "addStep") try: # Setting DBA environmental variables cmdParam = "" # get then envParams for param in self.context.envParams: cmdParam += " -e \\\"%s\\\"" % param # set the environmental variables on all nodes cmd = "%s -t %s -u %s %s -l %s" % (OMCommand.getLocalScript( "Local_PreInstall"), ACTION_SET_USER_ENV, self.context.user, cmdParam, self.context.localLog) # check the mpprcFile if (self.context.mpprcFile != ""): cmd += " -s '%s'" % self.context.mpprcFile self.context.logger.debug( "Command for setting user's environmental variables: %s" % cmd) # set user's environmental variables DefaultValue.execCommandWithMode( cmd, "set user's environmental variables.", self.context.sshTool, self.context.localMode or self.context.isSingle, self.context.mpprcFile) except Exception as e: raise Exception(str(e)) self.context.logger.log( "Successfully set user environmental variables.", "constant")
def __init__(self, dropnode): """ """ self.context = dropnode self.user = self.context.user self.userProfile = self.context.userProfile self.group = self.context.group self.backupFilePrimary = '' self.localhostname = DefaultValue.GetHostIpOrName() self.logger = self.context.logger self.resultDictOfPrimary = [] self.replSlot = '' envFile = DefaultValue.getEnv("MPPDB_ENV_SEPARATE_PATH") if envFile: self.envFile = envFile else: self.envFile = "/etc/profile" gphomepath = DefaultValue.getEnv("GPHOME") if gphomepath: self.gphomepath = gphomepath else: (status, output) = subprocess.getstatusoutput("which gs_om") if "no gs_om in" in output: raise Exception(ErrorCode.GAUSS_518["GAUSS_51800"] % "$GPHOME") self.gphomepath = os.path.normpath( output.replace("/script/gs_om", "")) self.appPath = self.context.clusterInfo.appPath self.gsqlPath = "source %s;%s/bin/gsql" % (self.userProfile, self.appPath) currentTime = str(datetime.datetime.now()).replace(" ", "_").replace( ".", "_") self.dnIdForDel = [] for hostDelName in self.context.hostMapForDel.keys(): self.dnIdForDel += self.context.hostMapForDel[hostDelName]['dn_id'] self.commonOper = OperCommon(dropnode)
def getLockFiles(self): """ function: Get lock files input : NA output: NA """ fileList = [] # the static file must be exists tmpDir = os.path.realpath(DefaultValue.getTmpDirFromEnv()) pgsql = ".s.PGSQL.%d" % self.instInfo.port pgsqlLock = ".s.PGSQL.%d.lock" % self.instInfo.port fileList.append(os.path.join(tmpDir, pgsql)) fileList.append(os.path.join(tmpDir, pgsqlLock)) return fileList
def CleanLog(self): """ function: Clean default log input : NA output: NA """ self.logger.debug("Deleting log.", "addStep") # check if need delete instance if (not self.cleanInstance): self.logger.debug("No need to delete data.", "constant") return try: # clean log userLogDir = DefaultValue.getUserLogDirWithUser(self.user) cmd = g_file.SHELL_CMD_DICT["cleanDir"] % (userLogDir, userLogDir, userLogDir) # delete log dir DefaultValue.execCommandWithMode(cmd, "delete user log directory", self.sshTool, self.localMode, self.mpprcFile) except Exception as e: self.logger.exitWithError(str(e)) self.logger.debug("Successfully deleted log.", "constant")
def checkParameter(): """ function: check parameter for different action input : NA output: NA """ # check if user exist and is the right user if (g_opts.user != ''): DefaultValue.checkUser(g_opts.user) tmpDir = DefaultValue.getTmpDirFromEnv(g_opts.user) if (not os.path.exists(tmpDir)): GaussLog.exitWithError(ErrorCode.GAUSS_502["GAUSS_50201"] % ("temporary directory[" + tmpDir + "]")) # check the -t parameter if (g_opts.action == ""): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % 't' + '.') if (g_opts.action not in list(actioItemMap.keys())): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50004"] % "t") if (g_opts.logFile == ""): dirName = os.path.dirname(os.path.realpath(__file__)) g_opts.logFile = os.path.join(dirName, "gaussdb_localcheck.log")
def checkTmpDir(self, hostName): """ if the tmp dir id not exist, create it. """ tmpDir = os.path.realpath(DefaultValue.getTmpDirFromEnv()) checkCmd = 'if [ ! -d "%s" ]; then exit 1;fi;' % (tmpDir) sshTool = SshTool([hostName]) resultMap, outputCollect = sshTool.getSshStatusOutput( checkCmd, [hostName], self.envFile) ret = resultMap[hostName] if ret == STATUS_FAIL: self.logger.debug("Node [%s] does not have tmp dir. need to fix.") fixCmd = "mkdir -p %s" % (tmpDir) sshTool.getSshStatusOutput(fixCmd, [hostName], self.envFile) self.cleanSshToolFile(sshTool)
def checkHostnameMapping(clusterInfo, logFile): """ function: check host name mapping input: NA output: NA """ nodes = clusterInfo.getClusterNodeNames() if (len(nodes) > 0): try: pool = ThreadPool(DefaultValue.getCpuSet()) results = pool.map(OMCommand.checkHostname, nodes) pool.close() pool.join() except Exception as e: raise Exception(str(e))
def del_remote_pkgpath(self): """ delete remote package path om scripts, lib and version.cfg :return: """ if not self.context.is_new_root_path: current_path = self.get_package_path() script = os.path.join(current_path, "script") hostList = self.context.clusterInfo.getClusterNodeNames() hostList.remove(DefaultValue.GetHostIpOrName()) if not self.context.localMode and hostList: cmd = "rm -f %s/gs_*" % script self.context.sshTool.executeCommand(cmd, "", DefaultValue.SUCCESS, hostList, self.context.mpprcFile)
def __bakInstallPackage(self): """ function: backup install package for replace input : NA output: NA """ dirName = os.path.dirname(os.path.realpath(__file__)) packageFile = "%s/%s" % (os.path.join(dirName, "./../../"), DefaultValue.get_package_back_name()) # Check if MPPDB package exist if not os.path.exists(packageFile): self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50201"] % 'MPPDB package' + " Can not back up.") # Save MPPDB package to bin path destPath = "'%s'/bin/" % self.installPath g_file.cpFile(packageFile, destPath)
def doRefreshConf(self): """ function: do refresh conf input : NA output : NA """ if self.context.clusterInfo.isSingleNode(): self.logger.log( "No need to generate dynamic configuration file for one node.") return self.logger.log("Generating dynamic configuration file for all nodes.") hostName = DefaultValue.GetHostIpOrName() sshtool = SshTool(self.context.clusterInfo.getClusterNodeNames()) self.context.clusterInfo.createDynamicConfig(self.context.user, hostName, sshtool) self.logger.log("Successfully generated dynamic configuration file.")
def __checkOSVersion(self): """ function: Check operator system version, install binary file version. input : NA output: NA """ self.logger.log("Checking OS version.") try: if (not DefaultValue.checkOsVersion()): raise Exception(ErrorCode.GAUSS_519["GAUSS_51900"] + "The current system is: %s." % platform.platform()) except Exception as e: raise Exception(str(e)) self.logger.log("Successfully checked OS version.")