#!/usr/bin/env python3
#
# Copyright (c) Greenplum Inc 2010. All Rights Reserved. 
#
#
# THIS IMPORT MUST COME FIRST
# import mainUtils FIRST to get python version check
#
from gppylib.mainUtils import *
import os, sys

import json
import re

from optparse import Option, OptionGroup, OptionParser, OptionValueError

from gppylib.gpparseopts import OptParser, OptChecker
from gppylib import gplog, gparray, pgconf
from gppylib.commands import base, gp, pg, unix
from gppylib.db import dbconn

logger = gplog.get_default_logger()

# Return codes for PQping(), exported by libpq and returned from pg_isready.
PQPING_OK = 0
PQPING_REJECT = 1
PQPING_NO_RESPONSE = 2
PQPING_NO_ATTEMPT = 3
PQPING_MIRROR_READY = 64

# When attempting to connect to a mirror, the postmaster will report the
# software version after a short prefix. This is that prefix, which must match
# that in <postmaster/postmaster.h>.
POSTMASTER_MIRROR_VERSION_DETAIL_MSG = "- VERSION:"

def _get_segment_status(segment):
    cmd = base.Command('pg_isready for segment',
                       "PGOPTIONS=\"-c gp_role=utility\" pg_isready -q -h %s -p %d -d %s" % (segment.hostname, segment.port, gp.PGDATABASE_FOR_COMMON_USE))
    cmd.run()

    rc = cmd.get_return_code()

    if rc == PQPING_OK:
        if segment.role == gparray.ROLE_PRIMARY:
            return 'Up'
        elif segment.role == gparray.ROLE_MIRROR:
            return 'Acting as Primary'
    elif rc == PQPING_REJECT:
        return 'Rejecting Connections'
    elif rc == PQPING_NO_RESPONSE:
        return 'Down'
    elif rc == PQPING_MIRROR_READY:
        if segment.role == gparray.ROLE_PRIMARY:
            return 'Acting as Mirror'
        elif segment.role == gparray.ROLE_MIRROR:
            return 'Up'

    return None

# Used by _get_segment_version() to find the version string for a mirror.
_version_regex = re.compile(r'%s (.*)' % POSTMASTER_MIRROR_VERSION_DETAIL_MSG)

def _get_segment_version(seg):
    try:
        if seg.role == gparray.ROLE_PRIMARY:
            dburl = dbconn.DbURL(hostname=seg.hostname, port=seg.port, dbname="template1")
            conn = dbconn.connect(dburl, utility=True)
            return dbconn.querySingleton(conn, "select version()")

        if seg.role == gparray.ROLE_MIRROR:
            cmd = base.Command("Try connecting to mirror",
                               "psql -h %s -p %s template1 -c 'select 1'"
                               %(seg.hostname, seg.port))
            cmd.run(validateAfter=False)
            if cmd.results.rc == 0:
                raise RuntimeError("Connection to mirror succeeded unexpectedly")

            stderr = cmd.results.stderr.splitlines()
            for line in stderr:
                match = _version_regex.match(line)
                if match:
                    return match.group(1)

            raise RuntimeError("Unexpected error from mirror connection: %s" % cmd.results.stderr)

        logger.error("Invalid role '%s' for dbid %d", seg.role, seg.dbid)
        return None

    except Exception as ex:
        logger.error("Could not get segment version for dbid %d", seg.dbid, exc_info=ex)
        return None

#
# todo: the file containing this should be renamed since it gets more status than just from transition
#
class GpSegStatusProgram:
    """

    Program to fetch status from the a segment(s).

    Multiple pieces of status information can be fetched in a single request by
         passing in multiple status request options on the command line

    """

    def __init__(self, options):
        self.__options = options
        self.__pool = None

    def getPidStatus(self, seg, pidRunningStatus):
        """
        returns a dict containing "pid" and "error" fields.  Note that
           the "error" field may be non-None even when pid is non-zero (pid if zero indicates
           unable to determine the pid).  This can happen if the pid is there in the
           lock file but not active on the port.

        The caller can rely on this to try to differentiate between an active pid and an inactive one

        """

        lockFileExists = pidRunningStatus['lockFileExists']
        ssPortActive = pidRunningStatus['ssPortActive']
        pidValue = pidRunningStatus['pidValue']

        lockFileName = gp.get_lockfile_name(seg.getSegmentPort())

        error = None
        if not lockFileExists and not ssPortActive:
            error = "No socket connection or lock file (%s) found for port %s" % (lockFileName, seg.getSegmentPort())
        elif not lockFileExists and ssPortActive:
            error = "No lock file %s but process running on port %s" % (lockFileName, seg.getSegmentPort())
        elif lockFileExists and not ssPortActive:
            error = "Have lock file %s but no process running on port %s" % (lockFileName, seg.getSegmentPort())
        else:
            if pidValue == 0:
                error = "Have lock file and process is active, but did not get a pid value" # this could be an assert?

        res = {}
        res['pid'] = pidValue
        res['error'] = error
        return res


    def getPidRunningStatus(self, seg):
        """
        Get an object containing various information about the postmaster pid's status
        """
        (postmasterPidFileExists, tempFileExists, lockFileExists, ssPortActive, pidValue) = \
                    gp.chk_local_db_running(seg.getSegmentDataDirectory(), seg.getSegmentPort())

        return {
            'postmasterPidFileExists' : postmasterPidFileExists,
            'tempFileExists' : tempFileExists,
            'lockFileExists' : lockFileExists,
            'ssPortActive' : ssPortActive,
            'pidValue' : pidValue
        }

    def run(self):

        if self.__options.statusQueryRequests is None:
            raise ProgramArgumentValidationException("-s argument not specified")
        if self.__options.dirList is None:
            raise ProgramArgumentValidationException("-D argument not specified")

        toFetch = self.__options.statusQueryRequests.split(":")
        segments = list(map(gparray.Segment.initFromString, self.__options.dirList))

        output = {}
        for seg in segments:
            pidRunningStatus = self.getPidRunningStatus(seg)

            outputThisSeg = output[seg.getSegmentDbId()] = {}
            for statusRequest in toFetch:
                data = None
                if statusRequest == gp.SEGMENT_STATUS__GET_VERSION:
                    data = _get_segment_version(seg)

                elif statusRequest == gp.SEGMENT_STATUS__GET_MIRROR_STATUS:
                    data = _get_segment_status(seg)
                    if data is not None:
                        data = {'databaseStatus': data}

                elif statusRequest == gp.SEGMENT_STATUS__GET_PID:
                    data = self.getPidStatus(seg, pidRunningStatus)
                
                elif statusRequest == gp.SEGMENT_STATUS__HAS_POSTMASTER_PID_FILE:
                    data = pidRunningStatus['postmasterPidFileExists']
                
                elif statusRequest == gp.SEGMENT_STATUS__HAS_LOCKFILE:
                    data = pidRunningStatus['lockFileExists']
                    
                else:
                    raise Exception("Invalid status request %s" % statusRequest )
                    
                outputThisSeg[statusRequest] = data

        status = '\nSTATUS_RESULTS:' + json.dumps(output)
        logger.info(status)

    def cleanup(self):
        if self.__pool:
            self.__pool.haltWork()

    @staticmethod
    def createParser():
        parser = OptParser(option_class=OptChecker,
                           description="Gets status from segments on a single host "
                                            "using a transition message.  Internal-use only.",
                           version='%prog version $Revision: #1 $')
        parser.setHelp([])

        addStandardLoggingAndHelpOptions(parser, True)

        addTo = parser
        addTo.add_option("-s", None, type="string",
                         dest="statusQueryRequests",
                         metavar="<statusQueryRequests>",
                         help="Status Query Message")
        addTo.add_option("-D", "--dblist", type="string", action="append",
                         dest="dirList",
                         metavar="<dirList>",
                         help="Directory List")

        parser.set_defaults()
        return parser

    @staticmethod
    def createProgram(options, args):
        if len(args) > 0 :
            raise ProgramArgumentValidationException(\
                            "too many arguments: only options may be specified", True)
        return GpSegStatusProgram(options)

#-------------------------------------------------------------------------
if __name__ == '__main__':
    mainOptions = { 'setNonuserOnToolLogger':True}
    simple_main( GpSegStatusProgram.createParser, GpSegStatusProgram.createProgram, mainOptions)