#!/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  : ConfigInstance.py is a utility to config
# CN/DN/gtm/cm_agent/cm_server instance.
#############################################################################

import getopt
import sys
import os

sys.path.append(sys.path[0] + "/../")
from gspylib.common.GaussLog import GaussLog
from gspylib.common.Common import DefaultValue, ClusterInstanceConfig
from gspylib.common.ParameterParsecheck import Parameter
from gspylib.common.LocalBaseOM import LocalBaseOM
from gspylib.common.ErrorCode import ErrorCode
from gspylib.threads.parallelTool import parallelTool
from domain_utils.cluster_file.cluster_log import ClusterLog
from domain_utils.domain_common.cluster_constants import ClusterConstants
from domain_utils.cluster_os.cluster_user import ClusterUser

#############################################################################
# Global variables
#   INSTANCE_TYPE_UNDEFINED: the signal about instance
#   MASTER_INSTANCE: the signal about instance
#   STANDBY_INSTANCE: the signal about instance
#   DUMMY_STANDBY_INSTANCE: the signal about instance
#############################################################################
INSTANCE_TYPE_UNDEFINED = -1
MASTER_INSTANCE = 0
STANDBY_INSTANCE = 1
DUMMY_STANDBY_INSTANCE = 2
CONFIG_ITEM_TYPE = "ConfigInstance"

CONFIG_PG_FILE = "pg_config"
CONFIG_GS_FILE = "gs_config"
CONFIG_ALL_FILE = "all"
########################################################################
# Global variables define
########################################################################
g_opts = None


########################################################################
class CmdOptions():
    """
    class: cmdOptions
    """

    def __init__(self):
        """
        function: constructor
        """
        self.clusterUser = ""
        self.dataGucParams = []
        self.cmsGucParams = []
        self.configType = CONFIG_ALL_FILE
        self.clusterStaticConfigFile = ""
        self.logFile = ""
        self.alarmComponent = ""
        self.gucXml = False
        self.vcMode = False
        self.dws_mode = False
        self.clusterConf = ""


def usage():
    """
Usage:
    python3 -h | -help
    python3 ConfigInstance.py -U user
        [-T config_type]
        [-P cluster_static_config]
        [-C "PARAMETER=VALUE" [...]]
        [-D "PARAMETER=VALUE" [...]]
        [-L log]
        target file: pg_config, gs_config, all
    """
    print(usage.__doc__)


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:S: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 == "-S":
            g_opts.cmsGucParams.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 checkParameter():
    """
    function: checkParameter
    input: NA
    output: NA
    """
    # check if user exist and is the right user
    if (g_opts.clusterUser == ""):
        GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50001"] % 'U' + ".")
    ClusterUser.checkUser(g_opts.clusterUser)

    if (g_opts.configType not in [CONFIG_ALL_FILE,
                                  CONFIG_GS_FILE, CONFIG_PG_FILE]):
        GaussLog.exitWithError(ErrorCode.GAUSS_500["GAUSS_50004"]
                               % 'T' + " Value: %s." % g_opts.configType)

    if (g_opts.logFile == ""):
        g_opts.logFile = ClusterLog.getOMLogPath(
            ClusterConstants.LOCAL_LOG_FILE, g_opts.clusterUser, "")

    if (g_opts.alarmComponent == ""):
        g_opts.alarmComponent = DefaultValue.ALARM_COMPONENT_PATH


def getAlarmDict(configItemType=None, alarmComponent=None):
    """
    function: Get Alarm configuration for om_monitor
    input : configItemType, alarmComponent
    output: NA
    """
    tmpAlarmDict = {}
    if (configItemType == "ConfigInstance"):
        tmpAlarmDict["alarm_component"] = "%s" % alarmComponent
    return tmpAlarmDict


class ConfigInstance(LocalBaseOM):
    """
    Class: ConfigInstance
    """

    def __init__(self, logFile, user, clusterConf, dwsMode=False,
                 dataParams=None, confType="",
                 clusterStaticConfigFile="", alarmComponent="", cmsParams=None):
        """
        function: configure all instance on local node
        """
        if dataParams is None:
            dataParams = []
        if cmsParams is None:
            cmsParams = []
        LocalBaseOM.__init__(self, logFile, user, clusterConf, dwsMode)
        if (self.clusterConfig == ""):
            # Read config from static config file
            self.readConfigInfo()
        else:
            self.readConfigInfoByXML()
        # get user info
        self.getUserInfo()
        if (user != "" and self.user != user.strip()):
            self.logger.debug("User parameter : %s." % user)
            self.logger.logExit(ErrorCode.GAUSS_503["GAUSS_50315"]
                                % (self.user, self.clusterInfo.appPath))
        # get log file info
        # init every component
        self.initComponent()

        self.dataGucParams = dataParams
        self.cmsGucParams = cmsParams
        self.configType = confType
        self.clusterStaticConfigFile = clusterStaticConfigFile
        self.alarmComponent = alarmComponent
        self.__dataConfig = {}
        self.__cmsConfig = {}

    def __checkconfigParams(self, param, instance_type):
        """
        function:
            Check parameter for postgresql.conf
            port : this is calculated automatically
        input : param
        output: int
        """
        configInvalidArgs = ["port", "alarm_component"]
        # get key name and key value
        # split by '='
        keyValue = param.split("=")
        if (len(keyValue) != 2):
            return 1
        # the type like this: "key = value"
        key = keyValue[0].strip()
        value = keyValue[1].strip()
        if key in configInvalidArgs:
            return 1
        if instance_type == "dn":
            self.__dataConfig[key] = value
        else:
            self.__cmsConfig[key] = value
        return 0

    def __checkGUCInstParameters(self):
        """
        function: Check parameters for instance configuration
        input : NA
        output: NA
        """
        # Checking parameters for configuration CN and DN.
        self.logger.log("Checking parameters for configuration database node.")

        for param in self.dataGucParams:
            if self.__checkconfigParams(param.strip(), "dn") != 0:
                self.logger.logExit(ErrorCode.GAUSS_500["GAUSS_50000"]
                                    % param)
        for param in self.cmsGucParams:
            if self.__checkconfigParams(param.strip(), "cms") != 0:
                self.logger.logExit(ErrorCode.GAUSS_500["GAUSS_50000"] % param)

    def __modifyConfig(self):
        """
        function: Modify all instances on loacl node
        input : NA
        output: NA
        """
        self.logger.log("Modifying Alarm configuration.")
        tmpAlarmDict = getAlarmDict(self.configType, self.alarmComponent)
        # init alarmItem.conf file
        configFile = "%s/bin/alarmItem.conf" % self.clusterInfo.appPath
        ClusterInstanceConfig.setConfigItem(
            DefaultValue.INSTANCE_ROLE_CMAGENT, "", configFile, tmpAlarmDict)
        componentList = self.dnCons + self.cmCons
        if len(componentList) == 0:
            return
        try:
            # config instance in paralle
            parallelTool.parallelExecute(self.configInst, componentList)
        except Exception as e:
            self.logger.logExit(str(e))

    def configInst(self, dbCon):
        """
        function: Config the instance
        input : dbCon
        output: NA
        """
        if dbCon.instInfo.instanceRole == DefaultValue.INSTANCE_ROLE_DATANODE:
            # modifying database node configuration.
            self.logger.log("Modifying database node configuration.")
            peerInsts = self.clusterInfo.getPeerInstance(dbCon.instInfo)
            azNames = self.clusterInfo.getazNames()
            allConfig = {}
            allConfig.update(self.__dataConfig)
            dbCon.configInstance(self.user, allConfig,
                                 peerInsts, CONFIG_ITEM_TYPE,
                                 self.alarmComponent, azNames,
                                 g_opts.gucXml)

        if dbCon.instInfo.instanceRole == DefaultValue.INSTANCE_ROLE_CMSERVER:
            # modifying CMServer configuration.
            if len(self.cmsGucParams) != 0:
                self.logger.log("Modifying CMServer configuration.")
                dbCon.configInstance(self.user, CONFIG_ITEM_TYPE,
                                     self.alarmComponent, self.__cmsConfig)
            else:
                self.logger.log("No need to modify CMServer configuration.")

        if dbCon.instInfo.instanceRole == DefaultValue.INSTANCE_ROLE_CMAGENT:
            # modifying CMAgent configuration.
            if len(self.cmsGucParams) != 0:
                self.logger.log("Modifying CMAgent configuration.")
                tmp_config = {}
                temp_cma_config = {}
                tmp_config.update(self.__cmsConfig)
                if 'enable_dcf' in tmp_config:
                    temp_cma_config['enable_dcf'] = tmp_config['enable_dcf']
                dbCon.configInstance(self.user, CONFIG_ITEM_TYPE,
                                     self.alarmComponent, temp_cma_config)
            else:
                self.logger.log("No need to modify CMAgent configuration.")

    def modifyInstance(self):
        """
        Class: modifyInstance
        """
        self.__checkGUCInstParameters()
        # modify all instances on loacl node
        if self.configType in [CONFIG_PG_FILE, CONFIG_ALL_FILE]:
            self.__modifyConfig()


if __name__ == '__main__':
    ##########################################################################
    # config instance
    ##########################################################################
    """
    function: config instance
              1.check dbInitParams
              2.modify instance 
              3.genarate cert files
    input : NA
    output: NA
    """
    try:
        # parse and check input parameters
        parseCommandLine()
        checkParameter()

        # modify Instance
        configer = ConfigInstance(g_opts.logFile, g_opts.clusterUser,
                                  g_opts.clusterConf,
                                  False,
                                  g_opts.dataGucParams, g_opts.configType,
                                  g_opts.clusterStaticConfigFile,
                                  g_opts.alarmComponent, g_opts.cmsGucParams)
        configer.modifyInstance()
    except Exception as e:
        GaussLog.exitWithError(str(e))

    sys.exit(0)