← Back to branch summary

~ubuntu-branches/ubuntu/quantal/virtinst/quantal-proposed

« back to all changes in this revision

Viewing changes to .pc/9002-libvirt_disk_format.patch/tests/xmlconfig.py

  • Committer: Bazaar Package Importer
  • Author(s): Marc Deslauriers
  • Date: 2011-02-01 15:40:11 UTC
  • mfrom: (1.3.16 experimental)
  • Revision ID: james.westby@ubuntu.com-20110201154011-op0nusgc240xajvb
Tags: 0.500.5-1ubuntu1
* Merge from debian experimental. Remaining changes:
  - debian/patches/9001_Ubuntu.patch:
     + Updated to add maverick and natty to OS list and enable virtio
       for them.
  - debian/patches/9003-fix-path-to-hvmloader-in-testsuite.patch: adjust
    testsuite for 0001-fix-path-to-hvmloader.patch and
    0002-Fix-path-to-pygrub.patch. (refreshed)
  - debian/control: added acl package to depends.
  - Demote virt-viewer to Suggests, as it's in universe.
  - Recommends libvirt-bin
* Removed patches:
  - debian/patches/9002-libvirt_disk_format.patch: Upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/9002-libvirt_disk_format.patch/tests/xmlconfig.py
1
 
#
2
 
# This program is free software; you can redistribute it and/or modify
3
 
# it under the terms of the GNU General Public License as published by
4
 
# the Free  Software Foundation; either version 2 of the License, or
5
 
# (at your option)  any later version.
6
 
#
7
 
# This program is distributed in the hope that it will be useful,
8
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
# GNU General Public License for more details.
11
 
#
12
 
# You should have received a copy of the GNU General Public License
13
 
# along with this program; if not, write to the Free Software
14
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
15
 
# MA 02110-1301 USA.
16
 
 
17
 
import unittest
18
 
import os
19
 
import libvirt
20
 
import urlgrabber.progress as progress
21
 
 
22
 
import virtinst
23
 
from virtinst import VirtualDisk
24
 
from virtinst import VirtualAudio
25
 
from virtinst import VirtualNetworkInterface
26
 
from virtinst import VirtualHostDeviceUSB, VirtualHostDevicePCI
27
 
from virtinst import VirtualCharDevice
28
 
from virtinst import VirtualVideoDevice
29
 
from virtinst import VirtualController
30
 
from virtinst import VirtualWatchdog
31
 
import tests
32
 
 
33
 
conn = tests.open_testdriver()
34
 
 
35
 
def get_basic_paravirt_guest():
36
 
    g = virtinst.ParaVirtGuest(connection=conn, type="xen")
37
 
    g.name = "TestGuest"
38
 
    g.memory = int(200)
39
 
    g.maxmemory = int(400)
40
 
    g.uuid = "12345678-1234-1234-1234-123456789012"
41
 
    g.boot = ["/boot/vmlinuz","/boot/initrd"]
42
 
    g.graphics = (True, "vnc", None, "ja")
43
 
    g.vcpus = 5
44
 
    return g
45
 
 
46
 
def get_basic_fullyvirt_guest(typ="xen"):
47
 
    g = virtinst.FullVirtGuest(connection=conn, type=typ,
48
 
                               emulator="/usr/lib/xen/bin/qemu-dm",
49
 
                               arch="i686")
50
 
    g.name = "TestGuest"
51
 
    g.memory = int(200)
52
 
    g.maxmemory = int(400)
53
 
    g.uuid = "12345678-1234-1234-1234-123456789012"
54
 
    g.cdrom = "/dev/loop0"
55
 
    g.set_os_type("other")
56
 
    g.set_os_variant("generic")
57
 
    g.graphics = (True, "sdl")
58
 
    g.features['pae'] = 0
59
 
    g.vcpus = 5
60
 
    return g
61
 
 
62
 
def get_floppy(path="/default-pool/testvol1.img"):
63
 
    return VirtualDisk(path, conn=conn, device=VirtualDisk.DEVICE_FLOPPY)
64
 
 
65
 
def get_filedisk(path="/tmp/test.img"):
66
 
    return VirtualDisk(path, size=.0001, conn=conn)
67
 
 
68
 
def get_blkdisk():
69
 
    return VirtualDisk("/dev/loop0", conn=conn)
70
 
 
71
 
def get_virtual_network():
72
 
    dev = virtinst.VirtualNetworkInterface()
73
 
    dev.macaddr = "11:22:33:44:55:66"
74
 
    dev.type = virtinst.VirtualNetworkInterface.TYPE_VIRTUAL
75
 
    dev.network = "default"
76
 
    return dev
77
 
 
78
 
def qemu_uri():
79
 
    return "qemu:///system"
80
 
 
81
 
def xen_uri():
82
 
    return "xen:///"
83
 
 
84
 
class TestXMLConfig(unittest.TestCase):
85
 
 
86
 
    def _compare(self, xenguest, filebase, do_install, do_disk_boot=False):
87
 
        filename = os.path.join("tests/xmlconfig-xml", filebase + ".xml")
88
 
        xenguest._prepare_install(progress.BaseMeter())
89
 
        try:
90
 
            actualXML = xenguest.get_config_xml(install=do_install,
91
 
                                                disk_boot=do_disk_boot)
92
 
            tests.diff_compare(actualXML, filename)
93
 
            # Libvirt throws errors since we are defining domain
94
 
            # type='xen', when test driver can only handle type='test'
95
 
            # Sanitize the XML so we can define
96
 
            actualXML = actualXML.replace("<domain type='xen'>",
97
 
                                          "<domain type='test'>")
98
 
            actualXML = actualXML.replace(">linux<", ">xen<")
99
 
 
100
 
            # Should probably break this out into a separate function
101
 
            dom = xenguest.conn.defineXML(actualXML)
102
 
            dom.create()
103
 
            dom.destroy()
104
 
            dom.undefine()
105
 
        finally:
106
 
            xenguest._cleanup_install()
107
 
 
108
 
    def conn_function_wrappers(self, guest, filename, do_boot,
109
 
                               conn_version=None,
110
 
                               conn_uri=None,
111
 
                               libvirt_version=None,
112
 
                               do_disk_boot=False):
113
 
        testconn = guest.conn
114
 
 
115
 
        def set_func(newfunc, funcname, obj, force=False):
116
 
            if newfunc or force:
117
 
                orig = None
118
 
                if hasattr(obj, funcname):
119
 
                    orig = getattr(obj, funcname)
120
 
 
121
 
                setattr(obj, funcname, newfunc)
122
 
                return orig, True
123
 
 
124
 
            return None, False
125
 
 
126
 
        def set_version(newfunc, force=False):
127
 
            return set_func(newfunc, "getVersion", testconn, force)
128
 
        def set_uri(newfunc, force=False):
129
 
            return set_func(newfunc, "getURI", testconn, force)
130
 
        def set_libvirt_version(newfunc, force=False):
131
 
            return set_func(newfunc, "getVersion", libvirt, force)
132
 
 
133
 
        old_version = None
134
 
        old_uri = None
135
 
        old_libvirt_version = None
136
 
        try:
137
 
            old_version = set_version(conn_version)
138
 
            old_uri = set_uri(conn_uri)
139
 
            old_libvirt_version = set_libvirt_version(libvirt_version)
140
 
            self._compare(guest, filename, do_boot, do_disk_boot)
141
 
        finally:
142
 
            set_version(*old_version)
143
 
            set_uri(*old_uri)
144
 
            set_libvirt_version(*old_libvirt_version)
145
 
 
146
 
    def testBootParavirtDiskFile(self):
147
 
        g = get_basic_paravirt_guest()
148
 
        g.disks.append(get_filedisk())
149
 
        self._compare(g, "boot-paravirt-disk-file", False)
150
 
 
151
 
    def testBootParavirtDiskFileBlktapCapable(self):
152
 
        oldblktap = virtinst._util.is_blktap_capable
153
 
        try:
154
 
            virtinst._util.is_blktap_capable = lambda: True
155
 
            g = get_basic_paravirt_guest()
156
 
            g.disks.append(get_filedisk())
157
 
            self._compare(g, "boot-paravirt-disk-drv-tap", False)
158
 
        finally:
159
 
            virtinst._util.is_blktap_capable = oldblktap
160
 
 
161
 
    def testBootParavirtDiskBlock(self):
162
 
        g = get_basic_paravirt_guest()
163
 
        g.disks.append(get_blkdisk())
164
 
        self._compare(g, "boot-paravirt-disk-block", False)
165
 
 
166
 
    def testBootParavirtDiskDrvPhy(self):
167
 
        g = get_basic_paravirt_guest()
168
 
        disk = get_blkdisk()
169
 
        disk.driver_name = VirtualDisk.DRIVER_PHY
170
 
        g.disks.append(disk)
171
 
        self._compare(g, "boot-paravirt-disk-drv-phy", False)
172
 
 
173
 
    def testBootParavirtDiskDrvFile(self):
174
 
        g = get_basic_paravirt_guest()
175
 
        disk = get_filedisk()
176
 
        disk.driver_name = VirtualDisk.DRIVER_FILE
177
 
        g.disks.append(disk)
178
 
        self._compare(g, "boot-paravirt-disk-drv-file", False)
179
 
 
180
 
    def testBootParavirtDiskDrvTap(self):
181
 
        g = get_basic_paravirt_guest()
182
 
        disk = get_filedisk()
183
 
        disk.driver_name = VirtualDisk.DRIVER_TAP
184
 
        g.disks.append(disk)
185
 
        self._compare(g, "boot-paravirt-disk-drv-tap", False)
186
 
 
187
 
    def testBootParavirtDiskDrvTapQCow(self):
188
 
        g = get_basic_paravirt_guest()
189
 
        disk = get_filedisk()
190
 
        disk.driver_name = VirtualDisk.DRIVER_TAP
191
 
        disk.driver_type = VirtualDisk.DRIVER_TAP_QCOW
192
 
        g.disks.append(disk)
193
 
        self._compare(g, "boot-paravirt-disk-drv-tap-qcow", False)
194
 
 
195
 
    def testBootParavirtManyDisks(self):
196
 
        g = get_basic_paravirt_guest()
197
 
        disk = get_filedisk("/tmp/test2.img")
198
 
        disk.driver_name = VirtualDisk.DRIVER_TAP
199
 
        disk.driver_type = VirtualDisk.DRIVER_TAP_QCOW
200
 
 
201
 
        g.disks.append(get_filedisk("/tmp/test1.img"))
202
 
        g.disks.append(disk)
203
 
        g.disks.append(get_blkdisk())
204
 
        self._compare(g, "boot-paravirt-many-disks", False)
205
 
 
206
 
    def testBootFullyvirtDiskFile(self):
207
 
        g = get_basic_fullyvirt_guest()
208
 
        g.disks.append(get_filedisk())
209
 
        self._compare(g, "boot-fullyvirt-disk-file", False)
210
 
 
211
 
    def testBootFullyvirtDiskBlock(self):
212
 
        g = get_basic_fullyvirt_guest()
213
 
        g.disks.append(get_blkdisk())
214
 
        self._compare(g, "boot-fullyvirt-disk-block", False)
215
 
 
216
 
 
217
 
 
218
 
 
219
 
    def testInstallParavirtDiskFile(self):
220
 
        g = get_basic_paravirt_guest()
221
 
        g.disks.append(get_filedisk())
222
 
        self._compare(g, "install-paravirt-disk-file", True)
223
 
 
224
 
    def testInstallParavirtDiskBlock(self):
225
 
        g = get_basic_paravirt_guest()
226
 
        g.disks.append(get_blkdisk())
227
 
        self._compare(g, "install-paravirt-disk-block", True)
228
 
 
229
 
    def testInstallParavirtDiskDrvPhy(self):
230
 
        g = get_basic_paravirt_guest()
231
 
        disk = get_blkdisk()
232
 
        disk.driver_name = VirtualDisk.DRIVER_PHY
233
 
        g.disks.append(disk)
234
 
        self._compare(g, "install-paravirt-disk-drv-phy", True)
235
 
 
236
 
    def testInstallParavirtDiskDrvFile(self):
237
 
        g = get_basic_paravirt_guest()
238
 
        disk = get_filedisk()
239
 
        disk.driver_name = VirtualDisk.DRIVER_FILE
240
 
        g.disks.append(disk)
241
 
        self._compare(g, "install-paravirt-disk-drv-file", True)
242
 
 
243
 
    def testInstallParavirtDiskDrvTap(self):
244
 
        g = get_basic_paravirt_guest()
245
 
        disk = get_filedisk()
246
 
        disk.driver_name = VirtualDisk.DRIVER_TAP
247
 
        g.disks.append(disk)
248
 
        self._compare(g, "install-paravirt-disk-drv-tap", True)
249
 
 
250
 
    def testInstallParavirtDiskDrvTapQCow(self):
251
 
        g = get_basic_paravirt_guest()
252
 
        disk = get_filedisk()
253
 
        disk.driver_name = VirtualDisk.DRIVER_TAP
254
 
        disk.driver_type = VirtualDisk.DRIVER_TAP_QCOW
255
 
        g.disks.append(disk)
256
 
        self._compare(g, "install-paravirt-disk-drv-tap-qcow", True)
257
 
 
258
 
    def testInstallParavirtManyDisks(self):
259
 
        g = get_basic_paravirt_guest()
260
 
        disk = get_filedisk("/tmp/test2.img")
261
 
        disk.driver_name = VirtualDisk.DRIVER_TAP
262
 
        disk.driver_type = VirtualDisk.DRIVER_TAP_QCOW
263
 
 
264
 
        g.disks.append(get_filedisk("/tmp/test1.img"))
265
 
        g.disks.append(disk)
266
 
        g.disks.append(get_blkdisk())
267
 
        self._compare(g, "install-paravirt-many-disks", True)
268
 
 
269
 
    def testInstallFullyvirtDiskFile(self):
270
 
        g = get_basic_fullyvirt_guest()
271
 
        g.disks.append(get_filedisk())
272
 
        self._compare(g, "install-fullyvirt-disk-file", True)
273
 
 
274
 
    def testInstallFullyvirtDiskBlock(self):
275
 
        g = get_basic_fullyvirt_guest()
276
 
        g.disks.append(get_blkdisk())
277
 
        self._compare(g, "install-fullyvirt-disk-block", True)
278
 
 
279
 
    def testInstallFVPXE(self):
280
 
        g = get_basic_fullyvirt_guest()
281
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
282
 
                                            conn=g.conn)
283
 
        g.disks.append(get_filedisk())
284
 
        self._compare(g, "install-fullyvirt-pxe", True)
285
 
 
286
 
    def testBootFVPXE(self):
287
 
        g = get_basic_fullyvirt_guest()
288
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
289
 
                                            conn=g.conn)
290
 
        g.disks.append(get_filedisk())
291
 
        self._compare(g, "boot-fullyvirt-pxe", False)
292
 
 
293
 
    def testInstallFVPXENoDisks(self):
294
 
        g = get_basic_fullyvirt_guest()
295
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
296
 
                                            conn=g.conn)
297
 
        self._compare(g, "install-fullyvirt-pxe-nodisks", True)
298
 
 
299
 
    def testBootFVPXENoDisks(self):
300
 
        g = get_basic_fullyvirt_guest()
301
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
302
 
                                            conn=g.conn)
303
 
        self._compare(g, "boot-fullyvirt-pxe-nodisks", False)
304
 
 
305
 
    def testInstallFVLiveCD(self):
306
 
        g = get_basic_fullyvirt_guest()
307
 
        g.installer = virtinst.LiveCDInstaller(type="xen", os_type="hvm",
308
 
                                               conn=g.conn,
309
 
                                               location="/dev/loop0")
310
 
        self._compare(g, "install-fullyvirt-livecd", False)
311
 
 
312
 
    def testDoubleInstall(self):
313
 
        # Make sure that installing twice generates the same XML, to ensure
314
 
        # we aren't polluting the device list during the install process
315
 
        g = get_basic_fullyvirt_guest()
316
 
        g.installer = virtinst.LiveCDInstaller(type="xen", os_type="hvm",
317
 
                                               conn=g.conn,
318
 
                                               location="/dev/loop0")
319
 
        self._compare(g, "install-fullyvirt-livecd", False)
320
 
        self._compare(g, "install-fullyvirt-livecd", False)
321
 
 
322
 
 
323
 
    def testInstallFVImport(self):
324
 
        g = get_basic_fullyvirt_guest()
325
 
        g.disks.append(get_filedisk())
326
 
        g.installer = virtinst.ImportInstaller(type="xen", os_type="hvm",
327
 
                                               conn=g.conn)
328
 
        self._compare(g, "install-fullyvirt-import", False)
329
 
 
330
 
    def testInstallPVImport(self):
331
 
        g = get_basic_paravirt_guest()
332
 
        g.disks.append(get_filedisk())
333
 
        g.installer = virtinst.ImportInstaller(type="xen", os_type="xen",
334
 
                                               conn=g.conn)
335
 
        self._compare(g, "install-paravirt-import", False)
336
 
 
337
 
    def testQEMUDriverName(self):
338
 
        g = get_basic_fullyvirt_guest()
339
 
        g.disks.append(get_blkdisk())
340
 
        self.conn_function_wrappers(g, "misc-qemu-driver-name", True,
341
 
                                    conn_uri=qemu_uri)
342
 
 
343
 
        g = get_basic_fullyvirt_guest()
344
 
        g.disks.append(get_filedisk())
345
 
        self.conn_function_wrappers(g, "misc-qemu-driver-type", True,
346
 
                                    conn_uri=qemu_uri)
347
 
 
348
 
        g = get_basic_fullyvirt_guest()
349
 
        g.disks.append(get_filedisk("/default-pool/iso-vol"))
350
 
        self.conn_function_wrappers(g, "misc-qemu-iso-disk", True,
351
 
                                    conn_uri=qemu_uri)
352
 
 
353
 
    def testXMLEscaping(self):
354
 
        g = get_basic_fullyvirt_guest()
355
 
        g.disks.append(get_filedisk("/tmp/ISO&'&s"))
356
 
        self._compare(g, "misc-xml-escaping", True)
357
 
 
358
 
    # OS Type/Version configurations
359
 
    def testF10(self):
360
 
        g = get_basic_fullyvirt_guest("kvm")
361
 
        g.os_type = "linux"
362
 
        g.os_variant = "fedora10"
363
 
        g.installer = virtinst.PXEInstaller(type="kvm", os_type="hvm",
364
 
                                            conn=g.conn)
365
 
        g.disks.append(get_filedisk())
366
 
        g.disks.append(get_blkdisk())
367
 
        g.nics.append(get_virtual_network())
368
 
        self.conn_function_wrappers(g, "install-f10", True,
369
 
                                    conn_uri=qemu_uri)
370
 
 
371
 
    def testF11(self):
372
 
        g = get_basic_fullyvirt_guest("kvm")
373
 
        g.os_type = "linux"
374
 
        g.os_variant = "fedora11"
375
 
        g.installer = virtinst.DistroInstaller(type="kvm", os_type="hvm",
376
 
                                               conn=g.conn,
377
 
                                               location="/default-pool/default-vol")
378
 
        g.installer.cdrom = True
379
 
        g.disks.append(get_floppy())
380
 
        g.disks.append(get_filedisk())
381
 
        g.disks.append(get_blkdisk())
382
 
        g.nics.append(get_virtual_network())
383
 
        self.conn_function_wrappers(g, "install-f11", False,
384
 
                                    conn_uri=qemu_uri)
385
 
 
386
 
    def testF11AC97(self):
387
 
        def build_guest():
388
 
            g = get_basic_fullyvirt_guest("kvm")
389
 
            g.os_type = "linux"
390
 
            g.os_variant = "fedora11"
391
 
            g.installer = virtinst.DistroInstaller(type="kvm", os_type="hvm",
392
 
                            conn=g.conn, location="/default-pool/default-vol")
393
 
            g.installer.cdrom = True
394
 
            g.disks.append(get_floppy())
395
 
            g.disks.append(get_filedisk())
396
 
            g.disks.append(get_blkdisk())
397
 
            g.nics.append(get_virtual_network())
398
 
            g.add_device(VirtualAudio())
399
 
            return g
400
 
 
401
 
        def libvirt_nosupport_ac97(drv=None):
402
 
            libver = 5000
403
 
            if drv:
404
 
                return (libver, libver)
405
 
            return libver
406
 
 
407
 
        def conn_nosupport_ac97():
408
 
            return 10000
409
 
 
410
 
        def conn_support_ac97():
411
 
            return 11000
412
 
 
413
 
        g = build_guest()
414
 
        self.conn_function_wrappers(g, "install-f11-ac97", False,
415
 
                                    conn_uri=qemu_uri,
416
 
                                    conn_version=conn_support_ac97)
417
 
 
418
 
        g = build_guest()
419
 
        self.conn_function_wrappers(g, "install-f11-noac97", False,
420
 
                                    libvirt_version=libvirt_nosupport_ac97,
421
 
                                    conn_uri=qemu_uri)
422
 
 
423
 
        g = build_guest()
424
 
        self.conn_function_wrappers(g, "install-f11-noac97", False,
425
 
                                    conn_version=conn_nosupport_ac97,
426
 
                                    conn_uri=qemu_uri)
427
 
 
428
 
 
429
 
    def testF11Qemu(self):
430
 
        g = get_basic_fullyvirt_guest("qemu")
431
 
        g.os_type = "linux"
432
 
        g.os_variant = "fedora11"
433
 
        g.installer = virtinst.DistroInstaller(type="qemu", os_type="hvm",
434
 
                                               conn=g.conn,
435
 
                                               location="/default-pool/default-vol")
436
 
        g.installer.cdrom = True
437
 
        g.disks.append(get_floppy())
438
 
        g.disks.append(get_filedisk())
439
 
        g.disks.append(get_blkdisk())
440
 
        g.nics.append(get_virtual_network())
441
 
        self.conn_function_wrappers(g, "install-f11-qemu", False,
442
 
                                    conn_uri=qemu_uri)
443
 
 
444
 
    def testF11Xen(self):
445
 
        g = get_basic_fullyvirt_guest("xen")
446
 
        g.os_type = "linux"
447
 
        g.os_variant = "fedora11"
448
 
        g.installer = virtinst.DistroInstaller(type="xen", os_type="hvm",
449
 
                                               conn=g.conn,
450
 
                                               location="/default-pool/default-vol")
451
 
        g.installer.cdrom = True
452
 
        g.disks.append(get_floppy())
453
 
        g.disks.append(get_filedisk())
454
 
        g.disks.append(get_blkdisk())
455
 
        g.nics.append(get_virtual_network())
456
 
        self.conn_function_wrappers(g, "install-f11-xen", False,
457
 
                                    conn_uri=xen_uri)
458
 
 
459
 
    def _build_win_kvm(self):
460
 
        g = get_basic_fullyvirt_guest("kvm")
461
 
        g.os_type = "windows"
462
 
        g.os_variant = "winxp"
463
 
        g.disks.append(get_filedisk())
464
 
        g.disks.append(get_blkdisk())
465
 
        g.nics.append(get_virtual_network())
466
 
        g.add_device(VirtualAudio())
467
 
        g.add_device(VirtualVideoDevice(g.conn))
468
 
 
469
 
        return g
470
 
 
471
 
    def testInstallWindowsKVM(self):
472
 
        g = self._build_win_kvm()
473
 
        self.conn_function_wrappers(g, "winxp-kvm-stage1", True,
474
 
                                    conn_uri=qemu_uri)
475
 
 
476
 
    def testContinueWindowsKVM(self):
477
 
        g = self._build_win_kvm()
478
 
        self.conn_function_wrappers(g, "winxp-kvm-stage2", True,
479
 
                                    conn_uri=qemu_uri,
480
 
                                    do_disk_boot=True)
481
 
 
482
 
    def testBootWindowsKVM(self):
483
 
        g = self._build_win_kvm()
484
 
        self.conn_function_wrappers(g, "winxp-kvm-stage3", False,
485
 
                                    conn_uri=qemu_uri)
486
 
 
487
 
 
488
 
    def testInstallWindowsXenNew(self):
489
 
        def old_xen_ver():
490
 
            return 3000001
491
 
 
492
 
        def new_xen_ver():
493
 
            return 3100000
494
 
 
495
 
 
496
 
        g = get_basic_fullyvirt_guest("xen")
497
 
        g.os_type = "windows"
498
 
        g.os_variant = "winxp"
499
 
        g.disks.append(get_filedisk())
500
 
        g.disks.append(get_blkdisk())
501
 
        g.nics.append(get_virtual_network())
502
 
        g.add_device(VirtualAudio())
503
 
 
504
 
        for f, xml in [(old_xen_ver, "install-windowsxp-xenold"),
505
 
                       (new_xen_ver, "install-windowsxp-xennew")]:
506
 
 
507
 
            self.conn_function_wrappers(g, xml, True,
508
 
                                        conn_version=f,
509
 
                                        conn_uri=xen_uri)
510
 
 
511
 
 
512
 
    # Device heavy configurations
513
 
    def testManyDisks2(self):
514
 
        g = get_basic_fullyvirt_guest()
515
 
        g.disks.append(get_filedisk())
516
 
        g.disks.append(get_blkdisk())
517
 
        g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
518
 
                                   device=VirtualDisk.DEVICE_CDROM))
519
 
        g.disks.append(VirtualDisk(conn=g.conn, path=None,
520
 
                                   device=VirtualDisk.DEVICE_CDROM,
521
 
                                   bus="scsi"))
522
 
        g.disks.append(VirtualDisk(conn=g.conn, path=None,
523
 
                                   device=VirtualDisk.DEVICE_FLOPPY))
524
 
        g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
525
 
                                   device=VirtualDisk.DEVICE_FLOPPY))
526
 
        g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
527
 
                                   bus="virtio"))
528
 
 
529
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
530
 
                                            conn=g.conn)
531
 
        self._compare(g, "boot-many-disks2", False)
532
 
 
533
 
    def testManyNICs(self):
534
 
        g = get_basic_fullyvirt_guest()
535
 
        net1 = VirtualNetworkInterface(type="user",
536
 
                                       macaddr="11:11:11:11:11:11")
537
 
        net2 = get_virtual_network()
538
 
        net3 = get_virtual_network()
539
 
        net3.model = "e1000"
540
 
        net4 = VirtualNetworkInterface(bridge="foobr0",
541
 
                                       macaddr="22:22:22:22:22:22")
542
 
 
543
 
        g.nics.append(net1)
544
 
        g.nics.append(net2)
545
 
        g.nics.append(net3)
546
 
        g.nics.append(net4)
547
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
548
 
                                            conn=g.conn)
549
 
        self._compare(g, "boot-many-nics", False)
550
 
 
551
 
    def testManyHostdevs(self):
552
 
        g = get_basic_fullyvirt_guest()
553
 
        dev1 = VirtualHostDeviceUSB(g.conn)
554
 
        dev1.product = "0x1234"
555
 
        dev1.vendor = "0x4321"
556
 
 
557
 
        dev2 = VirtualHostDevicePCI(g.conn)
558
 
        dev2.bus = "0x11"
559
 
        dev2.slot = "0x22"
560
 
        dev2.function = "0x33"
561
 
 
562
 
        g.hostdevs.append(dev1)
563
 
        g.hostdevs.append(dev2)
564
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
565
 
                                            conn=g.conn)
566
 
        self._compare(g, "boot-many-hostdevs", False)
567
 
 
568
 
    def testManySounds(self):
569
 
        g = get_basic_fullyvirt_guest()
570
 
        g.sound_devs.append(VirtualAudio("sb16", conn=g.conn))
571
 
        g.sound_devs.append(VirtualAudio("es1370", conn=g.conn))
572
 
        g.sound_devs.append(VirtualAudio("pcspk", conn=g.conn))
573
 
        g.sound_devs.append(VirtualAudio(conn=g.conn))
574
 
 
575
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
576
 
                                            conn=g.conn)
577
 
        self._compare(g, "boot-many-sounds", False)
578
 
 
579
 
    def testManyChars(self):
580
 
        g = get_basic_fullyvirt_guest()
581
 
        dev1 = VirtualCharDevice.get_dev_instance(g.conn,
582
 
                                                  VirtualCharDevice.DEV_SERIAL,
583
 
                                                  VirtualCharDevice.CHAR_NULL)
584
 
        dev2 = VirtualCharDevice.get_dev_instance(g.conn,
585
 
                                                  VirtualCharDevice.DEV_PARALLEL,
586
 
                                                  VirtualCharDevice.CHAR_UNIX)
587
 
        dev2.source_path = "/tmp/foobar"
588
 
        dev3 = VirtualCharDevice.get_dev_instance(g.conn,
589
 
                                                  VirtualCharDevice.DEV_SERIAL,
590
 
                                                  VirtualCharDevice.CHAR_TCP)
591
 
        dev3.protocol = "telnet"
592
 
        dev3.source_host = "my.source.host"
593
 
        dev3.source_port = "1234"
594
 
        dev4 = VirtualCharDevice.get_dev_instance(g.conn,
595
 
                                                  VirtualCharDevice.DEV_PARALLEL,
596
 
                                                  VirtualCharDevice.CHAR_UDP)
597
 
        dev4.bind_host = "my.bind.host"
598
 
        dev4.bind_port = "1111"
599
 
        dev4.source_host = "my.source.host"
600
 
        dev4.source_port = "2222"
601
 
 
602
 
        g.add_device(dev1)
603
 
        g.add_device(dev2)
604
 
        g.add_device(dev3)
605
 
        g.add_device(dev4)
606
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
607
 
                                            conn=g.conn)
608
 
        self._compare(g, "boot-many-chars", False)
609
 
 
610
 
    def testManyDevices(self):
611
 
        g = get_basic_fullyvirt_guest()
612
 
        g.description = "foooo barrrr \n baz && snarf. '' \"\" @@$\n"
613
 
 
614
 
        # Hostdevs
615
 
        dev1 = VirtualHostDeviceUSB(g.conn)
616
 
        dev1.product = "0x1234"
617
 
        dev1.vendor = "0x4321"
618
 
        g.hostdevs.append(dev1)
619
 
 
620
 
        # Sound devices
621
 
        g.sound_devs.append(VirtualAudio("sb16", conn=g.conn))
622
 
        g.sound_devs.append(VirtualAudio("es1370", conn=g.conn))
623
 
 
624
 
        # Disk devices
625
 
        g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
626
 
                                   device=VirtualDisk.DEVICE_FLOPPY))
627
 
        g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
628
 
                                   bus="scsi"))
629
 
        g.disks.append(VirtualDisk(conn=g.conn, path="/tmp", device="floppy"))
630
 
        d3 = VirtualDisk(conn=g.conn, path="/default-pool/testvol1.img",
631
 
                         bus="scsi", driverName="qemu")
632
 
        g.disks.append(d3)
633
 
 
634
 
        # Controller devices
635
 
        c1 = VirtualController.get_class_for_type(VirtualController.CONTROLLER_TYPE_IDE)(g.conn)
636
 
        c1.index = "3"
637
 
        c2 = VirtualController.get_class_for_type(VirtualController.CONTROLLER_TYPE_VIRTIOSERIAL)(g.conn)
638
 
        c2.ports = "32"
639
 
        c2.vectors = "17"
640
 
        g.add_device(c1)
641
 
        g.add_device(c2)
642
 
 
643
 
        # Network devices
644
 
        net1 = get_virtual_network()
645
 
        net1.model = "e1000"
646
 
        net2 = VirtualNetworkInterface(type="user",
647
 
                                       macaddr="11:11:11:11:11:11")
648
 
        g.nics.append(net1)
649
 
        g.nics.append(net2)
650
 
 
651
 
        # Character devices
652
 
        cdev1 = VirtualCharDevice.get_dev_instance(g.conn,
653
 
                                                   VirtualCharDevice.DEV_SERIAL,
654
 
                                                   VirtualCharDevice.CHAR_NULL)
655
 
        cdev2 = VirtualCharDevice.get_dev_instance(g.conn,
656
 
                                                   VirtualCharDevice.DEV_PARALLEL,
657
 
                                                   VirtualCharDevice.CHAR_UNIX)
658
 
        cdev2.source_path = "/tmp/foobar"
659
 
        g.add_device(cdev1)
660
 
        g.add_device(cdev2)
661
 
 
662
 
        # Video Devices
663
 
        vdev1 = VirtualVideoDevice(g.conn)
664
 
        vdev1.model_type = "vmvga"
665
 
 
666
 
        vdev2 = VirtualVideoDevice(g.conn)
667
 
        vdev2.model_type = "cirrus"
668
 
        vdev2.vram = 10 * 1024
669
 
        vdev2.heads = 3
670
 
 
671
 
        vdev3 = VirtualVideoDevice(g.conn)
672
 
        g.add_device(vdev1)
673
 
        g.add_device(vdev2)
674
 
        g.add_device(vdev3)
675
 
 
676
 
        wdev2 = VirtualWatchdog(g.conn)
677
 
        wdev2.model = "ib700"
678
 
        wdev2.action = "none"
679
 
        g.add_device(wdev2)
680
 
 
681
 
        g.clock.offset = "localtime"
682
 
 
683
 
        seclabel = virtinst.Seclabel(g.conn)
684
 
        seclabel.type = seclabel.SECLABEL_TYPE_STATIC
685
 
        seclabel.model = "selinux"
686
 
        seclabel.label = "foolabel"
687
 
        seclabel.imagelabel = "imagelabel"
688
 
        g.seclabel = seclabel
689
 
 
690
 
        g.installer = virtinst.PXEInstaller(type="xen", os_type="hvm",
691
 
                                            conn=g.conn)
692
 
        self._compare(g, "boot-many-devices", False)
693
 
 
694
 
if __name__ == "__main__":
695
 
    unittest.main()