def __saveUpgradeVerionInfo(self): """ function: save upgrade version info input: NA output: NA """ if self.dws_mode: versionCfgFile = "%s/version.cfg" % DefaultValue.DWS_PACKAGE_PATH upgradeVersionFile = "%s/bin/upgrade_version" % self.installPath else: dirName = os.path.dirname(os.path.realpath(__file__)) versionCfgFile = "%s/../../version.cfg" % dirName upgradeVersionFile = "%s/bin/upgrade_version" % self.installPath if not os.path.exists(versionCfgFile): self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50201"] % versionCfgFile) if not os.path.isfile(versionCfgFile): self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50210"] % versionCfgFile) try: # read version info from version.cfg file (newClusterVersion, newClusterNumber, commitId) = \ VersionInfo.get_version_info(versionCfgFile) # save version info to upgrade_version file if os.path.isfile(upgradeVersionFile): os.remove(upgradeVersionFile) g_file.createFile(upgradeVersionFile) g_file.writeFile(upgradeVersionFile, [newClusterVersion, newClusterNumber, commitId]) g_file.changeMode(DefaultValue.KEY_FILE_MODE, upgradeVersionFile) except Exception as e: self.logger.logExit(str(e))
def __fixInstallPathPermission(self): """ function: fix the whole install path's permission input : NA output: NA """ installPathFileTypeDict = {} try: # get files type installPathFileTypeDict = g_file.getFilesType(self.installPath) except Exception as e: self.logger.logExit(str(e)) for key in installPathFileTypeDict: if not os.path.exists(key): self.logger.debug("[%s] does not exist. Please skip it." % key) continue if os.path.islink(key): self.logger.debug("[%s] is a link file. Please skip it." % key) continue # skip DbClusterInfo.pyc if os.path.basename(key) == "DbClusterInfo.pyc": continue if (installPathFileTypeDict[key].find("executable") >= 0 or installPathFileTypeDict[key].find("ELF") >= 0 or installPathFileTypeDict[key].find("directory") >= 0): g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, key, True) else: g_file.changeMode(DefaultValue.KEY_FILE_MODE, key)
def writeOperateStep(self, stepName, nodes=None): """ function: write operate step signal input : step output: NA """ if nodes is None: nodes = [] try: # write the step into INSTALL_STEP # open the INSTALL_STEP with open(self.operateStepFile, "w") as g_DB: # write the INSTALL_STEP g_DB.write(stepName) g_DB.write(os.linesep) g_DB.flush() # change the INSTALL_STEP permissions g_file.changeMode(DefaultValue.KEY_FILE_MODE, self.operateStepFile) # distribute file to all nodes cmd = "mkdir -p -m %s '%s'" % (DefaultValue.KEY_DIRECTORY_MODE, self.operateStepDir) DefaultValue.execCommandWithMode( cmd, "create backup directory " "on all nodes", self.sshTool, self.localMode or self.isSingle, "", nodes) if not self.localMode and not self.isSingle: self.sshTool.scpFiles(self.operateStepFile, self.operateStepDir, nodes) except Exception as e: # failed to write the step into INSTALL_STEP raise Exception(str(e))
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 __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 __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 __createStaticConfig(self): """ function: Save cluster info to static config input : NA output: NA """ staticConfigPath = "%s/bin/cluster_static_config" % self.installPath # save static config nodeId = self.dbNodeInfo.id self.clusterInfo.saveToStaticConfig(staticConfigPath, nodeId) g_file.changeMode(DefaultValue.KEY_FILE_MODE, staticConfigPath) g_file.changeOwner(self.user, staticConfigPath, False)
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 __makeDirForDBUser(self, path, desc): """ function: Create a dir for DBUser: 1.create a dir for DB user 2.Check if target directory is writeable for user input : path, desc output: NA """ self.logger.debug("Making %s directory[%s] for database node user." % (desc, path)) g_file.createDirectory(path) g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, path) if (not g_file.checkDirWriteable(path)): self.logger.logExit(ErrorCode.GAUSS_501["GAUSS_50102"] % (path, self.user))
def checkFilePermission(self, filename): """ Function : check file: 1.exist 2. isfile 3. permission Note : 1.You must check that the file exist and is a file. 2.You can choose whether to check the file's permission:executable. """ # Check if the file exists if (not os.path.exists(filename)): raise Exception("The file %s does not exist." % filename) # Check whether the file if (not os.path.isfile(filename)): raise Exception("%s is not file." % filename) # Check the file permissions # Modify the file permissions if (not os.access(filename, os.X_OK)): g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, filename)
def recursivePath(self, filepath): """ function: recursive path input: filepath output: NA """ fileList = os.listdir(filepath) for fileName in fileList: fileName = os.path.join(filepath, fileName) # change the owner of files g_file.changeOwner(self.context.g_opts.user, fileName) if (os.path.isfile(fileName)): # change fileName permission g_file.changeMode(DefaultValue.KEY_FILE_MODE, fileName) else: # change directory permission g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, fileName, True) self.recursivePath(fileName)
def __checkPgsqlDir(self): """ function: 1.Check pgsql directory 2.change permission 3.Check if target directory is writeable for user input : NA output: NA """ tmpDir = DefaultValue.getTmpDirFromEnv() self.logger.log("Checking directory [%s]." % tmpDir) if (not os.path.exists(tmpDir)): self.logger.logExit(ErrorCode.GAUSS_502["GAUSS_50201"] % tmpDir + " Please create it first.") self.__pgsqlFiles = os.listdir(tmpDir) g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, tmpDir) if (not g_file.checkDirWriteable(tmpDir)): self.logger.logExit(ErrorCode.GAUSS_501["GAUSS_50102"] % (tmpDir, self.user))
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)) # change owner for tar file. g_file.changeOwner(self.user, self.installPath, True) self.logger.log("Successfully decompressed bin file.")
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 checkLimitsParameter(limitPara, isSet): """ function: check and set the limit parameter input: limitPara, isSet output: NA """ # utility class for this function only class limitsconf_data: """ Class: limitsconf_data """ def __init__(self, expected): """ function: constructor """ self.domain = None self.value_found = None self.value_expected = expected # check the limit parameter table = dict() for key in list(limitPara.keys()): cmd = "ulimit -a | grep -F '%s' 2>/dev/null" % key (status, output) = subprocess.getstatusoutput(cmd) if (status == 0): resLines = output.split('\n') resList = resLines[0].split(' ') limitValue = resList[-1].strip() if (limitPara[key] == 'unlimited'): resultList.append(2) if limitValue != 'unlimited': g_logger.log(" Warning reason: variable '%s'" " RealValue '%s' ExpectedValue '%s'" % (key, limitValue, limitPara[key])) if (key == 'virtual memory'): table[('soft', 'as')] = limitsconf_data(limitPara[key]) table[('hard', 'as')] = limitsconf_data(limitPara[key]) if (key == 'max user processes'): table[('soft', 'nproc')] = limitsconf_data(limitPara[key]) table[('hard', 'nproc')] = limitsconf_data(limitPara[key]) elif (limitPara[key] != 'unlimited'): if (limitValue == 'unlimited'): continue if (int(limitValue) < int(limitPara[key])): if (key == "stack size"): resultList.append(1) g_logger.log(" Abnormal reason: variable '%s'" " RealValue '%s' ExpectedValue '%s'" % (key, limitValue, limitPara[key])) else: resultList.append(2) g_logger.log(" Warning reason: variable '%s'" " RealValue '%s' ExpectedValue '%s'" % (key, limitValue, limitPara[key])) if (key == 'stack size'): table[('soft', 'stack')] = limitsconf_data(limitPara[key]) table[('hard', 'stack')] = limitsconf_data(limitPara[key]) if (key == 'open files'): table[('soft', 'nofile')] = limitsconf_data(limitPara[key]) table[('hard', 'nofile')] = limitsconf_data(limitPara[key]) else: resultList.append(1) g_logger.debug("The cmd is %s " % cmd) g_logger.log(" Failed to obtain '%s'. Error: \n%s" % (key, output)) # set the open file numbers if isSet and len(list(table.keys())): for key in list(table.keys()): if (key[1] == "nofile" or key[1] == "nproc"): limitPath = '/etc/security/limits.d/' nofiles = glob.glob("/etc/security/limits.d/*.conf") for conf in nofiles: g_file.changeMode(DefaultValue.HOSTS_FILE, conf) SetLimitsConf(key[0], key[1], table[key].value_expected, conf) if os.path.isfile(os.path.join(limitPath, '91-nofile.conf')): limitFile = '91-nofile.conf' else: limitFile = '90-nofile.conf' if (key[1] == "stack" or key[1] == "as" or key[1] == "nproc"): limitPath = '/etc/security/' limitFile = 'limits.conf' if (checkLimitFile(limitPath, limitFile) != 0): return SetLimitsConf(key[0], key[1], table[key].value_expected, limitPath + limitFile) g_logger.log(" Set variable '%s %s' to '%s'" % (key[0], key[1], table[key].value_expected))
def __fixFilePermission(self): """ function: modify permission for app path input: NA ouput: NA """ self.logger.log("Fixing file permission.") binPath = "'%s'/bin" % self.installPath g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, binPath, True) libPath = "'%s'/lib" % self.installPath g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, libPath, True) sharePath = "'%s'/share" % self.installPath g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, sharePath, True) etcPath = "'%s'/etc" % self.installPath g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, etcPath, True) includePath = "'%s'/include" % self.installPath g_file.changeMode(DefaultValue.KEY_DIRECTORY_MODE, includePath, True) tarFile = "'%s'/bin/'%s'" % (self.installPath, DefaultValue.get_package_back_name()) if (os.path.isfile(tarFile)): g_file.changeMode(DefaultValue.KEY_FILE_MODE, tarFile) # ./script/util/*.conf *.service g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/bin/script/gspylib/etc/conf/check_list.conf" % self.installPath) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/bin/script/gspylib/etc/conf/" "check_list_dws.conf" % self.installPath) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/bin/script/gspylib/etc/conf/gs-OS-set.service" % self.installPath) # bin config file g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/bin/alarmItem.conf" % self.installPath) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/bin/cluster_guc.conf" % self.installPath) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/bin/upgrade_version" % self.installPath) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/bin/retry_errcodes.conf" % self.installPath) g_file.changeMode(DefaultValue.KEY_FILE_MODE, "'%s'/bin/cluster_static_config" % self.installPath) # ./script/local/*.sql cmd = "find '%s'/bin/script -type f -name \"*.sql\" -exec" \ " chmod 600 {} \\;" % self.installPath # ./lib files cmd += " && find '%s'/lib/ -type f -exec chmod 600 {} \\;" \ % self.installPath # ./share files cmd += " && find '%s'/share/ -type f -exec chmod 600 {} \\;" \ % self.installPath self.logger.debug("Command: %s" % cmd) (status, output) = subprocess.getstatusoutput(cmd) if status != 0: self.logger.log(output) self.logger.logExit(ErrorCode.GAUSS_501["GAUSS_50107"] % "app.")
def doSet(self): resultStr = "" for dirName in g_chList: g_file.changeOwner(self.user, dirName, True) g_file.changeMode(DIRECTORY_MODE, dirName) self.result.val = "Set DirPermissions completely."
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 chmodFile(fileName, permission=FILE_MODE, user=""): # Modify the file permissions g_file.changeMode(permission, fileName) if (user): g_file.changeOwner(user, fileName)
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))