# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
# 
#   http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

from OvmCommonModule import *
from OVSSiteRMServer import get_master_ip, register_server
from OVSCommons import *
from OVSXMonitor import xen_get_xm_info
from OVSXSysInfo import get_agent_version
from OVSSiteRMServer import get_srv_agent_status
from OVSXMonitor import sys_perf_info
from OVSDB import db_get_vm
from OvmStoragePoolModule import OvmStoragePool
from OvmHaHeartBeatModule import OvmHaHeartBeat
import re

logger = OvmLogger('OvmHost')

class OvmHostEncoder(json.JSONEncoder):
    def default(self, obj):
        if not isinstance(obj, OvmHost): raise Exception("%s is not instance of OvmHost"%type(obj))
        dct = {}
        safeDictSet(obj, dct, 'masterIp')
        safeDictSet(obj, dct, 'cpuNum')
        safeDictSet(obj, dct, 'cpuSpeed')
        safeDictSet(obj, dct, 'totalMemory')
        safeDictSet(obj, dct, 'freeMemory')
        safeDictSet(obj, dct, 'dom0Memory')
        safeDictSet(obj, dct, 'agentVersion')
        safeDictSet(obj, dct, 'name')
        safeDictSet(obj, dct, 'dom0KernelVersion')
        safeDictSet(obj, dct, 'hypervisorVersion')
        return dct
        

def fromOvmHost(host):
    return normalizeToGson(json.dumps(host, cls=OvmHostEncoder))
    
class OvmHost(OvmObject):
    masterIp = ''
    cpuNum = 0
    cpuSpeed = 0
    totalMemory = 0
    freeMemory = 0
    dom0Memory = 0
    agentVersion = ''
    name = ''
    dom0KernelVersion = ''
    hypervisorVersion = ''

    def _getVmPathFromPrimaryStorage(self, vmName):
        '''
        we don't have a database to store vm states, so there is no way to retrieve information of a vm
        when it was already stopped. The trick is to try to find the vm path in primary storage then we 
        can read information from its configure file.
        '''
        mps = OvmStoragePool()._getAllMountPoints()
        vmPath = None
        for p in mps:
            vmPath = join(p, 'running_pool', vmName)
            if exists(vmPath): break
        if not vmPath:
            logger.error(self._getVmPathFromPrimaryStorage, "Cannot find link for %s in any primary storage, the vm was really gone!"%vmName)
            raise Exception("Cannot find link for %s in any primary storage, the vm was really gone!"%vmName)
        return vmPath
    
    def _vmNameToPath(self, vmName):
        # the xen_get_vm_path always sucks!!!
        #return successToMap((vmName))['path']
        return self._getVmPathFromPrimaryStorage(vmName)
    
    def _getAllDomains(self):
        stdout = timeout_command(["xm", "list"])
        l = [ line.split()[:2] for line in stdout.splitlines() ]
        l = [ (name, id) for (name, id) in l if name not in ("Name", "Domain-0") ]
        return l
    
    def _getDomainIdByName(self, vmName):
        l = self._getAllDomains()
        for name, id in l:
            if vmName == name: return id
        raise NoVmFoundException("No domain id for %s found"%vmName)

    @staticmethod
    def registerAsMaster(hostname, username="oracle", password="password", port=8899, isSsl=False):
        try:
            logger.debug(OvmHost.registerAsMaster, "ip=%s, username=%s, password=%s, port=%s, isSsl=%s"%(hostname, username, password, port, isSsl))
            exceptionIfNoSuccess(register_server(hostname, 'site', False, username, password, port, isSsl),
                             "Register %s as site failed"%hostname)
            exceptionIfNoSuccess(register_server(hostname, 'utility', False, username, password, port, isSsl),
                             "Register %s as utility failed"%hostname)
            rs = SUCC()
            return rs
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmHost.registerAsMaster, errmsg)
            raise XmlRpcFault(toErrCode(OvmHost, OvmHost.registerAsMaster), errmsg)
    
    @staticmethod
    def registerAsVmServer(hostname, username="oracle", password="password", port=8899, isSsl=False):
        try:
            logger.debug(OvmHost.registerAsVmServer, "ip=%s, username=%s, password=%s, port=%s, isSsl=%s"%(hostname, username, password, port, isSsl))
            exceptionIfNoSuccess(register_server(hostname, 'xen', False, username, password, port, isSsl),
                             "Register %s as site failed"%hostname)
            rs = SUCC()
            return rs
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmHost.registerAsVmServer, errmsg)
            raise XmlRpcFault(toErrCode(OvmHost, OvmHost.registerAsVmServer), errmsg)
    
    @staticmethod
    def ping(hostname):
        try:
            logger.debug(OvmHost.ping, "ping %s"%hostname)
            exceptionIfNoSuccess(get_srv_agent_status(hostname), "Ovs agent is down")
            rs = SUCC()
            return rs
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmHost.ping, errmsg)
            raise XmlRpcFault(toErrCode(OvmHost, OvmHost.ping, errmsg))
        
    @staticmethod
    def getDetails():
        try:
            obj = OvmHost()
            masterIp = successToMap(get_master_ip())
            safeSetAttr(obj, 'masterIp', masterIp['ip'])
            xmInfo = successToMap(xen_get_xm_info())
            totalMemory = MtoBytes(long(xmInfo['total_memory']))
            safeSetAttr(obj, 'totalMemory', totalMemory)
            freeMemory = MtoBytes(long(xmInfo['free_memory']))
            safeSetAttr(obj, 'freeMemory', freeMemory)
            dom0Memory = totalMemory - freeMemory
            safeSetAttr(obj, 'dom0Memory', dom0Memory)
            cpuNum = int(xmInfo['nr_cpus'])
            safeSetAttr(obj, 'cpuNum', cpuNum)
            cpuSpeed = int(xmInfo['cpu_mhz'])
            safeSetAttr(obj, 'cpuSpeed', cpuSpeed)
            name = xmInfo['host']
            safeSetAttr(obj, 'name', name)
            dom0KernelVersion = xmInfo['release']
            safeSetAttr(obj, 'dom0KernelVersion', dom0KernelVersion)
            hypervisorVersion = xmInfo['xen_major'] + '.' + xmInfo['xen_minor'] + xmInfo['xen_extra']
            safeSetAttr(obj, 'hypervisorVersion', hypervisorVersion)
            agtVersion = successToMap(get_agent_version())
            safeSetAttr(obj, 'agentVersion', agtVersion['agent_version'])
            res = fromOvmHost(obj)
            logger.debug(OvmHost.getDetails, res)
            return res
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmHost.getDetails, errmsg)
            raise XmlRpcFault(toErrCode(OvmHost, OvmHost.getDetails), errmsg)
    
    @staticmethod
    def getPerformanceStats(bridgeName):
        try:
            rxBytesPath = join("/sys/class/net/", bridgeName, "statistics/rx_bytes")
            txBytesPath = join("/sys/class/net/", bridgeName, "statistics/tx_bytes")
            if not exists(rxBytesPath): raise Exception("Cannot find %s"%rxBytesPath)
            if not exists(txBytesPath): raise Exception("Cannot find %s"%txBytesPath)
            rxBytes = long(doCmd(['cat', rxBytesPath])) / 1000
            txBytes = long(doCmd(['cat', txBytesPath])) / 1000
            sysPerf = successToMap(sys_perf_info())
            cpuUtil = float(100 - float(sysPerf['cpu_idle']) * 100)
            freeMemory = MtoBytes(long(sysPerf['mem_free']))
            xmInfo = successToMap(xen_get_xm_info())
            totalMemory = MtoBytes(long(xmInfo['total_memory']))
            rs = toGson({"cpuUtil":cpuUtil, "totalMemory":totalMemory, "freeMemory":freeMemory, "rxBytes":rxBytes, "txBytes":txBytes})
            logger.info(OvmHost.getPerformanceStats, rs)
            return rs
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmHost.getPerformanceStats, errmsg)
            raise XmlRpcFault(toErrCode(OvmHost, OvmHost.getPerformanceStats), errmsg)
    
    @staticmethod
    def getAllVms():
        def scanStoppedVmOnPrimaryStorage(vms):
            def isMyVmDirLink(path):
                return (islink(path) and exists(join(path, 'vm.cfg')) and ('-' in basename(path)) and (exists(join(path, makeOwnerFileName()))))
                    
            mps = OvmStoragePool()._getAllMountPoints()
            for mountPoint in mps:
                runningPool = join(mountPoint, 'running_pool')
                if not exists(runningPool):
                    logger.debug(OvmHost.getAllVms, "Primary storage %s not existing, skip it. this should be first getAllVms() called from Ovm resource configure"%runningPool)
                    continue
                    
                for dir in os.listdir(runningPool):
                    vmDir = join(runningPool, dir)
                    if not isMyVmDirLink(vmDir):
                        logger.debug(OvmHost.getAllVms, "%s is not our vm directory, skip it"%vmDir)
                        continue
                    if vms.has_key(dir):
                        logger.debug(OvmHost.getAllVms, "%s is already in running list, skip it"%dir)
                        continue
                    
                    logger.debug(OvmHost.getAllVms, "Found a stopped vm %s on primary storage %s, report it to management server" % (dir, mountPoint))
                    vms[dir] = "DOWN"
                    
                    
        try:
            l = OvmHost()._getAllDomains()
            dct = {}
            host = OvmHost()
            for name, id in l:
                try:
                    vmPath = host._getVmPathFromPrimaryStorage(name)
                    vmStatus = db_get_vm(vmPath)
                    dct[name] = vmStatus['status']
                except Exception, e:
                    logger.debug(OvmHost.getAllVms, "Cannot find link for %s on primary storage, treat it as Error"%name)
                    dct[name] = 'ERROR'
                        
            scanStoppedVmOnPrimaryStorage(dct)
            rs = toGson(dct)
            logger.info(OvmHost.getAllVms, rs)
            return rs
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmHost.getAllVms, errmsg)
            raise XmlRpcFault(toErrCode(OvmHost, OvmHost.getAllVms), errmsg)
    
    @staticmethod
    def fence(ip):
        # try 3 times to avoid race condition that read when heartbeat file is being written
        def getTimeStamp(hbFile):
            for i in range(1, 3):
                f = open(hbFile, 'r') 
                str = f.readline()
                items = re.findall(HEARTBEAT_TIMESTAMP_PATTERN, str)
                if len(items) == 0:
                    logger.debug(OvmHost.fence, "Get an incorrect heartbeat data %s, will retry %s times" % (str, 3-i))
                    f.close()
                    time.sleep(5)
                else:
                    f.close()
                    timestamp = items[0]
                    return timestamp.lstrip('<timestamp>').rstrip('</timestamp>')
            
        # totally check in 6 mins, the update frequency is 2 mins
        def check(hbFile):
            for i in range(1, 6):
                ts = getTimeStamp(hbFile)
                time.sleep(60)
                nts = getTimeStamp(hbFile)
                if ts != nts: return True
                else: logger.debug(OvmHost.fence, '%s is not updated, old value=%s, will retry %s times'%(hbFile, ts, 6-i))
            return False
                
        try:
            mountpoints = OvmStoragePool()._getAllMountPoints()
            hbFile = None
            for m in mountpoints:
                p = join(m, HEARTBEAT_DIR, ipToHeartBeatFileName(ip))
                if exists(p):
                    hbFile = p
                    break
                
            if not hbFile: raise Exception('Can not find heartbeat file for %s in pools %s'%(ip, mountpoints))
            rs = toGson({"isLive":check(hbFile)})
            logger.debug(OvmHost.fence, rs)
            return rs
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmHost.fence, errmsg)
            raise XmlRpcFault(toErrCode(OvmHost, OvmHost.fence), errmsg)
    
    @staticmethod
    def setupHeartBeat(poolUuid, ip):
        try:
            sr = OvmStoragePool()._getSrByNameLable(poolUuid)
            OvmHaHeartBeat.start(sr.mountpoint, ip)
            return SUCC()
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmHost.setupHeartBeat, errmsg)
            raise XmlRpcFault(toErrCode(OvmHost, OvmHost.setupHeartBeat), errmsg)
    
    @staticmethod
    def pingAnotherHost(ip):
        try:
            doCmd(['ping', '-c', '1', '-n', '-q', ip])
            return SUCC()
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmHost.pingAnotherHost, errmsg)
            raise XmlRpcFault(toErrCode(OvmHost, OvmHost.pingAnotherHost), errmsg)
        
if __name__ == "__main__":
    print OvmHost.getAllVms()