# 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 OVSSiteSR import sp_create, sr_create, sr_do
from OVSParser import parse_ocfs2_cluster_conf
from OVSXCluster import clusterm_set_ocfs2_cluster_conf, clusterm_start_o2cb_service
from OVSSiteRMServer import get_master_ip
from OvmOCFS2Module import OvmOCFS2
import re

class OvmStoragePoolDecoder(json.JSONDecoder):
    def decode(self, jStr):
        dct = asciiLoads(jStr)
        pool = OvmStoragePool()
        setAttrFromDict(pool, 'uuid', dct)
        setAttrFromDict(pool, 'type', dct)
        setAttrFromDict(pool, 'path', dct)
        return pool

class OvmStoragePoolEncoder(json.JSONEncoder):
    def default(self, obj):
        if not isinstance(obj, OvmStoragePool): raise Exception("%s is not instance of OvmStoragePool"%type(obj))
        dct = {}
        safeDictSet(obj, dct, 'uuid')
        safeDictSet(obj, dct, 'type')
        safeDictSet(obj, dct, 'path')
        safeDictSet(obj, dct, 'mountPoint')
        safeDictSet(obj, dct, 'totalSpace')
        safeDictSet(obj, dct, 'freeSpace')
        safeDictSet(obj, dct, 'usedSpace')
        return dct

def fromOvmStoragePool(pool):
    return normalizeToGson(json.dumps(pool, cls=OvmStoragePoolEncoder))

def toOvmStoragePool(jStr):
    return json.loads(jStr, cls=OvmStoragePoolDecoder)

logger = OvmLogger('OvmStoragePool')   
class OvmStoragePool(OvmObject):
    uuid = ''
    type = ''
    path = ''
    mountPoint = ''
    totalSpace = 0
    freeSpace = 0
    usedSpace = 0

    def _getSrByNameLable(self, poolUuid):
        d = db_dump('sr')
        for uuid, sr in d.items():
            if sr.name_label == poolUuid:
                return sr
    
        raise Exception("No SR matching to %s" % poolUuid)
    
    def _getSpaceinfoOfDir(self, dir):
        stat = os.statvfs(dir)
        freeSpace = stat.f_frsize * stat.f_bavail;
        totalSpace = stat.f_blocks * stat.f_frsize;
        return (totalSpace, freeSpace)
    
    def _checkDirSizeForImage(self, dir, image):
        (x, free_storage_size) = OvmStoragePool()._getSpaceinfoOfDir(dir)
        image_size = os.path.getsize(image)
        if image_size > (free_storage_size + 1024 * 1024 * 1024):
            raise Exception("No space on dir %s (free storage:%s, vm size:%s)"%(dir, free_storage_size, image_size))
         
    def _getAllMountPoints(self):
        mps = []
        d = db_dump('sr')
        for uuid, sr in d.items():
            mps.append(sr.mountpoint)
        return mps
    
    def _isMounted(self, path):
        res = doCmd(['mount'])
        return (path in res)
    
    def _mount(self, target, mountpoint, readonly=False):
        if not exists(mountpoint):
            os.makedirs(mountpoint)
            
        if not OvmStoragePool()._isMounted(mountpoint):
            if readonly:
                doCmd(['mount', target, mountpoint, '-r'])
            else:
                doCmd(['mount', target, mountpoint])
    
    def _umount(self, mountpoint):
        umountCmd = ['umount', '-f', mountpoint]
        doCmd(umountCmd)
        ls = os.listdir(mountpoint)
        if len(ls) == 0:
            rmDirCmd = ['rm', '-r', mountpoint]
            doCmd(rmDirCmd)
        else:
            logger.warning(OvmStoragePool._umount, "Something wrong when umount %s, there are still files in directory:%s", mountpoint, " ".join(ls))
         
    @staticmethod
    def create(jStr):
        try:
            pool = toOvmStoragePool(jStr)
            logger.debug(OvmStoragePool.create, fromOvmStoragePool(pool))
            spUuid = jsonSuccessToMap(sp_create(pool.type, pool.path))['uuid']
            srUuid = jsonSuccessToMap(sr_create(spUuid, name_label=pool.uuid))['uuid']
            sr_do(srUuid, "initialize")
            rs = SUCC()
            return rs
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmStoragePool.create, errmsg)
            raise XmlRpcFault(toErrCode(OvmStoragePool, OvmStoragePool.create), errmsg)
    
    @staticmethod
    def getDetailsByUuid(uuid):
        try:
            sr = OvmStoragePool()._getSrByNameLable(uuid)
            pool = OvmStoragePool()
            safeSetAttr(pool, 'uuid', uuid)
            #Note: the sr.sp.fs_type is not mapped to its class name which we use in mgmt server
            safeSetAttr(pool, 'type', sr.sp.__class__.__name__)
            safeSetAttr(pool, 'path', sr.sp.get_fs_spec())
            safeSetAttr(pool, 'mountPoint', sr.mountpoint)
            (totalSpace, freeSpace) = OvmStoragePool()._getSpaceinfoOfDir(sr.mountpoint)
            safeSetAttr(pool, 'totalSpace', totalSpace)
            safeSetAttr(pool, 'freeSpace', freeSpace)
            safeSetAttr(pool, 'usedSpace', totalSpace - freeSpace)
            res = fromOvmStoragePool(pool)
            logger.debug(OvmStoragePool.getDetailsByUuid, res)
            return res
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmStoragePool.getDetailsByUuid, errmsg)
            raise XmlRpcFault(toErrCode(OvmStoragePool, OvmStoragePool.getDetailsByUuid), errmsg)
    
    @staticmethod
    def downloadTemplate(uuid, secPath):
        secMountPoint = None
        try:
            logger.debug(OvmStoragePool.downloadTemplate, "download %s to pool %s"%(secPath, uuid))
            try:
                tmpUuid = get_uuid()
                secMountPoint = join("/var/cloud/", tmpUuid)
                if not exists(secMountPoint):
                    os.makedirs(secMountPoint)
    
                templateFile = None
                if secPath.endswith("raw"):
                    secPathDir = os.path.dirname(secPath)
                    templateFile = os.path.basename(secPath)
                else:
                    secPathDir = secPath
                    
                # mount as read-only
                mountCmd = ['mount.nfs', secPathDir, secMountPoint, '-r']
                doCmd(mountCmd)
    
                if not templateFile:
                    for f in os.listdir(secMountPoint):
                        if isfile(join(secMountPoint, f)) and f.endswith('raw'):
                            templateFile = f
                            break    
        
                if not templateFile:
                    raise Exception("Can not find raw template in secondary storage")
                templateSecPath = join(secMountPoint, templateFile)
    
                sr = OvmStoragePool()._getSrByNameLable(uuid)
                priStorageMountPoint = sr.mountpoint
                # Although mgmt server will check the size, we check again for safety
                OvmStoragePool()._checkDirSizeForImage(priStorageMountPoint, templateSecPath)
                seedDir = join(priStorageMountPoint, 'seed_pool', tmpUuid)
                if exists(seedDir):
                    raise Exception("%s already here, cannot override existing template" % seedDir)
                os.makedirs(seedDir)
    
                tgt = join(seedDir, templateFile)
                cpTemplateCmd = ['cp', templateSecPath, tgt]
                logger.info(OvmStoragePool.downloadTemplate, " ".join(cpTemplateCmd))
                doCmd(cpTemplateCmd)
                templateSize = os.path.getsize(tgt) 
                logger.info(OvmStoragePool.downloadTemplate, "primary_storage_download success:installPath:%s, templateSize:%s"%(tgt,templateSize))
                rs = toGson({"installPath":tgt, "templateSize":templateSize})
                return rs
            except Exception, e:
                errmsg = fmt_err_msg(e)
                logger.error(OvmStoragePool.downloadTemplate, errmsg)
                raise XmlRpcFault(toErrCode(OvmStoragePool, OvmStoragePool.downloadTemplate), errmsg)
        finally:
            if exists(secMountPoint):
                try:
                    OvmStoragePool()._umount(secMountPoint)
                except Exception, e:
                    errmsg = fmt_err_msg(e)
                    logger.error(OvmStoragePool.downloadTemplate, 'unmount secondary storage at %s failed, %s'%(secMountPoint, errmsg))

    @staticmethod
    def prepareOCFS2Nodes(clusterName, nodeString):        
        def configureEtcHosts(nodes):
            if not exists(ETC_HOSTS):
                orignalConf = ""
            else:
                fd = open(ETC_HOSTS, "r")
                orignalConf = fd.read()
                fd.close()
            
            pattern = r"(.*%s.*)|(.*%s.*)"
            newlines = []
            for n in nodes:
                p = pattern % (n["ip_address"], n["name"])
                orignalConf = re.sub(p, "", orignalConf)
                newlines.append("%s\t%s\n"%(n["ip_address"], n["name"]))
            
            orignalConf = orignalConf + "".join(newlines)
            # remove extra empty lines
            orignalConf = re.sub(r"\n\s*\n*", "\n", orignalConf)
            logger.debug(OvmStoragePool.prepareOCFS2Nodes, "Configure /etc/hosts:%s\n"%orignalConf)
            fd = open(ETC_HOSTS, "w")
            fd.write(orignalConf)
            fd.close()
        
        def configureHostName(nodes):
            myIp = successToMap(get_master_ip())['ip']
            nodeName = None
            for n in nodes:
                if myIp == n["ip_address"]:
                    nodeName = n["name"]
                    break
            
            if nodeName == None: raise Exception("Cannot find node equals to my ip address:%s"%myIp)
            if not exists(HOSTNAME_FILE):
                originalConf = ""
            else:
                fd = open(HOSTNAME_FILE, "r")
                originalConf = fd.read()
                fd.close()
            
            pattern = r"HOSTNAME=(.*)"
            # remove any old hostname
            originalConf = re.sub(pattern, "", originalConf)
            # remove extra empty lines
            originalConf = re.sub(r"\n\s*\n*", "\n", originalConf) + "\n" + "HOSTNAME=%s"%nodeName
            logger.debug(OvmStoragePool.prepareOCFS2Nodes, "Configure %s:%s\n"%(HOSTNAME_FILE,originalConf))
            fd = open(HOSTNAME_FILE, "w")
            fd.write(originalConf)
            fd.close()
            doCmd(['hostname', nodeName])
        
        def addNodes(nodes, clusterName):
            ocfs2 = OvmOCFS2()
            ocfs2._load()
            isOnline = ocfs2._isClusterOnline(clusterName)
            if not isOnline:
                ocfs2._prepareConf(clusterName)
            
            for n in nodes:
                ocfs2._addNode(n['name'], n['number'], n['ip_address'], 7777, clusterName, isOnline)
            
        def checkStaleCluster(clusterName):
            if exists('/sys/kernel/config/cluster/'):
                dirs = os.listdir('/sys/kernel/config/cluster/')
                for dir in dirs:
                    if dir != clusterName:
                        errMsg = '''CloudStack detected there is a stale cluster(%s) on host %s. Please manually clean up it first then add again by
1) remove the host from cloudstack 
2) umount all OCFS2 device on host
3) /etc/init.d/o2cb offline %s
4) /etc/init.d/o2cb restart
if this doesn't resolve the problem, please check oracle manual to see how to offline a cluster
    ''' % (dir, successToMap(get_master_ip())['ip'], dir)
                        raise Exception(errMsg)
            
        try:
            checkStaleCluster(clusterName)
            nodeString = nodeString.strip(";")
            nodes = []
            for n in nodeString.split(";"):
                params = n.split(":")
                if len(params) != 3: raise Exception("Wrong parameter(%s) in node string(%s)"%(n, nodeString))
                dict = {"number":params[0], "ip_address":params[1], "name":params[2]}
                nodes.append(dict)
            
            if len(nodes) > 255:
                raise Exception("%s nodes beyond maximum 255 allowed by OCFS2"%len(nodes))
            
            configureHostName(nodes)
            configureEtcHosts(nodes)
            addNodes(nodes, clusterName)
            OvmOCFS2()._start(clusterName)
            fd = open(OCFS2_CONF, 'r')
            conf = fd.readlines()
            fd.close()
            logger.debug(OvmStoragePool.prepareOCFS2Nodes, "Configure cluster.conf to:\n%s"%' '.join(conf))
            rs = SUCC()
            return rs
        
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmStoragePool.prepareOCFS2Nodes, errmsg)
            raise XmlRpcFault(toErrCode(OvmStoragePool, OvmStoragePool.prepareOCFS2Nodes), errmsg)
    
    @staticmethod
    def createTemplateFromVolume(secStorageMountPath, installPath, volumePath):
        try:
            secMountPoint = ""
            if not isfile(volumePath): raise Exception("Cannot find %s"%volumePath)
            vmCfg = join(dirname(volumePath), 'vm.cfg')
            vmName = getVmNameFromConfigureFile(vmCfg)
            if vmName in doCmd(['xm', 'list']):
                raise Exception("%s is still running, please stop it first then create template again"%vmName)
            
            tmpUuid = get_uuid()
            secMountPoint = join("/var/cloud/", tmpUuid)
            OvmStoragePool()._mount(secStorageMountPath, secMountPoint)
            installPath = installPath.lstrip('/')
            destPath = join(secMountPoint, installPath)
            #This prevent us deleting whole secondary in case we got a wrong installPath
            if destPath == secMountPoint: raise Exception("Install path equals to root of secondary storage(%s)"%destPath)
            if exists(destPath):
                logger.warning(OvmStoragePool.createTemplateFromVolume, "%s is already here, delete it since it is most likely stale"%destPath)
                doCmd(['rm', '-rf', destPath])
            OvmStoragePool()._checkDirSizeForImage(secMountPoint, volumePath)
            
            os.makedirs(destPath)
            newName = get_uuid() + ".raw"
            destName = join(destPath, newName)
            doCmd(['cp', volumePath, destName])
            size = os.path.getsize(destName)
            resInstallPath = join(installPath, newName)
            OvmStoragePool()._umount(secMountPoint)
            rs = toGson({"installPath":resInstallPath, "templateFileName":newName, "virtualSize":size, "physicalSize":size})
            return rs
        
        except Exception, e:
            try:
                if exists(secMountPoint):
                    OvmStoragePool()._umount(secMountPoint)
            except Exception, e:
                logger.warning(OvmStoragePool.createTemplateFromVolume, "umount %s failed"%secMountPoint)       
                
            errmsg = fmt_err_msg(e)
            logger.error(OvmStoragePool.createTemplateFromVolume, errmsg)
            raise XmlRpcFault(toErrCode(OvmStoragePool, OvmStoragePool.createTemplateFromVolume), errmsg)
    
    @staticmethod
    def delete(uuid):
        try:
            sr = OvmStoragePool()._getSrByNameLable(uuid)
            primaryStoragePath = sr.mountpoint
            OvmStoragePool()._umount(primaryStoragePath)
            rs = SUCC()
            return rs
        except Exception, e:
            errmsg = fmt_err_msg(e)
            logger.error(OvmStoragePool.delete, errmsg)
            raise XmlRpcFault(toErrCode(OvmStoragePool, OvmStoragePool.delete), errmsg) 
        
    @staticmethod
    def copyVolume(secStorageMountPath, volumeFolderOnSecStorage, volumePath, storagePoolUuid, toSec):
        def copyToSecStorage(secMountPoint, volumeFolderOnSecStorage, volumePath):
            if not isfile(volumePath): raise Exception("Cannot find volume at %s"%volumePath)
            OvmStoragePool()._checkDirSizeForImage(secMountPoint, volumePath)
            volumeFolderOnSecStorage = volumeFolderOnSecStorage.lstrip("/")
            destPath = join(secMountPoint, volumeFolderOnSecStorage)
            #This prevent us deleting whole secondary in case we got a wrong volumeFolderOnSecStorage
            if destPath == secMountPoint: raise Exception("volume path equals to root of secondary storage(%s)"%destPath)
            if exists(destPath):
                logger.warning(OvmStoragePool.copyVolume, "%s already exists, delete it first"%destPath)
                doCmd(['rm', '-rf', destPath])
            os.makedirs(destPath)
            newName = get_uuid() + ".raw"
            destName = join(destPath, newName)
            doCmd(['cp', volumePath, destName])
            return destName
        
        def copyToPrimary(secMountPoint, volumeFolderOnSecStorage, volumePath, primaryMountPath):
            srcPath = join(secMountPoint, volumeFolderOnSecStorage.lstrip("/"), volumePath.lstrip("/"))
            if not srcPath.endswith(".raw"): srcPath = srcPath + ".raw"
            if not isfile(srcPath): raise Exception("Cannot find volume at %s"%srcPath)
            if not exists(primaryMountPath): raise Exception("Primary storage(%s) seems to have gone"%primaryMountPath)
            OvmStoragePool()._checkDirSizeForImage(primaryMountPath, srcPath)
            destPath = join(primaryMountPath, "sharedDisk")
            newName = get_uuid() + ".raw"
            destName = join(destPath, newName)
            doCmd(['cp', srcPath, destName])
            return destName
                      
        secMountPoint = ""
        try:
            tmpUuid = get_uuid()
            secMountPoint = join("/var/cloud/", tmpUuid)
            OvmStoragePool()._mount(secStorageMountPath, secMountPoint)
            if toSec:
                resultPath = copyToSecStorage(secMountPoint, volumeFolderOnSecStorage, volumePath)
            else:
                sr = OvmStoragePool()._getSrByNameLable(storagePoolUuid)
                primaryStoragePath = sr.mountpoint
                resultPath = copyToPrimary(secMountPoint, volumeFolderOnSecStorage, volumePath, primaryStoragePath)
            OvmStoragePool()._umount(secMountPoint)
            
            # ingratiate bad mgmt server design, it asks 'installPath' but it only wants the volume name without suffix
            volumeUuid = basename(resultPath).rstrip(".raw")
            rs = toGson({"installPath":volumeUuid})
            return rs
        except Exception, e:
            try:
                if exists(secMountPoint):
                    OvmStoragePool()._umount(secMountPoint)
            except Exception, e:
                logger.warning(OvmStoragePool.copyVolume, "umount %s failed"%secMountPoint)       
                
            errmsg = fmt_err_msg(e)
            logger.error(OvmStoragePool.copyVolume, errmsg)
            raise XmlRpcFault(toErrCode(OvmStoragePool, OvmStoragePool.copyVolume), errmsg)