virt-manager/virtinst/VirtualNetworkInterface.py

#
# Copyright 2006-2009  Red Hat, Inc.
# Jeremy Katz <katzj@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free  Software Foundation; either version 2 of the License, or
# (at your option)  any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.

import logging
import random

import libvirt

from virtinst import util
from virtinst.VirtualDevice import VirtualDevice
from virtinst.xmlbuilder import XMLBuilder, XMLProperty


def _random_mac(conn):
    """Generate a random MAC address.

    00-16-3E allocated to xensource
    52-54-00 used by qemu/kvm

    The OUI list is available at http://standards.ieee.org/regauth/oui/oui.txt.

    The remaining 3 fields are random, with the first bit of the first
    random field set 0.

    @return: MAC address string
    """
    ouis = {'xen': [0x00, 0x16, 0x3E], 'qemu': [0x52, 0x54, 0x00]}

    try:
        oui = ouis[conn.getType().lower()]
    except KeyError:
        oui = ouis['xen']

    mac = oui + [
            random.randint(0x00, 0xff),
            random.randint(0x00, 0xff),
            random.randint(0x00, 0xff)]
    return ':'.join(["%02x" % x for x in mac])


class VirtualPort(XMLBuilder):

    def __init__(self, conn, parsexml=None, parsexmlnode=None):
        XMLBuilder.__init__(self, conn, parsexml,
                                                   parsexmlnode)
        self._type = None
        self._managerid = None
        self._typeid = None
        self._typeidversion = None
        self._instanceid = None

    def get_type(self):
        return self._type
    def set_type(self, val):
        self._type = val
    type = XMLProperty(get_type, set_type,
                                  xpath="./virtualport/@type")

    def get_managerid(self):
        return self._managerid
    def set_managerid(self, val):
        self._managerid = val
    managerid = XMLProperty(get_managerid, set_managerid,
                                  xpath="./virtualport/parameters/@managerid")

    def get_typeid(self):
        return self._typeid
    def set_typeid(self, val):
        self._typeid = val
    typeid = XMLProperty(get_typeid, set_typeid,
                               xpath="./virtualport/parameters/@typeid")

    def get_typeidversion(self):
        return self._typeidversion
    def set_typeidversion(self, val):
        self._typeidversion = val
    typeidversion = XMLProperty(get_typeidversion, set_typeidversion,
                               xpath="./virtualport/parameters/@typeidversion")

    def get_instanceid(self):
        return self._instanceid
    def set_instanceid(self, val):
        self._instanceid = val
    instanceid = XMLProperty(get_instanceid, set_instanceid,
                               xpath="./virtualport/parameters/@instanceid")

    def _get_xml_config(self):
        # FIXME: This should be implemented, currently we can only parse
        return ""


class VirtualNetworkInterface(VirtualDevice):

    _virtual_device_type = VirtualDevice.VIRTUAL_DEV_NET

    TYPE_BRIDGE     = "bridge"
    TYPE_VIRTUAL    = "network"
    TYPE_USER       = "user"
    TYPE_ETHERNET   = "ethernet"
    TYPE_DIRECT   = "direct"
    network_types = [TYPE_BRIDGE, TYPE_VIRTUAL, TYPE_USER, TYPE_ETHERNET,
                     TYPE_DIRECT]

    @staticmethod
    def get_network_type_desc(net_type):
        """
        Return human readable description for passed network type
        """
        desc = net_type.capitalize()

        if net_type == VirtualNetworkInterface.TYPE_BRIDGE:
            desc = _("Shared physical device")
        elif net_type == VirtualNetworkInterface.TYPE_VIRTUAL:
            desc = _("Virtual networking")
        elif net_type == VirtualNetworkInterface.TYPE_USER:
            desc = _("Usermode networking")

        return desc

    @staticmethod
    def generate_mac(conn):
        """
        Generate a random MAC that doesn't conflict with any VMs on
        the connection.
        """
        if hasattr(conn, "_virtinst__fake_conn_predictable"):
            # Testing hack
            return "00:11:22:33:44:55"

        for ignore in range(256):
            mac = _random_mac(conn)
            ret = VirtualNetworkInterface.is_conflict_net(conn, mac)
            if ret[1] is None:
                return mac

        logging.debug("Failed to generate non-conflicting MAC")
        return None

    @staticmethod
    def is_conflict_net(conn, searchmac):
        """
        @returns: a two element tuple:
            first element is True if fatal collision occured
            second element is a string description of the collision.

            Non fatal collisions (mac addr collides with inactive guest) will
            return (False, "description of collision")
        """
        if searchmac is None:
            return (False, None)

        vms = conn.fetch_all_guests()
        for vm in vms:
            for nic in vm.get_devices("interface"):
                nicmac = nic.macaddr or ""
                if nicmac.lower() == searchmac.lower():
                    return (True, _("The MAC address '%s' is in use "
                                    "by another virtual machine.") % searchmac)
        return (False, None)


    def __init__(self, conn, macaddr=None, type=TYPE_BRIDGE, bridge=None,
                 network=None, model=None,
                 parsexml=None, parsexmlnode=None):
        # pylint: disable=W0622
        # Redefining built-in 'type', but it matches the XML so keep it

        VirtualDevice.__init__(self, conn, parsexml, parsexmlnode)

        self._network = None
        self._bridge = None
        self._macaddr = None
        self._type = None
        self._model = None
        self._target_dev = None
        self._source_dev = None
        self._source_mode = "vepa"
        self._virtualport = VirtualPort(conn, parsexml, parsexmlnode)

        # Generate _random_mac
        self._random_mac = None
        self._default_bridge = None

        if self._is_parse():
            return

        self.type = type
        self.macaddr = macaddr
        self.bridge = bridge
        self.source_dev = bridge
        self.network = network
        self.model = model

        if self.type == self.TYPE_VIRTUAL:
            if network is None:
                raise ValueError(_("A network name was not provided"))

    def _generate_default_bridge(self):
        ret = self._default_bridge
        if ret is None:
            ret = False
            default = util.default_bridge(self.conn)
            if default:
                ret = default[1]

        self._default_bridge = ret
        return ret or None

    def get_source(self):
        """
        Convenince function, try to return the relevant <source> value
        per the network type.
        """
        if self.type == self.TYPE_VIRTUAL:
            return self.network
        if self.type == self.TYPE_BRIDGE:
            return self.bridge
        if self.type == self.TYPE_ETHERNET or self.type == self.TYPE_DIRECT:
            return self.source_dev
        if self.type == self.TYPE_USER:
            return None
        return self.network or self.bridge or self.source_dev

    def set_source(self, newsource):
        """
        Conveninece function, try to set the relevant <source> value
        per the network type
        """
        if self.type == self.TYPE_VIRTUAL:
            self.network = newsource
        elif self.type == self.TYPE_BRIDGE:
            self.bridge = newsource
        elif self.type == self.TYPE_ETHERNET or self.type == self.TYPE_DIRECT:
            self.source_dev = newsource
        return
    source = property(get_source, set_source)

    def _get_virtualport(self):
        return self._virtualport
    virtualport = property(_get_virtualport)

    def get_type(self):
        return self._type
    def set_type(self, val):
        if val not in self.network_types:
            raise ValueError(_("Unknown network type %s") % val)
        self._type = val
    type = XMLProperty(get_type, set_type,
                         xpath="./@type")

    def get_macaddr(self):
        # Don't generate a random MAC if parsing XML, since it can be slow
        if self._macaddr or self._is_parse():
            return self._macaddr
        if not self._random_mac:
            self._random_mac = self.generate_mac(self.conn)
        return self._random_mac
    def set_macaddr(self, val):
        util.validate_macaddr(val)
        self._macaddr = val
    macaddr = XMLProperty(get_macaddr, set_macaddr,
                            xpath="./mac/@address")

    def get_network(self):
        return self._network
    def set_network(self, newnet):
        def _is_net_active(netobj):
            # Apparently the 'info' command was never hooked up for
            # libvirt virNetwork python apis.
            if not self.conn:
                return True
            return self.conn.listNetworks().count(netobj.name())

        if newnet is not None and self.conn:
            try:
                net = self.conn.networkLookupByName(newnet)
            except libvirt.libvirtError, e:
                raise ValueError(_("Virtual network '%s' does not exist: %s")
                                   % (newnet, str(e)))
            if not _is_net_active(net):
                raise ValueError(_("Virtual network '%s' has not been "
                                   "started.") % newnet)

        self._network = newnet
    network = XMLProperty(get_network, set_network,
                            xpath="./source/@network")

    def get_bridge(self):
        if (not self._is_parse() and
            not self._bridge and
            self.type == self.TYPE_BRIDGE):
            return self._generate_default_bridge()
        return self._bridge
    def set_bridge(self, val):
        self._bridge = val
    bridge = XMLProperty(get_bridge, set_bridge,
                           xpath="./source/@bridge")

    def get_model(self):
        return self._model
    def set_model(self, val):
        self._model = val
    model = XMLProperty(get_model, set_model,
                          xpath="./model/@type")

    def get_target_dev(self):
        return self._target_dev
    def set_target_dev(self, val):
        self._target_dev = val
    target_dev = XMLProperty(get_target_dev, set_target_dev,
                               xpath="./target/@dev")

    def get_source_dev(self):
        return self._source_dev
    def set_source_dev(self, val):
        self._source_dev = val
    source_dev = XMLProperty(get_source_dev, set_source_dev,
                               xpath="./source/@dev")

    def get_source_mode(self):
        return self._source_mode
    def set_source_mode(self, newmode):
        self._source_mode = newmode
    source_mode = XMLProperty(get_source_mode, set_source_mode,
                                xpath="./source/@mode")

    def setup(self, meter=None):
        if self.macaddr:
            ret, msg = self.is_conflict_net(self.conn, self.macaddr)
            if msg is not None:
                if ret is False:
                    logging.warning(msg)
                else:
                    raise RuntimeError(msg)

    def _get_xml_config(self):
        src_xml = ""
        model_xml = ""
        target_xml = ""
        addr_xml = ""
        if self.type == self.TYPE_BRIDGE:
            src_xml     = "      <source bridge='%s'/>\n" % self.bridge
        elif self.type == self.TYPE_VIRTUAL:
            src_xml     = "      <source network='%s'/>\n" % self.network
        elif self.type == self.TYPE_ETHERNET and self.source_dev:
            src_xml     = "      <source dev='%s'/>\n" % self.source_dev
        elif self.type == self.TYPE_DIRECT and self.source_dev:
            src_xml     = "      <source dev='%s' mode='%s'/>\n" % (self.source_dev, self.source_mode)

        if self.model:
            model_xml   = "      <model type='%s'/>\n" % self.model

        if self.address:
            addr_xml = self.indent(self.address.get_xml_config(), 6)

        if self.target_dev:
            target_xml  = "      <target dev='%s'/>\n" % self.target_dev

        xml  = "    <interface type='%s'>\n" % self.type
        xml += src_xml
        xml += "      <mac address='%s'/>\n" % self.macaddr
        xml += target_xml
        xml += model_xml
        xml += addr_xml
        xml += "    </interface>"
        return xml