def copyAndModCertFiles(self): """ function : copy and chage permission cert files input : NA output : NA """ user = g_OSlib.getUserInfo()["name"] appPath = DefaultValue.getInstallDir(user) caPath = os.path.join(appPath, "share/sslcert/om") # cp cert files g_file.cpFile("%s/server.crt" % caPath, "%s/" % self.instInfo.datadir) g_file.cpFile("%s/server.key" % caPath, "%s/" % self.instInfo.datadir) g_file.cpFile("%s/cacert.pem" % caPath, "%s/" % self.instInfo.datadir) g_file.cpFile("%s/server.key.cipher" % caPath, "%s/" % self.instInfo.datadir) g_file.cpFile("%s/server.key.rand" % caPath, "%s/" % self.instInfo.datadir) # change mode g_file.changeMode(DefaultValue.KEY_FILE_MODE, "%s/server.crt" % self.instInfo.datadir) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "%s/server.key" % self.instInfo.datadir) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "%s/cacert.pem" % self.instInfo.datadir) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "%s/server.key.cipher" % self.instInfo.datadir) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "%s/server.key.rand" % self.instInfo.datadir)
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 __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 __distributeBackupFile(self, tmp_backupDir, flag): """ function: distribute Backup File input : tmp_backupDir, flag output: NA """ # compresses the configuration files for all node backups tarFiles = "%s_*.tar" % flag tarName = "%s.tar" % flag cmd = g_file.SHELL_CMD_DICT["compressTarFile"] \ % (tmp_backupDir, tarName, tarFiles, DefaultValue.KEY_FILE_MODE, tarName) if (flag == "parameter"): (status, output) = subprocess.getstatusoutput(cmd) if (status != 0): raise Exception( ErrorCode.GAUSS_514["GAUSS_51400"] % cmd + " Error:\n%s" % output) else: self._runCmd(cmd) # prepares the backup directory for the specified node cmd = g_file.SHELL_CMD_DICT["createDir"] \ % (self.context.backupDir, self.context.backupDir, DefaultValue.KEY_DIRECTORY_MODE) self._runCmd(cmd, self.context.nodename) # send backup package to the specified node from the local node originalFile = "'%s'/%s.tar" % (tmp_backupDir, flag) if flag == "parameter": if self.context.nodename != [g_OSlib.getHostName()]: self.context.sshTool.scpFiles( originalFile, self.context.backupDir, self.context.nodename) else: g_file.cpFile(originalFile, self.context.backupDir) else: targetFile = "'%s'/%s.tar" % (self.context.backupDir, flag) cmd = g_file.SHELL_CMD_DICT["copyFile"] % ( originalFile, targetFile) self._runCmd(cmd)
def distributeDNCert(self, certList, dnDict=None): """ function: distribute ssl cert files on single_inst cluster input: certList: cert files list dnDict: dictionary output: NA """ tempDir = "tempCertDir" gphost = DefaultValue.getTmpDirFromEnv() if dnDict is None: dnDict = {} dnName = dnDict.keys() certPathList = [] self.logger.debug(certList) for num in iter(certList): sslPath = os.path.join(os.path.join(gphost, tempDir), num) certPathList.append(sslPath) # local mode if self.context.g_opts.localMode: localDnDir = dnDict[DefaultValue.GetHostIpOrName()] for num in range(len(certList)): # distribute gsql SSL cert if (os.path.isfile(os.path.join(localDnDir, certList[num]))): os.remove(os.path.join(localDnDir, certList[num])) if (os.path.isfile(certPathList[num])): g_file.cpFile(certPathList[num], os.path.join(localDnDir, certList[num])) g_file.changeMode(DefaultValue.KEY_FILE_MODE, os.path.join(localDnDir, certList[num])) # remove 'sslcrl-file.crl' file if (DefaultValue.SSL_CRL_FILE not in certList and os.path.isfile( os.path.join(localDnDir, DefaultValue.SSL_CRL_FILE))): os.remove(os.path.join(localDnDir, DefaultValue.SSL_CRL_FILE)) # config 'sslcrl-file.crl' option in 'postgresql.conf' if (os.path.isfile( os.path.join(localDnDir, DefaultValue.SSL_CRL_FILE))): cmd = "gs_guc set " \ "-D %s -c \"ssl_crl_file=\'%s\'\"" % \ (localDnDir, DefaultValue.SSL_CRL_FILE) (status, output) = subprocess.getstatusoutput(cmd) if (status != 0): raise Exception((ErrorCode.GAUSS_514["GAUSS_51400"] % cmd) + "Failed set 'ssl_crl_file' option." + "Error: \n%s" % output) else: cmd = "gs_guc set -D %s -c \"ssl_crl_file=\'\'\"" \ % localDnDir (status, output) = subprocess.getstatusoutput(cmd) if (status != 0): raise Exception((ErrorCode.GAUSS_514["GAUSS_51400"] % cmd) + "Failed set 'ssl_crl_file' option." + "Error: \n%s" % output) # remove backup flag file 'certFlag' if (os.path.isfile(os.path.join(localDnDir, 'certFlag'))): os.remove(os.path.join(localDnDir, 'certFlag')) self.logger.log( "Replace SSL cert files with local mode successfully.") return # not local mode for node in dnName: for num in range(len(certList)): sshcmd = g_file.SHELL_CMD_DICT["deleteFile"] % (os.path.join( dnDict[node], certList[num]), os.path.join(dnDict[node], certList[num])) self.sshTool.executeCommand(sshcmd, "Delete read only cert file.", DefaultValue.SUCCESS, [node], self.context.g_opts.mpprcFile) if (os.path.exists(certPathList[num])): self.sshTool.scpFiles(certPathList[num], dnDict[node], [node]) # change permission of cert file 600, # there no need to is exists file, # because the files must be exist. sshcmd = g_file.SHELL_CMD_DICT["changeMode"] % ( DefaultValue.KEY_FILE_MODE, os.path.join(dnDict[node], certList[num])) self.sshTool.executeCommand(sshcmd, "Change file permisstion.'", DefaultValue.SUCCESS, [node], self.context.g_opts.mpprcFile) if (DefaultValue.SSL_CRL_FILE in certList): if (node == DefaultValue.GetHostIpOrName()): sshcmd = "gs_guc set " \ "-D %s -c \"ssl_crl_file='%s'\"" \ % (dnDict[node], DefaultValue.SSL_CRL_FILE) else: sshcmd = "gs_guc set " \ " -D %s -c \"ssl_crl_file=\\\\\\'%s\\\\\\'\"" \ % (dnDict[node], DefaultValue.SSL_CRL_FILE) self.sshTool.executeCommand(sshcmd, "Find 'ssl_crl_file'", DefaultValue.SUCCESS, [node], self.context.g_opts.mpprcFile) else: # no ssl cert file there will delete old cert file, # and config option ssl_crl_file = '' sshcmd = g_file.SHELL_CMD_DICT["deleteFile"] % ( os.path.join(dnDict[node], DefaultValue.SSL_CRL_FILE), os.path.join(dnDict[node], DefaultValue.SSL_CRL_FILE)) self.sshTool.executeCommand(sshcmd, "Find 'ssl_crl_file'", DefaultValue.SUCCESS, [node], self.context.g_opts.mpprcFile) if (node == DefaultValue.GetHostIpOrName()): sshcmd = "gs_guc set " \ "-D %s -c \"ssl_crl_file=\'\'\"" % (dnDict[node]) else: sshcmd = \ "gs_guc set " \ "-D %s " \ "-c \"ssl_crl_file=\\\\\\'\\\\\\'\"" % (dnDict[node]) self.sshTool.executeCommand(sshcmd, "Find 'ssl_crl_file'", DefaultValue.SUCCESS, [node], self.context.g_opts.mpprcFile) # remove file 'sslcrl-file.crl' sshcmd = g_file.SHELL_CMD_DICT["deleteFile"] % ( os.path.join(dnDict[node], DefaultValue.SSL_CRL_FILE), os.path.join(dnDict[node], DefaultValue.SSL_CRL_FILE)) self.sshTool.executeCommand(sshcmd, "Delete read only cert file.", DefaultValue.SUCCESS, [node], self.context.g_opts.mpprcFile) # remove backup flag file 'certFlag' sshcmd = g_file.SHELL_CMD_DICT["deleteFile"] % (os.path.join( dnDict[node], "certFlag"), os.path.join(dnDict[node], "certFlag")) self.sshTool.executeCommand(sshcmd, "Delete backup flag file.", DefaultValue.SUCCESS, [node], self.context.g_opts.mpprcFile) self.logger.log("%s replace SSL cert files successfully." % node)
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 doRestore(self): """ function: restore files Restoring binary files: 1.decompress tar file 2.Check binary files 3.Create installation path 4.Restore binary files to install path Restoring parameter files: 1.decompress tar file 2.delete temporary directory 3.extract parameter files to the temporary directory 4.check hostname and parameter 5.Restore parameter files 6.Remove the temporary directory input : NA output: NA """ self.logger.log("Restoring files.") if self.restoreBin: self.logger.log("Restoring binary files.") try: # decompress tar file self.decompressTarFile("binary") # Checking binary files self.logger.debug("Checking if binary files exist.") tarName = os.path.join(self.restoreDir, self.binTarName) if (not os.path.exists(tarName)): raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % "Binary files") # Creating installation path self.logger.debug( "Creating installation path if did not exist.") if (not os.path.exists(self.installPath)): os.makedirs(self.installPath, DefaultValue.KEY_DIRECTORY_PERMISSION) # Restore binary files to install path. self.logger.debug("Restore binary files to install path.") g_file.cleanDirectoryContent(self.installPath) cmd = g_file.SHELL_CMD_DICT["decompressTarFile"] % ( self.restoreDir, tarName) cmd += " && " cmd += g_file.SHELL_CMD_DICT["copyFile"] % ( "'%s'/*" % self.binExtractName, self.installPath) self.logger.debug("Command for restoring binary files:%s." % cmd) (status, output) = subprocess.getstatusoutput(cmd) if (status != 0): raise Exception(ErrorCode.GAUSS_502["GAUSS_50220"] % ( "binary files to install path[%s]" % \ self.installPath) + " Error: \n%s" % output) g_file.removeDirectory( os.path.join(self.restoreDir, self.binExtractName)) except Exception as e: raise Exception(str(e)) self.logger.log("Successfully restored binary files.") if self.restorePara: self.logger.log("Restoring parameter files.") # Re-obtaining clusterInfo because the restoreBin succeeded if self.dbNodeInfo is None: self.clusterInfo.initFromStaticConfig(self.user, g_staticFile) hostName = DefaultValue.GetHostIpOrName() self.dbNodeInfo = self.clusterInfo.getDbNodeByName(hostName) if self.dbNodeInfo is None: self.logger.logExit(ErrorCode.GAUSS_516["GAUSS_51619"] % hostName) # Restoring parameter files. try: # decompress tar file self.decompressTarFile("parameter") # delete temporary directory self.logger.debug( "Delete temporary directory if it has existed.") temp_dir = os.path.join(self.restoreDir, "parameter_%s" % HOSTNAME) if (os.path.exists(temp_dir)): g_file.removeDirectory(temp_dir) # extract parameter files to the temporary directory self.logger.debug( "Extract parameter files to the temporary directory.") tarName = os.path.join(self.restoreDir, self.paraTarName) if (not os.path.exists(tarName)): if (g_ignoreMiss): self.logger.error(ErrorCode.GAUSS_502["GAUSS_50201"] % "parameter files") sys.exit(0) else: raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % "parameter files") cmd = g_file.SHELL_CMD_DICT["decompressTarFile"] % ( self.restoreDir, tarName) (status, output) = subprocess.getstatusoutput(cmd) if (status != 0): raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd + " Error: \n%s" % output) # check hostname self.logger.debug("Checking hostname.") self.__checkHostName("%s/%s" % (temp_dir, self.hostnameFileName)) # check parameter self.logger.debug("Checking parameter files.") paraFileList = [] self.__checkParaFiles(temp_dir, paraFileList) self.logger.debug("Restoring parameter files.") paraFileNum = len(paraFileList) for i in range(paraFileNum): tarFileName, paraFilePath = paraFileList[i].split('|') g_file.cpFile(os.path.join(temp_dir, tarFileName), paraFilePath) self.logger.debug("Remove the temporary directory.") g_file.removeDirectory(temp_dir) except Exception as e: g_file.removeDirectory(temp_dir) raise Exception(str(e)) self.logger.log("Successfully restored parameter files.") self.logger.log("Successfully restored files.")
def __collectParaFilesToTempDir(self, inst, temp_dir): """ function: 1.check the instance directory 2.get the parameter file of instance 3.copy the parameter file to backup directory input : inst, temp_dir output: NA """ if (not os.path.exists(inst.datadir) or len( os.listdir(inst.datadir)) == 0): if (g_ignoreMiss): self.logger.log( "Data directory (%s) of instance (%s) " "does not exist or is empty." % \ (inst.datadir, str(inst))) return else: raise Exception(ErrorCode.GAUSS_502["GAUSS_50228"] % \ (("data directory [%s] of instance [%s]") % (inst.datadir, str(inst)))) paraFileList = {} if (inst.instanceRole == DefaultValue.INSTANCE_ROLE_CMSERVER): paraFileList[CM_SERVER_CONF] = os.path.join(inst.datadir, CM_SERVER_CONF) elif (inst.instanceRole == DefaultValue.INSTANCE_ROLE_CMAGENT): paraFileList[CM_AGENT_CONF] = os.path.join(inst.datadir, CM_AGENT_CONF) elif (inst.instanceRole == DefaultValue.INSTANCE_ROLE_GTM): paraFileList[GTM_CONF] = os.path.join(inst.datadir, GTM_CONF) elif (inst.instanceRole == DefaultValue.INSTANCE_ROLE_COODINATOR): paraFileList[POSTGRESQL_CONF] = os.path.join(inst.datadir, POSTGRESQL_CONF) paraFileList[POSTGRESQL_HBA_CONF] = os.path.join( inst.datadir, POSTGRESQL_HBA_CONF) elif (inst.instanceRole == DefaultValue.INSTANCE_ROLE_DATANODE): paraFileList[POSTGRESQL_CONF] = os.path.join( inst.datadir, POSTGRESQL_CONF) paraFileList[POSTGRESQL_HBA_CONF] = os.path.join( inst.datadir, POSTGRESQL_HBA_CONF) else: raise Exception(ErrorCode.GAUSS_512["GAUSS_51204"] % ( "specified", inst.instanceRole)) for key in paraFileList: if (not os.path.exists(paraFileList[key])): self.logger.debug( "The parameter path is: %s." % paraFileList[key]) if (g_ignoreMiss): self.logger.log( "Parameter file of instance [%s] is not existed." % ( str(inst))) return else: raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % ( 'parameter file of instance [%s]' % ( str(inst)))) for key in paraFileList: backupFileName = "%d_%s" % (inst.instanceId, key) g_file.cpFile(paraFileList[key], os.path.join(temp_dir, backupFileName))