def testAlterSounds(self):
infile = "tests/xmlparse-xml/change-sounds-in.xml"
outfile = "tests/xmlparse-xml/change-sounds-out.xml"
guest = virtinst.Guest(conn, parsexml=file(infile).read())
dev1 = guest.get_devices("sound")[0]
dev2 = guest.get_devices("sound")[1]
dev3 = guest.get_devices("sound")[2]
check = self._make_checker(dev1)
check("model", "sb16", "ac97")
check = self._make_checker(dev2)
check("model", "es1370", "es1370")
check = self._make_checker(dev3)
check("model", "ac97", "sb16")
self._alter_compare(guest.get_xml_config(), outfile)
def testAddRemoveDevices(self):
infile = "tests/xmlparse-xml/add-devices-in.xml"
outfile = "tests/xmlparse-xml/add-devices-out.xml"
guest = virtinst.Guest(conn=conn,
parsexml=file(infile).read())
rmdev = guest.get_devices("disk")[2]
guest.remove_device(rmdev)
adddev = virtinst.VirtualNetworkInterface(conn=conn, type="network",
network="default",
macaddr="1A:2A:3A:4A:5A:6A")
guest.add_device(virtinst.VirtualWatchdog(conn))
guest.add_device(adddev)
guest.remove_device(adddev)
guest.add_device(adddev)
self._alter_compare(guest.get_xml_config(), outfile)
def testAlterGraphics(self):
infile = "tests/xmlparse-xml/change-graphics-in.xml"
outfile = "tests/xmlparse-xml/change-graphics-out.xml"
guest = virtinst.Guest(conn=conn,
parsexml=file(infile).read())
dev1 = guest.get_devices("graphics")[0]
dev2 = guest.get_devices("graphics")[1]
dev3 = guest.get_devices("graphics")[2]
dev4 = guest.get_devices("graphics")[3]
dev5 = guest.get_devices("graphics")[4]
check = self._make_checker(dev1)
check("type", "vnc")
check("passwd", "foobar", "newpass")
check("port", 100, 6000)
check("listen", "0.0.0.0", "1.2.3.4")
check = self._make_checker(dev2)
check("type", "sdl")
check("xauth", "/tmp/.Xauthority", "fooauth")
check("display", "1:2", "6:1")
check = self._make_checker(dev3)
check("type", "rdp")
check = self._make_checker(dev4)
check("type", "vnc")
check("port", -1)
check("socket", "/tmp/foobar", "/var/lib/libvirt/socket/foo")
check = self._make_checker(dev5)
check("type", "spice")
check("passwd", "foobar", "newpass")
check("port", 100, 6000)
check("tlsPort", 101, 6001)
check("listen", "0.0.0.0", "1.2.3.4")
check("channel_inputs_mode", "insecure", "secure")
check("channel_main_mode", "secure", "any")
check("channel_record_mode", "any", "insecure")
check("passwdValidTo", "2010-04-09T15:51:00", "2011-01-07T19:08:00")
self._alter_compare(guest.get_xml_config(), outfile)
def testAlterInputs(self):
infile = "tests/xmlparse-xml/change-inputs-in.xml"
outfile = "tests/xmlparse-xml/change-inputs-out.xml"
guest = virtinst.Guest(conn=conn,
parsexml=file(infile).read())
dev1 = guest.get_devices("input")[0]
dev2 = guest.get_devices("input")[1]
check = self._make_checker(dev1)
check("type", "mouse", "tablet")
check("bus", "ps2", "usb")
check = self._make_checker(dev2)
check("type", "tablet", "mouse")
check("bus", "usb", "xen")
check("bus", "xen", "usb")
self._alter_compare(guest.get_xml_config(), outfile)
def testAlterDisk(self):
"""
Test changing VirtualDisk() parameters after parsing
"""
infile = "tests/xmlparse-xml/change-disk-in.xml"
outfile = "tests/xmlparse-xml/change-disk-out.xml"
guest = virtinst.Guest(conn=conn,
parsexml=file(infile).read())
# Set size up front. VirtualDisk validation is kind of
# convoluted. If trying to change a non-existing one and size wasn't
# already specified, we will error out.
disks = guest.get_devices("disk")
disk1 = disks[0]
disk1.size = 1
disk2 = disks[2]
disk2.size = 1
disk3 = disks[5]
disk3.size = 1
check = self._make_checker(disk1)
check("path", "/tmp/test.img", "/dev/loop0")
check("driver_name", None, "test")
check("driver_type", None, "raw")
check("serial", "WD-WMAP9A966149", "frob")
check = self._make_checker(disk2)
check("path", "/dev/loop0", None)
check("device", "cdrom", "floppy")
check("read_only", True, False)
check("target", None, "fde")
check("bus", None, "fdc")
check("error_policy", "stop", None)
check = self._make_checker(disk3)
check("path", None, "/default-pool/default-vol")
check("shareable", False, True)
check("driver_cache", None, "writeback")
check("driver_io", None, "threads")
check("driver_io", "threads", "native")
self._alter_compare(guest.get_xml_config(), outfile)
def testAlterFilesystems(self):
devtype = "filesystem"
infile = "tests/xmlparse-xml/change-%ss-in.xml" % devtype
outfile = "tests/xmlparse-xml/change-%ss-out.xml" % devtype
guest = virtinst.Guest(conn=conn,
parsexml=file(infile).read())
dev1 = guest.get_devices(devtype)[0]
dev2 = guest.get_devices(devtype)[1]
dev3 = guest.get_devices(devtype)[2]
dev4 = guest.get_devices(devtype)[3]
check = self._make_checker(dev1)
check("type", None, "mount")
check("mode", None, "passthrough")
check("driver", "handle", None)
check("wrpolicy", None, None)
check("source", "/foo/bar", "/new/path")
check("target", "/bar/baz", "/new/target")
check = self._make_checker(dev2)
check("type", "template")
check("mode", None, "mapped")
check("source", "template_fedora", "template_new")
check("target", "/bar/baz")
check = self._make_checker(dev3)
check("type", "mount", None)
check("mode", "squash", None)
check("driver", "path", "handle")
check("wrpolicy", "immediate", None)
check("readonly", False, True)
check = self._make_checker(dev4)
check("type", "mount", None)
check("mode", "mapped", None)
check("driver", "path", "handle")
check("wrpolicy", None, "immediate")
check("readonly", False, True)
self._alter_compare(guest.get_xml_config(), outfile)
def testAlterHostdevs(self):
infile = "tests/xmlparse-xml/change-hostdevs-in.xml"
outfile = "tests/xmlparse-xml/change-hostdevs-out.xml"
guest = virtinst.Guest(conn,
parsexml=file(infile).read())
dev1 = guest.get_devices("hostdev")[0]
dev2 = guest.get_devices("hostdev")[1]
dev3 = guest.get_devices("hostdev")[2]
check = self._make_checker(dev1)
check("type", "usb", "foo", "usb")
check("managed", True, False)
check("mode", "subsystem", None)
check("vendor", "0x4321", "0x1111")
check("product", "0x1234", "0x2222")
check("bus", None, "1")
check("device", None, "2")
check = self._make_checker(dev2)
check("type", "usb")
check("managed", False, True)
check("mode", "capabilities", "subsystem")
check("bus", "0x12", "0x56")
check("device", "0x34", "0x78")
check = self._make_checker(dev3)
check("type", "pci")
check("managed", True, True)
check("mode", "subsystem", "subsystem")
check("domain", "0x0", "0x4")
check("bus", "0x1", "0x5")
check("slot", "0x2", "0x6")
check("function", "0x3", "0x7")
check("driver_name", None, "vfio")
check("rom_bar", None, True)
self._alter_compare(guest.get_xml_config(), outfile)
def testAlterVideos(self):
infile = "tests/xmlparse-xml/change-videos-in.xml"
outfile = "tests/xmlparse-xml/change-videos-out.xml"
guest = virtinst.Guest(conn=conn, parsexml=file(infile).read())
dev1 = guest.get_devices("video")[0]
dev2 = guest.get_devices("video")[1]
dev3 = guest.get_devices("video")[2]
check = self._make_checker(dev1)
check("model_type", "vmvga", "vga")
check("vram", None, "1000")
check("heads", None, "1")
check = self._make_checker(dev2)
check("model_type", "cirrus", "vmvga")
check("vram", "10240", None)
check("heads", "3", "5")
check = self._make_checker(dev3)
check("model_type", "cirrus", "cirrus")
self._alter_compare(guest.get_config_xml(), outfile)
def get_basic_paravirt_guest(installer=None):
g = virtinst.Guest(_conn)
g.type = "xen"
g.name = "TestGuest"
g.memory = int(200 * 1024)
g.maxmemory = int(400 * 1024)
g.uuid = "12345678-1234-1234-1234-123456789012"
gdev = VirtualGraphics(_conn)
gdev.type = "vnc"
gdev.keymap = "ja"
g.add_device(gdev)
g.vcpus = 5
if installer:
g.installer = installer
else:
g.installer._install_kernel = "/boot/vmlinuz"
g.installer._install_initrd = "/boot/initrd"
g.add_default_input_device()
g.add_default_console_device()
return g
def testAlterAddr(self):
infile = "tests/xmlparse-xml/change-addr-in.xml"
outfile = "tests/xmlparse-xml/change-addr-out.xml"
guest = virtinst.Guest(conn=conn,
parsexml=file(infile).read())
dev1 = guest.get_devices("disk")[0]
dev2 = guest.get_devices("controller")[0]
dev3 = guest.get_devices("channel")[0]
check = self._make_checker(dev1.address)
check("type", "drive", "pci")
check("type", "pci", "drive")
check("controller", "3", "1")
check("bus", "5", "4")
check("unit", "33", "32")
check = self._make_checker(dev1.alias)
check("name", "foo2", None)
check = self._make_checker(dev2.address)
check("type", "pci")
check("domain", "0x0000", "0x0001")
check("bus", "0x00", "4")
check("slot", "0x04", "10")
check("function", "0x7", "0x6")
check = self._make_checker(dev2.alias)
check("name", None, "frob")
check = self._make_checker(dev3.address)
check("type", "virtio-serial")
check("controller", "0")
check("bus", "0")
check("port", "2", "4")
check = self._make_checker(dev3.alias)
check("name", "channel0", "channel1")
self._alter_compare(guest.get_xml_config(), outfile)
def testControllerAttachedDevices():
"""
Test DeviceController.get_attached_devices
"""
conn = utils.URIs.open_testdefault_cached()
xml = open(DATADIR + "controller-attached-devices.xml").read()
guest = virtinst.Guest(conn, xml)
# virtio-serial path
controller = [
c for c in guest.devices.controller if c.type == "virtio-serial"
][0]
devs = controller.get_attached_devices(guest)
assert len(devs) == 4
assert devs[-1].DEVICE_TYPE == "console"
# disk path
controller = [c for c in guest.devices.controller if c.type == "sata"][0]
devs = controller.get_attached_devices(guest)
assert len(devs) == 1
assert devs[-1].device == "cdrom"
# Little test for DeviceAddress.pretty_desc
assert devs[-1].address.pretty_desc() == "0:0:0:3"
def _get_test_content(conn, basename):
infile = DATADIR + "%s-in.xml" % basename
outfile = _gen_outfile_path(basename)
guest = virtinst.Guest(conn, parsexml=open(infile).read())
return guest, outfile
def _import_file(conn, input_file):
"""
Parse the OVF file and generate a virtinst.Guest object from it
"""
root = xml.etree.ElementTree.parse(input_file).getroot()
vsnode = _find(root, "./ovf:VirtualSystem")
vhnode = _find(vsnode, "./ovf:VirtualHardwareSection")
# General info
name = _text(vsnode.find("./ovf:Name", OVF_NAMESPACES))
desc = _text(vsnode.find("./ovf:AnnotationSection/ovf:Annotation",
OVF_NAMESPACES))
if not desc:
desc = _text(vsnode.find("./ovf:Description", OVF_NAMESPACES))
vhxpath = "./ovf:Item[rasd:ResourceType='%s']"
vcpus = _text(_find(vhnode,
(vhxpath % DEVICE_CPU) + "/rasd:VirtualQuantity"))
mem = _text(_find(vhnode,
(vhxpath % DEVICE_MEMORY) + "/rasd:VirtualQuantity"))
alloc_mem = _text(_find(vhnode,
(vhxpath % DEVICE_MEMORY) + "/rasd:AllocationUnits"))
# Sections that we handle
# NetworkSection is ignored, since I don't have an example of
# a valid section in the wild.
parsed_sections = ["References", "DiskSection", "NetworkSection",
"VirtualSystem"]
# Check for unhandled 'required' sections
for env_node in root.findall("./"):
if any([p for p in parsed_sections if p in env_node.tag]):
continue
logging.debug("Unhandled XML section '%s'",
env_node.tag)
if not _convert_bool_val(env_node.attrib.get("required")):
continue
raise Exception(_("OVF section '%s' is listed as "
"required, but parser doesn't know "
"how to handle it.") % env_node.name)
disk_buses = {}
for node in _findall(vhnode, vhxpath % DEVICE_IDE_BUS):
instance_id = _text(_find(node, "rasd:InstanceID"))
disk_buses[instance_id] = "ide"
for node in _findall(vhnode, vhxpath % DEVICE_SCSI_BUS):
instance_id = _text(_find(node, "rasd:InstanceID"))
disk_buses[instance_id] = "scsi"
ifaces = []
for node in _findall(vhnode, vhxpath % DEVICE_ETHERNET):
iface = virtinst.DeviceInterface(conn)
# Just ignore 'source' info for now and choose the default
net_model = _text(_find(node, "rasd:ResourceSubType"))
if net_model and not net_model.isdigit():
iface.model = net_model.lower()
iface.set_default_source()
ifaces.append(iface)
disks = []
for node in _findall(vhnode, vhxpath % DEVICE_DISK):
bus_id = _text(_find(node, "rasd:Parent"))
path = _text(_find(node, "rasd:HostResource"))
bus = disk_buses.get(bus_id, "ide")
fmt = "raw"
if path:
path = _lookup_disk_path(root, path)
fmt = "vmdk"
disk = virtinst.DeviceDisk(conn)
disk.path = path
disk.driver_type = fmt
disk.bus = bus
disk.device = "disk"
disks.append(disk)
# Generate the Guest
guest = virtinst.Guest(conn)
if not name:
name = os.path.basename(input_file)
guest.name = name.replace(" ", "_")
guest.description = desc or None
if vcpus:
guest.vcpus = int(vcpus)
if mem:
guest.memory = _convert_alloc_val(alloc_mem, mem) * 1024
for dev in ifaces + disks:
guest.add_device(dev)
return guest
def testGuestValidation(self):
g = virtinst.Guest(conn=testconn, type="xen")
self._testArgs(g, virtinst.Guest, 'guest')
def _roundtrip_compare(self, filename):
expectXML = sanitize_file_xml(file(filename).read())
guest = virtinst.Guest(conn, parsexml=expectXML)
actualXML = guest.get_xml_config()
utils.diff_compare(actualXML, expect_out=expectXML)
def testAlterGuest(self):
"""
Test changing Guest() parameters after parsing
"""
infile = "tests/xmlparse-xml/change-guest-in.xml"
outfile = "tests/xmlparse-xml/change-guest-out.xml"
guest = virtinst.Guest(conn=conn, parsexml=file(infile).read())
check = self._make_checker(guest)
check("name", "TestGuest", "change_name")
check("description", None, "Hey desc changed")
check("maxvcpus", 5, 30)
check("vcpus", 30, 22)
check("cpuset", "1-3", "1-8,^6", "1-5,15")
check("maxmemory", 400, 500)
check("memory", 200, 1000)
check("maxmemory", 1000, 2000)
check("uuid", "12345678-1234-1234-1234-123456789012",
"11111111-2222-3333-4444-555555555555")
check("emulator", "/usr/lib/xen/bin/qemu-dm", "/usr/binnnn/fooemu")
check("hugepage", False, True)
check = self._make_checker(guest.clock)
check("offset", "utc", "localtime")
check = self._make_checker(guest.seclabel)
check("type", "static", "static")
check("model", "selinux", "apparmor")
check("label", "foolabel", "barlabel")
check("imagelabel", "imagelabel", "fooimage")
check = self._make_checker(guest.installer)
check("type", "kvm", "test")
check("os_type", "hvm", "xen")
check("arch", "i686", None)
check("machine", "foobar", "pc-0.11")
check("loader", None, "/foo/loader")
check("init", None, "/sbin/init")
check = self._make_checker(guest.installer.bootconfig)
check("bootorder", ["hd"], ["fd"])
check("enable_bootmenu", None, False)
check("kernel", None)
check("initrd", None)
check("kernel_args", None)
check = self._make_checker(guest.features)
check("acpi", True, False)
check("apic", True, False)
check("pae", False, True)
def feature_checker(prop, origval, newval):
self.assertEqual(guest.features[prop], origval)
guest.features[prop] = newval
self.assertEqual(guest.features[prop], newval)
feature_checker("acpi", False, False)
feature_checker("apic", False, True)
feature_checker("pae", True, False)
check = self._make_checker(guest.cpu)
check("match", "exact", "strict")
check("model", "footest", "qemu64")
check("vendor", "Intel", "qemuvendor")
check("threads", 2, 1)
check("cores", 5, 3)
check("sockets", 4, 1)
check = self._make_checker(guest.cpu.features[0])
check("name", "x2apic", "foofeat")
check("policy", "force", "disable")
guest.cpu.remove_feature(guest.cpu.features[1])
guest.cpu.add_feature("addfeature")
check = self._make_checker(guest.numatune)
check("memory_mode", "interleave", "strict", None)
check("memory_nodeset", "1-5,^3,7", "2,4,6")
self._alter_compare(guest.get_config_xml(), outfile)
def _make_guest(conn=None, os_variant=None):
if not conn:
conn = utils.URIs.open_testdriver_cached()
g = virtinst.Guest(conn)
g.type = "kvm"
g.name = "TestGuest"
g.memory = int(200 * 1024)
g.maxmemory = int(400 * 1024)
g.uuid = "12345678-1234-1234-1234-123456789012"
gdev = virtinst.DeviceGraphics(conn)
gdev.type = "vnc"
gdev.keymap = "ja"
g.add_device(gdev)
g.features.pae = False
g.vcpus = 5
g.emulator = "/usr/lib/xen/bin/qemu-dm"
g.os.arch = "i686"
g.os.os_type = "hvm"
if os_variant:
g.set_os_name(os_variant)
# Floppy disk
path = "/dev/default-pool/testvol1.img"
d = DeviceDisk(conn)
d.path = path
d.device = d.DEVICE_FLOPPY
d.validate()
g.add_device(d)
# File disk
path = "/dev/default-pool/new-test-suite.img"
d = virtinst.DeviceDisk(conn)
d.path = path
if d.wants_storage_creation():
parent_pool = d.get_parent_pool()
vol_install = virtinst.DeviceDisk.build_vol_install(conn,
os.path.basename(path), parent_pool, .0000001, True)
d.set_vol_install(vol_install)
d.validate()
g.add_device(d)
# Block disk
path = "/dev/disk-pool/diskvol1"
d = virtinst.DeviceDisk(conn)
d.path = path
d.validate()
g.add_device(d)
# Network device
dev = virtinst.DeviceInterface(conn)
dev.macaddr = "22:22:33:44:55:66"
dev.type = virtinst.DeviceInterface.TYPE_VIRTUAL
dev.source = "default"
g.add_device(dev)
return g
"noxen": True,
'i586': MANDRIVA_BASEURL % ("2009.1", "i586"),
'x86_64': MANDRIVA_BASEURL % ("2009.1", "x86_64"),
'distro': ("linux", None)
},
"mandriva-2010.2" : {
"noxen": True,
'i586': MANDRIVA_BASEURL % ("2010.2", "i586"),
'x86_64': MANDRIVA_BASEURL % ("2010.2", "x86_64"),
'distro': ("linux", None)
},
}
testconn = libvirt.open("test:///default")
testguest = virtinst.Guest(conn=testconn,
installer=virtinst.DistroInstaller())
class TestURLFetch(unittest.TestCase):
def setUp(self):
self.meter = urlgrabber.progress.BaseMeter()
if utils.get_debug():
self.meter = urlgrabber.progress.TextMeter(fo=sys.stdout)
def _fetchLocalMedia(self, mediapath):
arch = platform.machine()
fetcher = OSDistro._fetcherForURI(mediapath, "/tmp")
def _get_test_content(self, basename, kvm=False):
infile = "tests/xmlparse-xml/%s-in.xml" % basename
outfile = "tests/xmlparse-xml/%s-out.xml" % basename
guest = virtinst.Guest(kvm and kvmconn or conn,
parsexml=file(infile).read())
return guest, outfile
def _make_guest(installer=None, conn=None):
if conn is None:
conn = _default_conn
g = virtinst.Guest(conn)
g.type = "kvm"
g.name = "TestGuest"
g.memory = int(200 * 1024)
g.maxmemory = int(400 * 1024)
g.uuid = "12345678-1234-1234-1234-123456789012"
gdev = virtinst.VirtualGraphics(conn)
gdev.type = "vnc"
gdev.keymap = "ja"
g.add_device(gdev)
g.features.pae = False
g.vcpus = 5
if not installer:
installer = _make_installer(conn=conn)
g.installer = installer
g.emulator = "/usr/lib/xen/bin/qemu-dm"
g.os.arch = "i686"
g.os.os_type = "hvm"
g.add_default_input_device()
g.add_default_console_device()
g.add_device(virtinst.VirtualAudio(g.conn))
# Floppy disk
path = "/dev/default-pool/testvol1.img"
d = VirtualDisk(conn)
d.path = path
d.device = d.DEVICE_FLOPPY
d.validate()
g.add_device(d)
# File disk
path = "/dev/default-pool/new-test-suite.img"
d = virtinst.VirtualDisk(conn)
d.path = path
if d.wants_storage_creation():
parent_pool = d.get_parent_pool()
vol_install = virtinst.VirtualDisk.build_vol_install(
conn, os.path.basename(path), parent_pool, .0000001, True)
d.set_vol_install(vol_install)
d.validate()
g.add_device(d)
# Block disk
path = "/dev/disk-pool/diskvol1"
d = virtinst.VirtualDisk(conn)
d.path = path
d.validate()
g.add_device(d)
# Network device
dev = virtinst.VirtualNetworkInterface(conn)
dev.macaddr = "22:22:33:44:55:66"
dev.type = virtinst.VirtualNetworkInterface.TYPE_VIRTUAL
dev.source = "default"
g.add_device(dev)
return g
