#!/usr/bin/env python3 # -*- coding:utf-8 -*- ############################################################################# # Copyright (c) 2020 Huawei Technologies Co.,Ltd. # # openGauss is licensed under Mulan PSL v2. # You can use this software according to the terms # and conditions of the Mulan PSL v2. # You may obtain a copy of Mulan PSL v2 at: # # http://license.coscl.org.cn/MulanPSL2 # # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, # WITHOUT WARRANTIES OF ANY KIND, # EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, # MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. # See the Mulan PSL v2 for more details. # ---------------------------------------------------------------------------- # Description : gs_om is a utility to manage a Gauss200 cluster. ############################################################################# import subprocess import os import sys import pwd from gspylib.common.GaussLog import GaussLog from gspylib.common.ErrorCode import ErrorCode from gspylib.common.ParameterParsecheck import Parameter from gspylib.common.Common import DefaultValue from gspylib.common.ParallelBaseOM import ParallelBaseOM from gspylib.threads.SshTool import SshTool from impl.om.OLAP.OmImplOLAP import OmImplOLAP from domain_utils.cluster_file.cluster_log import ClusterLog from base_utils.os.env_util import EnvUtil from base_utils.os.file_util import FileUtil from base_utils.os.user_util import UserUtil from domain_utils.domain_common.cluster_constants import ClusterConstants from domain_utils.cluster_os.cluster_user import ClusterUser # action type ACTION_START = "start" ACTION_STOP = "stop" ACTION_RESTART = "restart" ACTION_STATUS = "status" ACTION_REBUID = "generateconf" ACTION_CERT = "cert" STOP_MODE_FAST = "fast" STOP_MODE_IMMEDIATE = "immediate" ACTION_VIEW = "view" ACTION_QUERY = "query" ACTION_KERBEROS = "kerberos" ACTION_REFRESHCONF = "refreshconf" # postgis ACTION_DEL_POSTGIs = "rmlib" class CmdOptions(): """ define option """ def __init__(self): self.action = "" # if action is "express", use this parameter to store the list of # cluster node names passed by the # command line option "-h". self.nodeName = "" self.time_out = None # if action is "express", use this parameter to store whether to # show the detail message of cluster # node state. self.show_detail = False self.showAll = False self.dataDir = "" self.outFile = "" self.logFile = "" self.localLog = "" self.reset = False self.distribute = False self.certFile = "" self.certRollback = False self.NormalCNNode = [] self.mode = "" self.user = "" self.group = "" self.userInfo = "" self.mpprcFile = "" self.confFile = "" self.localMode = False self.instanceName = "" self.azName = "" self.nodeId = -1 self.clusterInfo = None self.security_mode = "off" self.cluster_number = "" # kerberos self.kerberosMode = "" self.clusterUser = "" self.kerberosType = "" self.clusterToolPath = "" # change_static self.old_values = [] self.new_values = [] ########################################### class OperationManager(ParallelBaseOM): def __init__(self): """ init the command options save command line parameter values """ ParallelBaseOM.__init__(self) # command line parameter collection self.g_opts = CmdOptions() self.OM_PARAMETER_DIR = "" def usage(self): """ gs_om is a utility to manage a cluster. Usage: gs_om -? | --help gs_om -V | --version OLAP scene: gs_om -t start [-h HOSTNAME] [-D dataDir] [--time-out=SECS] [--security-mode=MODE] [--cluster-number=None] [-l LOGFILE] gs_om -t stop [-h HOSTNAME] [-D dataDir] [--time-out=SECS] [-m MODE] [-l LOGFILE] gs_om -t restart [-h HOSTNAME] [-D dataDir] [--time-out=SECS] [--security-mode=MODE] [-l LOGFILE] [-m MODE] gs_om -t status [-h HOSTNAME] [-o OUTPUT] [--detail] [--all] [--az=AZ] [-l LOGFILE] [--time-out=SECS] gs_om -t generateconf -X XMLFILE [--distribute] [-l LOGFILE] gs_om -t generateconf --old-values=old --new-values=new [--distribute] [-l LOGFILE] gs_om -t cert [--cert-file=CERTFILE | --rollback] [-L] [-l LOGFILE] gs_om -t kerberos -m [install|uninstall] -U USER [-l LOGFILE] [--krb-server|--krb-client] gs_om -t view [-o OUTPUT] gs_om -t query [-o OUTPUT] [--time-out=SECS] gs_om -t refreshconf General options: -t Type of the OM command. -l Path of log file. -?, --help Show help information for this utility, and exit the command line mode. -V, --version Show version information. Options for start -h Name of the host to be started. -D Path of dn --time-out=SECS Maximum waiting time when start the cluster or node. --security-mode=MODE database start with security mode: on or off on: start with security mode off: start without security mode --cluster-number database start with kernel version corresponding to version.cfg Options for stop -h Name of the host to be shut down. -m, --mode=MODE Shutdown mode. It can be f (fast), or i (immediate). -D Path of dn --time-out=SECS Maximum waiting time when start the cluster or node. Options for restart -h Name of the host to be started. -m, --mode=MODE Shutdown mode. It can be f (fast), or i (immediate). -D Path of dn --time-out=SECS Maximum waiting time when start the cluster or node. --security-mode=MODE database start with security mode: on or off on: start with security mode off: start without security mode Options for status -h Name of the host whose status is to be queried. --az=AZ Name of the single az whose status is to be queried. -o Save the result to the specified file. --detail Show detailed status information. --all Show all database node status information. --time-out=SECS Maximum waiting time when query cluster status. Options for generating configuration files -X Path of the XML configuration file. --old-values IP or hostname or port like "host1,ip1,port1" --new-values IP or hostname or port like "host1,ip1,port1" --distribute Distribute the static configuration file to installation directory of cluster nodes. Options for cert --cert-file Path of cert file. --rollback Perform rollback SSL cert files. -L local mode. Options for kerberos -m Kerberos management mode. It can be install or uninstall. -U %s cluster user. Install options: --krb-server Execute install for server. This parameter only work for install --krb-client Execute install for client. This parameter only work for install """ print(self.usage.__doc__) def initGlobal(self): """ function:Init logger input:NA output:NA """ try: # Init logger self.xmlFile = self.g_opts.confFile self.logFile = self.g_opts.logFile self.initLogger(self.g_opts.action) if (os.getuid() != 0): FileUtil.modifyFileOwnerFromGPHOME(self.logger.logFile) dirName = os.path.dirname(self.g_opts.logFile) self.g_opts.localLog = os.path.join(dirName, ClusterConstants.LOCAL_LOG_FILE) if self.g_opts.action == ACTION_REBUID and self.g_opts.confFile: self.initClusterInfo() else: # Initialize the self.clusterInfo variable if (self.g_opts.action == ACTION_STATUS): self.initClusterInfoFromStaticFile(self.g_opts.user, False) else: self.initClusterInfoFromStaticFile(self.g_opts.user) # Obtain the owner and group of the cluster installation directory if self.g_opts.action != ACTION_KERBEROS: (self.g_opts.user, self.g_opts.group) = UserUtil.getPathOwner( self.clusterInfo.appPath) if self.g_opts.user == "" or self.g_opts.group == "": raise Exception(ErrorCode.GAUSS_503["GAUSS_50308"]) # Init base member self.user = self.g_opts.user self.group = self.g_opts.group # init components if self.g_opts.action != ACTION_STATUS: self.initComponent() except Exception as e: GaussLog.exitWithError(str(e)) def checkAction(self, ParaDict): """ """ if (ParaDict.__contains__("action")): self.g_opts.action = ParaDict.get("action") if (len(self.g_opts.action) == 0): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % "t" + ".") def parseNode(self, ParaDict): """ """ if (self.g_opts.action == ACTION_START or self.g_opts.action == ACTION_STOP or self.g_opts.action == ACTION_STATUS or self.g_opts.action == ACTION_RESTART): if (ParaDict.__contains__("nodename")): nodename = ParaDict.get("nodename") self.g_opts.estimateNodeName = nodename # Only one -h parameter can be entered if (len(nodename) != 1): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50006"] % nodename[0] + " Please check it.") self.g_opts.nodeName = nodename[0] if "nodeId" in ParaDict.keys(): nodeId = int(ParaDict.get("nodeId")) if nodeId < 1: GaussLog.exitWithError( ErrorCode.GAUSS_500["GAUSS_50004"] % ParaDict.get("nodeId") + " Please check it.") self.g_opts.nodeId = nodeId if ("dataDir" in ParaDict.keys()): self.g_opts.dataDir = ParaDict.get("dataDir") def parseAZ(self, ParaDict): """ """ if self.g_opts.action == ACTION_STATUS: if (ParaDict.__contains__("az_name")): azname = ParaDict.get("az_name") self.g_opts.azName = azname def parseTimeOut(self, ParaDict): """ """ if self.g_opts.action == ACTION_START or self.g_opts.action == \ ACTION_STOP or self.g_opts.action == ACTION_RESTART \ or self.g_opts.action == ACTION_STATUS or self.g_opts.action == ACTION_QUERY: if (ParaDict.__contains__("time_out")): self.g_opts.time_out = ParaDict.get("time_out") def parseMode(self, ParaDict): """ """ if (self.g_opts.action == ACTION_STOP): if (ParaDict.__contains__("Mode")): self.g_opts.mode = ParaDict.get("Mode") def parseKerberosMode(self, ParaDict): """ """ if (self.g_opts.action == ACTION_KERBEROS): if ("Mode" in ParaDict): self.g_opts.kerberosMode = ParaDict.get("Mode") def parseStatus(self, ParaDict): """ """ if (self.g_opts.action == ACTION_STATUS): # A status query can specify an out file if (ParaDict.__contains__("outFile")): self.g_opts.outFile = ParaDict.get("outFile") # The status query can display detailed information if (ParaDict.__contains__("show_detail")): self.g_opts.show_detail = ParaDict.get("show_detail") if (ParaDict.__contains__("all")): self.g_opts.showAll = ParaDict.get("all") def parseView(self, ParaDict): """ """ if (self.g_opts.action == ACTION_VIEW): # A view can specify an out file if ("outFile" in ParaDict.keys()): self.g_opts.outFile = ParaDict.get("outFile") def parseQuery(self, ParaDict): """ """ if (self.g_opts.action == ACTION_QUERY): # A view can specify an out file if ("outFile" in ParaDict.keys()): self.g_opts.outFile = ParaDict.get("outFile") def parseStart(self, ParaDict): """ """ if (self.g_opts.action == ACTION_START) \ or self.g_opts.action == ACTION_RESTART: # The start query can specify az name if ParaDict.__contains__("az_name"): self.g_opts.azName = ParaDict.get("az_name") if ParaDict.__contains__("security_mode"): self.g_opts.security_mode = ParaDict.get("security_mode") if ParaDict.__contains__("cluster_number"): self.g_opts.cluster_number = ParaDict.get("cluster_number") def parseStop(self, ParaDict): """ """ if (self.g_opts.action == ACTION_STOP) \ or self.g_opts.action == ACTION_RESTART: # The start query can specify az name for OLAP if (ParaDict.__contains__("az_name")): self.g_opts.azName = ParaDict.get("az_name") def parseConFile(self, ParaDict): """ """ if (self.g_opts.action == ACTION_REBUID): # Changeip, managecn, and generateconf require the -X parameter if (ParaDict.__contains__("confFile")): self.g_opts.confFile = ParaDict.get("confFile") if ParaDict.__contains__("old_values"): self.g_opts.old_values = ParaDict.get("old_values") if ParaDict.__contains__("new_values"): self.g_opts.new_values = ParaDict.get("new_values") def parseGenerateconf(self, ParaDict): """ """ if (self.g_opts.action == ACTION_REBUID): # Generateconf can specify the distribution file if (ParaDict.__contains__("distribute")): self.g_opts.distribute = ParaDict.get("distribute") def parseCert(self, ParaDict): """ """ if (self.g_opts.action == ACTION_CERT): # cert can change cert file if (ParaDict.__contains__("cert-file")): self.g_opts.certFile = ParaDict.get("cert-file") if (ParaDict.__contains__("rollback")): self.g_opts.certRollback = ParaDict.get("rollback") if (ParaDict.__contains__("localMode")): self.g_opts.localMode = ParaDict.get("localMode") if (ParaDict.__contains__("cert-file") and ParaDict.__contains__( "rollback")): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50005"] % ("-cert-file", "-rollback")) def parseKerberos(self, ParaDict): """ """ if self.g_opts.action == ACTION_KERBEROS: if "user" in ParaDict: self.g_opts.clusterUser = ParaDict.get("user") if self.g_opts.kerberosMode == "install": if "krb-server" in ParaDict and "krb-client" in ParaDict: GaussLog.exitWithError( ErrorCode.GAUSS_500["GAUSS_50005"] % ("-krb-server", "-krb-client")) if (("krb-server" not in ParaDict) and ( "krb-client" not in ParaDict)): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % "-krb-server' or '--krb-client") if "krb-server" in ParaDict: self.g_opts.kerberosType = "krb-server" if "krb-client" in ParaDict: self.g_opts.kerberosType = "krb-client" if self.g_opts.kerberosMode == "uninstall": if "krb-server" in ParaDict: GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50002"] % "-krb-server") if "krb-client" in ParaDict: GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50002"] % "-krb-client") def parseLog(self, ParaDict): """ """ if (ParaDict.__contains__("logFile")): self.g_opts.logFile = ParaDict.get("logFile") def parseCommandLine(self): """ function:Parse command line and save to global variable input:NA output:NA """ # Parse command line ParaObj = Parameter() ParaDict = ParaObj.ParameterCommandLine("gs_om") # If help is included in the parameter, # the help message is printed and exited if (ParaDict.__contains__("helpFlag")): self.usage() sys.exit(0) # The -t parameter is required self.checkAction(ParaDict) # Starting a cluster, stopping a cluster, querying a state, # and switching between active and standby devices require obtaining # node information self.parseNode(ParaDict) # Starting a Cluster and Stopping a Cluster # can specify a timeout period self.parseTimeOut(ParaDict) # Stop the cluster and managecn to specify the mode self.parseMode(ParaDict) # Kerberos to specify the mode self.parseKerberosMode(ParaDict) # Parse start parameter self.parseStart(ParaDict) # Parse stop parameter self.parseStop(ParaDict) # Parse status parameter self.parseStatus(ParaDict) # Parse view parameter self.parseView(ParaDict) # Parse query parameter self.parseQuery(ParaDict) # Parse -X parameter self.parseConFile(ParaDict) # Parse generateconf parameter self.parseGenerateconf(ParaDict) # Parse cert parameter self.parseCert(ParaDict) # Parse kerberos parameter self.parseKerberos(ParaDict) # Parse log parameter self.parseLog(ParaDict) # Parse Az info self.parseAZ(ParaDict) ########################################################################### # Check parameters for all operations ########################################################################### def checkParameter(self): """ function:Check parameter from command line input:NA output:NA """ if (os.getuid() == 0): GaussLog.exitWithError(ErrorCode.GAUSS_501["GAUSS_50105"] + \ " When the parameter '-t' value is not " "dailyAlarm or not estimate install " "consume or not extension connector with " "add, delete, restart, upgrade in -m " "parameter.") if (self.g_opts.action == ACTION_START): self.checkStartParameter() elif (self.g_opts.action == ACTION_STOP): self.checkStopParameter() elif (self.g_opts.action == ACTION_RESTART): self.checkRestartParameter() elif (self.g_opts.action == ACTION_STATUS): self.checkOutFileParameter() self.checkTimeOutParam() elif (self.g_opts.action == ACTION_REBUID): self.checkGenerateConfParameter() elif (self.g_opts.action == ACTION_CERT): self.checkCertParameter() elif (self.g_opts.action == ACTION_KERBEROS): self.checkKerberosParameter() elif (self.g_opts.action == ACTION_VIEW): self.checkOutFileParameter() elif (self.g_opts.action == ACTION_QUERY): self.checkOutFileParameter() self.checkTimeOutParam() elif (self.g_opts.action == ACTION_REFRESHCONF): pass else: GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50004"] % "t") # check mpprc file path self.g_opts.mpprcFile = EnvUtil.getMpprcFile() # check if user exist and is the right user if (self.g_opts.user == ""): self.g_opts.user = pwd.getpwuid(os.getuid()).pw_name if (self.g_opts.user == ""): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % "U" + ".") # Check user on installed cluster ClusterUser.checkUser(self.g_opts.user) # Check whether the current user is consistent with -U if no root if (os.getuid() != 0): cmd = "id -un" (status, output) = subprocess.getstatusoutput(cmd) if (output != self.g_opts.user): GaussLog.exitWithError( ErrorCode.GAUSS_530["GAUSS_53033"] % self.g_opts.user) self.OM_PARAMETER_DIR = "%s/om_parameter_dir" % \ EnvUtil.getTmpDirFromEnv(self.g_opts.user) # check log file if (self.g_opts.logFile == ""): self.g_opts.logFile = ClusterLog.getOMLogPath( ClusterConstants.OM_LOG_FILE, self.g_opts.user, "", action=self.g_opts.action) if (not os.path.isabs(self.g_opts.logFile)): GaussLog.exitWithError(ErrorCode.GAUSS_502["GAUSS_50213"] % "log") def checkStartParameter(self): """ Check parameter for start the cluster and node input : NA output: NA """ # if the parameter -I is exits, then the -h parameter is required. if (self.g_opts.instanceName and (not self.g_opts.nodeName)): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % "h") # check timeout self.checkTimeOutParam() if self.g_opts.security_mode != "off" and self.g_opts.security_mode \ != "on": GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50004"] % "-security-mode") def checkTimeOutParam(self): # If the cluster does not specify a time-out period, the default is # 300 seconds if (self.g_opts.time_out is None): self.g_opts.time_out = DefaultValue.TIMEOUT_CLUSTER_START else: # The timeout parameter must be a pure number if (not str(self.g_opts.time_out).isdigit()): GaussLog.exitWithError( ErrorCode.GAUSS_500["GAUSS_50003"] % ("-time-out", "a nonnegative integer")) self.g_opts.time_out = int(self.g_opts.time_out) # The timeout parameter must be greater than 0 # The timeout parameter must be less than the integer maximum if (self.g_opts.time_out <= 0 or self.g_opts.time_out >= 2147483647): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50004"] % "-time-out") def checkStopParameter(self): """ Check parameter for stop cluster and node input : NA output: NA """ # if the parameter -I is exits, then the -h parameter is required. if (self.g_opts.instanceName and (not self.g_opts.nodeName)): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % "h") # If no stop type is specified, the default is fast # check timeout self.checkTimeOutParam() if (self.g_opts.mode == ""): self.g_opts.mode = STOP_MODE_FAST # Specifies that the stop type must be f, i or s if (self.g_opts.mode not in [STOP_MODE_FAST, STOP_MODE_IMMEDIATE, "f", "i"]): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50004"] % "m") def checkRestartParameter(self): """ Check parameter for restart cluster and node. Restart parameters are same with start and stop. input : NA output: NA """ self.checkStartParameter() if (self.g_opts.mode == ""): self.g_opts.mode = STOP_MODE_FAST # Specifies that the stop type must be f, i or s if (self.g_opts.mode not in [STOP_MODE_FAST, STOP_MODE_IMMEDIATE, "f", "i"]): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50004"] % "m") def checkOutFileParameter(self): """ Check parameter for status input : NA output: NA """ # Check the status query for the specified output file if (self.g_opts.outFile != ''): DefaultValue.checkOutputFile(self.g_opts.outFile) def checkGenerateConfParameter(self): """ Check parameter for generate config input : NA output: NA """ if self.g_opts.old_values.__len__() == 0: # check xml file if self.g_opts.confFile == "": GaussLog.exitWithError( ErrorCode.GAUSS_500["GAUSS_50001"] % 'X' + ".") if not os.path.isfile(self.g_opts.confFile): GaussLog.exitWithError( ErrorCode.GAUSS_502["GAUSS_50210"] % self.g_opts.confFile) else: if self.g_opts.old_values.__len__() != self.g_opts.new_values.__len__(): GaussLog.exitWithError( ErrorCode.GAUSS_512["GAUSS_51230"] % ("old-values", "equal to new-values")) def checkCertParameter(self): """ Check parameter for cert input : NA output: NA """ # add cert must specify the --cert-file parameter if (self.g_opts.certFile == "" and not self.g_opts.certRollback): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % '-cert-file or --rollback') # certFile must be exist if (self.g_opts.certFile != "" and self.g_opts.certFile[-4:] != ".zip"): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % "-cert-file type is not 'zip'") if (not os.path.isfile(self.g_opts.certFile) and not self.g_opts.certRollback): GaussLog.exitWithError(ErrorCode.GAUSS_502["GAUSS_50210"] % self.g_opts.certFile) def checkKerberosParameter(self): """ Check parameter for kerberos input : NA output: NA """ if (self.g_opts.kerberosMode != "install" and self.g_opts.kerberosMode != "uninstall"): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50004"] % 'm' + "Value: %s" % self.g_opts.kerberosMode) # get user info self.user = UserUtil.getUserInfo()['name'] if (self.g_opts.clusterUser == ""): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % 'U') if self.g_opts.clusterUser != self.user: GaussLog.exitWithError(ErrorCode.GAUSS_503["GAUSS_50323"] % self.g_opts.clusterUser) if (self.g_opts.kerberosMode == "install" and self.g_opts.kerberosType == ""): GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % "-krb-server' or '--krb-client") def checkDSN(self, dsnName): """ function: Check the path: the path must be composed of letters, numbers, underscores, slashes, hyphen, and spaces input : path_type_in output: NA """ nameLen = len(dsnName) if (nameLen > 64): GaussLog.exitWithError(ErrorCode.GAUSS_502["GAUSS_50219"] % dsnName + "Error:\nThe DSN name is too long.") wrongChar = None i = 0 a_ascii = ord('a') z_ascii = ord('z') A_ascii = ord('A') Z_ascii = ord('Z') num0_ascii = ord('0') num9_ascii = ord('9') sep_ascii = ord('_') for i in range(0, nameLen): char_check = ord(dsnName[i]) if (not (a_ascii <= char_check <= z_ascii or A_ascii <= char_check <= Z_ascii or num0_ascii <= char_check <= num9_ascii or char_check == sep_ascii)): wrongChar = dsnName[i] break if (wrongChar != None): return wrongChar else: return True def main(): """ main function """ try: # Objectize class manager = OperationManager() # parse cmd lines manager.parseCommandLine() # check parameters manager.checkParameter() # init global variables manager.initGlobal() # set action flag file DefaultValue.setActionFlagFile(manager.g_opts.action) except Exception as e: GaussLog.exitWithError(str(e)) try: impl = OmImplOLAP(manager) if (manager.g_opts.action not in [ACTION_START, ACTION_STOP, ACTION_RESTART, ACTION_STATUS, ACTION_REBUID, ACTION_CERT, ACTION_KERBEROS, ACTION_VIEW, ACTION_QUERY, ACTION_REFRESHCONF ]): raise Exception(ErrorCode.GAUSS_531['GAUSS_53104'] % ("gs_om -t " + manager.g_opts.action)) elif (manager.g_opts.action == ACTION_CERT and manager.g_opts.certRollback): impl.doDNSSLCertRollback() # Depending on the function, different operations are performed if (manager.g_opts.action == ACTION_START): impl.doStart() elif (manager.g_opts.action == ACTION_STOP): impl.doStop() elif (manager.g_opts.action == ACTION_RESTART): impl.doStop(), impl.doStart() elif (manager.g_opts.action == ACTION_STATUS): impl.doStatus() elif (manager.g_opts.action == ACTION_REBUID): impl.doRebuildConf() elif (manager.g_opts.action == ACTION_KERBEROS): if DefaultValue.isUnderUpgrade(manager.user): raise Exception(ErrorCode.GAUSS_529["GAUSS_52936"]) impl.doKerberos() elif (manager.g_opts.action == ACTION_CERT and not manager.g_opts.certRollback): impl.doReplaceSSLCert() elif (manager.g_opts.action == ACTION_VIEW): impl.doView() elif (manager.g_opts.action == ACTION_QUERY): impl.doQuery() elif (manager.g_opts.action == ACTION_REFRESHCONF): impl.doRefreshConf() manager.logger.closeLog() except Exception as e: manager.logger.logExit(str(e)) finally: DefaultValue.setActionFlagFile("gs_om", False) if __name__ == '__main__': main()