path: root/tools/laas-fog/source/api/libvirt_api.py

"""
#############################################################################
#Copyright 2017 Parker Berberian and others                                 #
#                                                                           #
#Licensed 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.                                             #
#############################################################################
"""

import libvirt
import time
import xml.dom
import xml.dom.minidom
from domain import Domain
from network import Network
from utilities import Utilities


class Libvirt:
    """
    This class talks to the Libvirt api.
    Given a config file, this class should create all networks and
    domains.

    TODO: convert prints to logging and remove uneeded pass statements
    """

    def __init__(self, hostAddr, net_conf=None, dom_conf=None):
        """
        init function
        hostAddr is the ip address of the host
        net_conf and dom_conf are the paths
        to the config files
        """
        self.host = hostAddr
        self.URI = "qemu+ssh://root@"+str(hostAddr)+"/system"
        self.hypervisor = None
        self.domains = []
        self.networks = []
        self.net_conf = net_conf
        self.dom_conf = dom_conf

    def setLogger(self, log):
        """
        Saves the logger in self.log
        """
        self.log = log

    def bootMaster(self):
        """
        starts the previously defined master node
        """
        for dom in self.domains:
            if 'master' in dom.name():
                try:
                    dom.create()
                except Exception:
                    pass

    def bootSlaves(self):
        """
        boots every defined vm with 'slave' in its name
        """
        for dom in self.domains:
            if 'slave' in dom.name():
                try:
                    dom.create()
                    self.log.info("Booting %s", dom.name())
                except Exception:
                    self.log.exception("%s", "failed to boot domain")
                time.sleep(5)

    def getMacs(self, domName):
        """
        returns a dictionary with a network name
        mapped to the mac address of the domain on that net
        """
        try:
            dom = self.hypervisor.lookupByName(domName)
            xmlDesc = dom.XMLDesc(0)
            parsedXML = xml.dom.minidom.parseString(xmlDesc)
            interfacesXML = parsedXML.getElementsByTagName('interface')
            netDict = {}
            for iface in interfacesXML:
                src = iface.getElementsByTagName('source')[0]
                mac = iface.getElementsByTagName('mac')[0]
                netDict[src] = mac
            return netDict
        except Exception:
            self.log.exception("%s", "Domain not found")

    def defineVM(self, xmlConfig):
        """
        Generic method to define a persistent vm with the
        given config.
        Assumes that self.hypervisor is already connected.
        """
        if self.checkForVM(xmlConfig):
            vm = self.hypervisor.defineXML(xmlConfig)
            if vm is None:
                name = self.getName(xmlConfig)
                self.log.error("Failed to define vm %s. exiting", name)
                exit(1)
            else:
                self.log.info("Successfully created vm %s", vm.name())
                pass
            self.domains.append(vm)

    def checkForVM(self, xmlConfig):
        """
        Checks if another vm with the same name exists
        on the remote host already. If it does, it will
        delete that vm
        """
        allGood = False
        vms = self.hypervisor.listAllDomains(0)
        names = []
        for dom in vms:
            names.append(dom.name())
        vmName = Utilities.getName(xmlConfig)
        if vmName in names:
            self.log.warning("domain %s already exists", vmName)
            self.log.warning("%s", "Atempting to delete it")
            self.deleteVM(vmName)
            allGood = True
        else:
            allGood = True
        return allGood

    def deleteVM(self, name):
        """
        removes the given vm from the remote host
        """
        try:
            vm = self.hypervisor.lookupByName(name)
        except:
            return
        active = vm.isActive()
        persistent = vm.isPersistent()
        if active:
            try:
                vm.destroy()
            except:
                self.log.exception("%s", "Failed to destroy vm")

        if persistent:
            try:
                vm.undefine()
            except:
                self.log.exception("%s", "Failed to undefine domain")
                pass

    def openConnection(self):
        """
        opens a connection to the remote host
        and stores it in self.hypervisor
        """
        self.log.info("Attempting to connect to libvirt at %s", self.host)
        try:
            hostHypervisor = libvirt.open(self.URI)
        except:
            self.log.warning(
                    "Failed to connect to %s. Trying again", self.host
                    )
            time.sleep(5)
            try:
                hostHypervisor = libvirt.open(self.URI)
            except:
                self.log.exception("Cannot connect to %s. Exiting", self.host)
                exit(1)

        if hostHypervisor is None:
            self.log.error("Failed to connect to %s. Exiting", self.host)
            exit(1)
        self.hypervisor = hostHypervisor

    def restartVM(self, vm):
        """
        causes the given vm to reboot
        """
        dom = self.hypervisor.lookupByName(vm)
        dom.destroy()
        time.sleep(15)
        dom.create()

    def close(self):
        """
        Closes connection to remote hypervisor
        """
        self.log.info("Closing connection to the hypervisor %s", self.host)
        self.hypervisor.close()

    def defineAllDomains(self, path):
        """
        Defines a domain from all the xml files in a directory
        """
        files = Utilities.getXMLFiles(path)
        definitions = []
        for xml_desc in files:
            definitions.append(xml_desc.read())

        for definition in definitions:
            self.defineVM(definition)

    def createAllNetworks(self, path):
        """
        Creates a network from all xml files in a directory
        """
        files = Utilities.getXMLFiles(path)
        definitions = []
        for xml_desc in files:
            definitions.append(Utilities.fileToString(xml_desc))

        for definition in definitions:
            self.createNet(definition)

    def createNet(self, config):
        """
        creates the network on the remote host
        config is the xml in string representation
        that defines the network
        """
        if self.checkNet(config):
            network = self.hypervisor.networkDefineXML(config)

            if network is None:
                name = self.getName(config)
                self.log.warning("Failed to define network %s", name)
            network.create()
            if network.isActive() == 1:
                net = network.name()
                self.log.info("Successfully defined network %s", net)
            self.networks.append(network)

    def checkNet(self, config):
        """
        Checks if another net with the same name exists, and
        deletes that network if one is found
        """
        allGood = False
        netName = Utilities.getName(config)
        if netName not in self.hypervisor.listNetworks():
            return True
        else:  # net name is already used
            self.log.warning(
                    "Network %s already exists. Trying to delete it", netName
                    )
            network = self.hypervisor.networkLookupByName(netName)
            self.deleteNet(network)
            allGood = True
        return allGood

    def deleteNet(self, net):
        """
        removes the given network from the host
        """
        active = net.isActive()
        persistent = net.isPersistent()
        if active:
            try:
                net.destroy()
            except:
                self.log.warning("%s", "Failed to destroy network")

        if persistent:
            try:
                net.undefine()
            except:
                self.log.warning("%s", "Failed to undefine network")

    def go(self):
        """
        This method does all the work of this class,
        Parsing the net and vm config files and creating
        all the requested nets/domains
        returns a list of all networks and a list of all domains
        as Network and Domain objects
        """
        nets = self.makeNetworks(self.net_conf)
        doms = self.makeDomains(self.dom_conf)
        return doms, nets

    def makeNetworks(self, conf):
        """
        Given a path to a  config file, this method
        parses the config and creates all requested networks,
        and returns them in a list of Network objects
        """
        networks = []
        definitions = Network.parseConfigFile(conf)
        for definition in definitions:
            network = Network(definition)
            networks.append(network)
            self.createNet(network.toXML())
        return networks

    def makeDomains(self, conf):
        """
        Given a path to a config file, this method
        parses the config and creates all requested vm's,
        and returns them in a list of Domain objects
        """
        domains = []
        definitions = Domain.parseConfigFile(conf)
        for definition in definitions:
            domain = Domain(definition)
            domains.append(domain)
            self.defineVM(domain.toXML())
        return domains

    @staticmethod
    def getName(xmlString):
        """
        given xml with a name tag, this returns the value of name
        eg:
            <name>Parker</name>
        returns 'Parker'
        """
        xmlDoc = xml.dom.minidom.parseString(xmlString)
        nameNode = xmlDoc.documentElement.getElementsByTagName('name')
        name = str(nameNode[0].firstChild.nodeValue)
        return name