def disk_prompt(prompt_txt, arg_dict, warn_overwrite=False, prompt_size=True,
path_to_clone=None):
retry_path = True
conn = arg_dict.get("conn")
passed_path = arg_dict.get("path")
size = arg_dict.get("size")
no_path_needed = (bool(arg_dict.get("volInstall")) or
bool(arg_dict.get("volName")))
while 1:
if not retry_path:
passed_path = None
size = None
retry_path = False
msg = None
patherr = _("A disk path must be specified.")
if path_to_clone:
patherr = (_("A disk path must be specified to clone '%s'.") %
path_to_clone)
if not prompt_txt:
msg = _("What would you like to use as the disk (file path)?")
if not size is None:
msg = _("Please enter the path to the file you would like to "
"use for storage. It will have size %sGB.") %(size,)
if not no_path_needed:
path = prompt_for_input(patherr, prompt_txt or msg, passed_path)
else:
path = None
arg_dict["path"] = path
sizeerr = _("A size must be specified for non-existent disks.")
if path and not size and prompt_size:
size_prompt = _("How large would you like the disk (%s) to "
"be (in gigabytes)?") % path
try:
if not VirtualDisk.path_exists(conn, path):
size = prompt_loop(size_prompt, sizeerr, size, None, None,
func=float)
except Exception, e:
# Path is probably bogus, raise the error
logging.error(str(e))
continue
arg_dict["size"] = size
# Build disk object for validation
try:
dev = VirtualDisk(**arg_dict)
except ValueError, e:
if is_prompt():
logging.error(e)
continue
else:
fail(_("Error with storage parameters: %s" % str(e)))
def get_floppy(path=None):
if not path:
path = "/dev/default-pool/testvol1.img"
d = VirtualDisk(_conn)
d.path = path
d.device = d.DEVICE_FLOPPY
d.validate()
return d
def testManyVirtio(self):
d = VirtualDisk(conn=utils.get_conn(), bus="virtio",
path="/default-pool/testvol1.img")
targetlist = []
for ignore in range(0, (26 * 2) + 1):
d.target = None
d.generate_target(targetlist)
targetlist.append(d.target)
self.assertEquals("vdaa", targetlist[26])
self.assertEquals("vdba", targetlist[26 * 2])
def testManyDisks2(self):
i = utils.make_pxe_installer()
g = utils.get_basic_fullyvirt_guest(installer=i)
g.disks.append(utils.get_filedisk())
g.disks.append(utils.get_blkdisk())
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
device=VirtualDisk.DEVICE_CDROM,
driverType="raw"))
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
device=VirtualDisk.DEVICE_DISK,
driverName="qemu", format="qcow2"))
g.disks.append(VirtualDisk(conn=g.conn, path=None,
device=VirtualDisk.DEVICE_CDROM,
bus="scsi"))
g.disks.append(VirtualDisk(conn=g.conn, path=None,
device=VirtualDisk.DEVICE_FLOPPY))
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
device=VirtualDisk.DEVICE_FLOPPY,
driverName="phy", driverCache="none"))
disk = VirtualDisk(conn=g.conn, path="/dev/loop0",
bus="virtio", driverName="qemu",
driverType="qcow2", driverCache="none")
disk.driver_io = "threads"
g.disks.append(disk)
self._compare(g, "boot-many-disks2", False)
def _make_disks(self):
for drive in self.boot_caps.drives:
path = self.image.abspath(drive.disk.file)
size = None
if drive.disk.size is not None:
size = float(drive.disk.size) / 1024
# FIXME: This is awkward; the image should be able to express
# whether the disk is expected to be there or not independently
# of its classification, especially for user disks
# FIXME: We ignore the target for the mapping in m.target
if (drive.disk.use == Disk.USE_SYSTEM and
not os.path.exists(path)):
raise RuntimeError(_("System disk %s does not exist") % path)
device = VirtualDisk.DEVICE_DISK
if drive.disk.format == Disk.FORMAT_ISO:
device = VirtualDisk.DEVICE_CDROM
disk = VirtualDisk(self.conn)
disk.path = path
disk.device = device
disk.target = drive.target
disk.set_create_storage(size=size, fmt=drive.disk.format)
disk.validate()
self.install_devices.append(disk)
def check_path_search_for_qemu(parent, conn, path):
set_error_parent(parent)
if conn.is_remote() or not conn.is_qemu_system():
return
user = util.running_config.default_qemu_user
skip_paths = util.running_config.get_perms_fix_ignore()
broken_paths = VirtualDisk.check_path_search_for_user(conn.vmm, path, user)
for p in broken_paths:
if p in skip_paths:
broken_paths.remove(p)
if not broken_paths:
return
logging.debug("No search access for dirs: %s", broken_paths)
resp, chkres = err_dial.warn_chkbox(
_("The emulator may not have search permissions "
"for the path '%s'.") % path,
_("Do you want to correct this now?"),
_("Don't ask about these directories again."),
buttons=gtk.BUTTONS_YES_NO)
if chkres:
util.running_config.add_perms_fix_ignore(broken_paths)
if not resp:
return
logging.debug("Attempting to correct permission issues.")
errors = VirtualDisk.fix_path_search_for_user(conn.vmm, path, user)
if not errors:
return
errmsg = _("Errors were encountered changing permissions for the "
"following directories:")
details = ""
for path, error in errors.items():
if path not in broken_paths:
continue
details += "%s : %s\n" % (path, error)
logging.debug("Permission errors:\n%s", details)
ignore, chkres = err_dial.err_chkbox(errmsg, details,
_("Don't ask about these directories again."))
if chkres:
util.running_config.add_perms_fix_ignore(errors.keys())
def populate_storage_volumes(self):
pool = self.current_pool()
model = self.widget("vol-list").get_model()
model.clear()
vols = pool.get_volumes()
for key in vols.keys():
vol = vols[key]
try:
path = vol.get_target_path()
name = vol.get_name()
cap = vol.get_pretty_capacity()
fmt = vol.get_format() or ""
except:
logging.debug(
"Error getting volume info for '%s', "
"hiding it",
key,
exc_info=True)
continue
namestr = None
try:
if path:
names = VirtualDisk.path_in_use_by(self.conn.vmm, path)
namestr = ", ".join(names)
if not namestr:
namestr = None
except:
logging.exception("Failed to determine if storage volume in "
"use.")
model.append([key, name, cap, fmt, namestr])
def ok(self, ignore1=None, ignore2=None):
if self.widget("iso-image").get_active():
path = self.widget("iso-path").get_text()
else:
path = self.mediacombo.get_path()
if path == "" or path is None:
return self.err.val_err(_("Invalid Media Path"),
_("A media path must be specified."))
names = VirtualDisk.path_in_use_by(self.disk.conn, path)
if names:
res = self.err.yes_no(
_('Disk "%s" is already in use by other guests %s') %
(path, names),
_("Do you really want to use the disk?"))
if not res:
return False
vmmAddStorage.check_path_search(self, self.conn, path)
try:
self.disk.path = path
except Exception as e:
return self.err.val_err(_("Invalid Media Path"), e)
self.emit("cdrom-chosen", self.disk, path)
self.close()
def testCreateDisk(self):
"""
Doesn't really belong here, but what the hell :)
"""
path = "/tmp/__virtinst_create_test__.img"
sizegigs = .001
sizebytes = long(sizegigs * 1024L * 1024L * 1024L)
for sparse in [True, False]:
disk = VirtualDisk(conn=utils.get_conn(), path=path, size=sizegigs,
sparse=sparse)
disk.setup()
actualsize = long(os.path.getsize(path))
os.unlink(path)
self.assertEquals(sizebytes, actualsize)
def populate_storage_volumes(list_widget, pool, sensitive_cb):
vols = pool and pool.get_volumes() or {}
model = list_widget.get_model()
model.clear()
for key in vols.keys():
vol = vols[key]
try:
path = vol.get_target_path()
name = vol.get_pretty_name(pool.get_type())
cap = vol.get_pretty_capacity()
fmt = vol.get_format() or ""
except:
logging.debug("Error getting volume info for '%s', "
"hiding it", key, exc_info=True)
continue
namestr = None
try:
if path:
names = VirtualDisk.path_in_use_by(vol.conn.get_backend(),
path)
namestr = ", ".join(names)
if not namestr:
namestr = None
except:
logging.exception("Failed to determine if storage volume in "
"use.")
row = [key, name, cap, fmt, namestr]
if sensitive_cb:
row.append(sensitive_cb(fmt))
model.append(row)
def populate_storage_volumes(self):
pool = self.current_pool()
model = self.widget("vol-list").get_model()
model.clear()
vols = pool.get_volumes()
for key in vols.keys():
vol = vols[key]
try:
path = vol.get_target_path()
name = vol.get_name()
cap = vol.get_pretty_capacity()
fmt = vol.get_format() or ""
except:
logging.debug("Error getting volume info for '%s', "
"hiding it", key, exc_info=True)
continue
namestr = None
try:
if path:
names = VirtualDisk.path_in_use_by(self.conn.vmm, path)
namestr = ", ".join(names)
if not namestr:
namestr = None
except:
logging.exception("Failed to determine if storage volume in "
"use.")
model.append([key, name, cap, fmt, namestr])
def _populate_vols(self):
list_widget = self.widget("vol-list")
pool = self._current_pool()
vols = pool and pool.get_volumes() or []
model = list_widget.get_model()
list_widget.get_selection().unselect_all()
model.clear()
vadj = self.widget("vol-scroll").get_vadjustment()
vscroll_percent = vadj.get_value() / max(vadj.get_upper(), 1)
for vol in vols:
key = vol.get_connkey()
try:
path = vol.get_target_path()
name = vol.get_pretty_name(pool.get_type())
cap = str(vol.get_capacity())
sizestr = vol.get_pretty_capacity()
fmt = vol.get_format() or ""
except:
logging.debug(
"Error getting volume info for '%s', "
"hiding it",
key,
exc_info=True)
continue
namestr = None
try:
if path:
names = VirtualDisk.path_in_use_by(vol.conn.get_backend(),
path)
namestr = ", ".join(names)
if not namestr:
namestr = None
except:
logging.exception("Failed to determine if storage volume in "
"use.")
sensitive = True
if self._vol_sensitive_cb:
sensitive = self._vol_sensitive_cb(fmt)
row = [None] * VOL_NUM_COLUMNS
row[VOL_COLUMN_KEY] = key
row[VOL_COLUMN_NAME] = name
row[VOL_COLUMN_SIZESTR] = sizestr
row[VOL_COLUMN_CAPACITY] = cap
row[VOL_COLUMN_FORMAT] = fmt
row[VOL_COLUMN_INUSEBY] = namestr
row[VOL_COLUMN_SENSITIVE] = sensitive
model.append(row)
def _reset_vscroll_position():
vadj.set_value(vadj.get_upper() * vscroll_percent)
self.idle_add(_reset_vscroll_position)
def testManyDisks2(self):
i = make_pxe_installer()
g = get_basic_fullyvirt_guest(installer=i)
g.disks.append(get_filedisk())
g.disks.append(get_blkdisk())
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
device=VirtualDisk.DEVICE_CDROM))
g.disks.append(VirtualDisk(conn=g.conn, path=None,
device=VirtualDisk.DEVICE_CDROM,
bus="scsi"))
g.disks.append(VirtualDisk(conn=g.conn, path=None,
device=VirtualDisk.DEVICE_FLOPPY))
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
device=VirtualDisk.DEVICE_FLOPPY))
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
bus="virtio"))
self._compare(g, "boot-many-disks2", False)
def _populate_vols(self):
list_widget = self.widget("vol-list")
pool = self._current_pool()
vols = pool and pool.get_volumes() or []
model = list_widget.get_model()
list_widget.get_selection().unselect_all()
model.clear()
vadj = self.widget("vol-scroll").get_vadjustment()
vscroll_percent = vadj.get_value() / max(vadj.get_upper(), 1)
for vol in vols:
key = vol.get_connkey()
try:
path = vol.get_target_path()
name = vol.get_pretty_name(pool.get_type())
cap = str(vol.get_capacity())
sizestr = vol.get_pretty_capacity()
fmt = vol.get_format() or ""
except:
logging.debug("Error getting volume info for '%s', "
"hiding it", key, exc_info=True)
continue
namestr = None
try:
if path:
names = VirtualDisk.path_in_use_by(vol.conn.get_backend(),
path)
namestr = ", ".join(names)
if not namestr:
namestr = None
except:
logging.exception("Failed to determine if storage volume in "
"use.")
sensitive = True
if self._vol_sensitive_cb:
sensitive = self._vol_sensitive_cb(fmt)
row = [None] * VOL_NUM_COLUMNS
row[VOL_COLUMN_KEY] = key
row[VOL_COLUMN_NAME] = name
row[VOL_COLUMN_SIZESTR] = sizestr
row[VOL_COLUMN_CAPACITY] = cap
row[VOL_COLUMN_FORMAT] = fmt
row[VOL_COLUMN_INUSEBY] = namestr
row[VOL_COLUMN_SENSITIVE] = sensitive
model.append(row)
def _reset_vscroll_position():
vadj.set_value(vadj.get_upper() * vscroll_percent)
self.idle_add(_reset_vscroll_position)
def testDiskNumbers(self):
self.assertEquals("a", VirtualDisk.num_to_target(1))
self.assertEquals("b", VirtualDisk.num_to_target(2))
self.assertEquals("z", VirtualDisk.num_to_target(26))
self.assertEquals("aa", VirtualDisk.num_to_target(27))
self.assertEquals("ab", VirtualDisk.num_to_target(28))
self.assertEquals("az", VirtualDisk.num_to_target(52))
self.assertEquals("ba", VirtualDisk.num_to_target(53))
self.assertEquals("zz", VirtualDisk.num_to_target(27 * 26))
self.assertEquals("aaa", VirtualDisk.num_to_target(27 * 26 + 1))
disk = virtinst.VirtualDisk(utils.get_conn())
disk.bus = "ide"
self.assertEquals("hda", disk.generate_target([]))
self.assertEquals("hdb", disk.generate_target(["hda"]))
self.assertEquals("hdc", disk.generate_target(["hdb", "sda"]))
self.assertEquals("hdb", disk.generate_target(["hda", "hdd"]))
def get_filedisk(path=None, fake=True):
if not path:
path = "/dev/default-pool/new-test-suite.img"
d = VirtualDisk(_conn)
d.path = path
size = None
if not fake:
size = .000001
d.set_create_storage(fake=fake, size=size)
d.validate()
return d
def get_floppy(path=None):
if not path:
path = "/dev/default-pool/testvol1.img"
d = VirtualDisk(_conn)
d.path = path
d.device = d.DEVICE_FLOPPY
d.validate()
return d
def get_filedisk(path=None, fake=True):
if not path:
path = "/tmp/test.img"
d = VirtualDisk(_conn)
d.path = path
size = None
if not fake:
size = .000001
d.set_create_storage(fake=fake, size=size)
d.validate()
return d
def get_filedisk(path=None, fake=True):
if not path:
path = "/dev/default-pool/new-test-suite.img"
d = VirtualDisk(_conn)
d.path = path
size = None
if not fake:
size = .000001
d.set_create_storage(fake=fake, size=size)
d.validate()
return d
def populate_storage_volumes(self):
model = self.widget("vol-list").get_model()
model.clear()
dironly = self.browse_reason == self.config.CONFIG_DIR_FS
pool = self.current_pool()
if not pool:
return
vols = pool.get_volumes()
for key in vols.keys():
vol = vols[key]
sensitive = True
try:
path = vol.get_target_path()
fmt = vol.get_format() or ""
except Exception:
logging.exception("Failed to determine volume parameters, "
"skipping volume %s", key)
continue
namestr = None
try:
if path:
names = VirtualDisk.path_in_use_by(self.conn.get_backend(),
path)
namestr = ", ".join(names)
if not namestr:
namestr = None
except:
logging.exception("Failed to determine if storage volume in "
"use.")
if dironly and fmt != 'dir':
sensitive = False
elif not self.rhel6_defaults:
if fmt == "vmdk":
sensitive = False
model.append([key, vol.get_name(), vol.get_pretty_capacity(),
fmt, namestr, sensitive])
def testManyDevices(self):
i = make_pxe_installer()
g = get_basic_fullyvirt_guest(installer=i)
g.description = "foooo barrrr \n baz && snarf. '' \"\" @@$\n"
# Hostdevs
dev1 = VirtualHostDeviceUSB(g.conn)
dev1.product = "0x1234"
dev1.vendor = "0x4321"
g.hostdevs.append(dev1)
# Sound devices
g.sound_devs.append(VirtualAudio("sb16", conn=g.conn))
g.sound_devs.append(VirtualAudio("es1370", conn=g.conn))
# Disk devices
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
device=VirtualDisk.DEVICE_FLOPPY))
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
bus="scsi"))
g.disks.append(VirtualDisk(conn=g.conn, path="/tmp", device="floppy"))
d3 = VirtualDisk(conn=g.conn, path="/default-pool/testvol1.img",
bus="scsi", driverName="qemu")
g.disks.append(d3)
# Controller devices
c1 = VirtualController.get_class_for_type(VirtualController.CONTROLLER_TYPE_IDE)(g.conn)
c1.index = "3"
c2 = VirtualController.get_class_for_type(VirtualController.CONTROLLER_TYPE_VIRTIOSERIAL)(g.conn)
c2.ports = "32"
c2.vectors = "17"
g.add_device(c1)
g.add_device(c2)
# Network devices
net1 = get_virtual_network()
net1.model = "e1000"
net2 = VirtualNetworkInterface(type="user",
macaddr="11:11:11:11:11:11")
g.nics.append(net1)
g.nics.append(net2)
# Character devices
cdev1 = VirtualCharDevice.get_dev_instance(g.conn,
VirtualCharDevice.DEV_SERIAL,
VirtualCharDevice.CHAR_NULL)
cdev2 = VirtualCharDevice.get_dev_instance(g.conn,
VirtualCharDevice.DEV_PARALLEL,
VirtualCharDevice.CHAR_UNIX)
cdev2.source_path = "/tmp/foobar"
g.add_device(cdev1)
g.add_device(cdev2)
# Video Devices
vdev1 = VirtualVideoDevice(g.conn)
vdev1.model_type = "vmvga"
vdev2 = VirtualVideoDevice(g.conn)
vdev2.model_type = "cirrus"
vdev2.vram = 10 * 1024
vdev2.heads = 3
vdev3 = VirtualVideoDevice(g.conn)
g.add_device(vdev1)
g.add_device(vdev2)
g.add_device(vdev3)
wdev2 = VirtualWatchdog(g.conn)
wdev2.model = "ib700"
wdev2.action = "none"
g.add_device(wdev2)
g.clock.offset = "localtime"
seclabel = virtinst.Seclabel(g.conn)
seclabel.type = seclabel.SECLABEL_TYPE_STATIC
seclabel.model = "selinux"
seclabel.label = "foolabel"
seclabel.imagelabel = "imagelabel"
g.seclabel = seclabel
self._compare(g, "boot-many-devices", False)
def _upload_file(conn, meter, destpool, src):
# Build stream object
stream = conn.newStream(0)
def safe_send(data):
while True:
ret = stream.send(data)
if ret == 0 or ret == len(data):
break
data = data[ret:]
if meter is None:
meter = urlgrabber.progress.BaseMeter()
# Build placeholder volume
size = os.path.getsize(src)
basename = os.path.basename(src)
poolpath = util.xpath(destpool.XMLDesc(0), "/pool/target/path")
name = Storage.StorageVolume.find_free_name(basename,
pool_object=destpool)
if name != basename:
logging.debug("Generated non-colliding volume name %s", name)
vol_install = VirtualDisk.build_vol_install(conn, name, destpool,
(float(size) / 1024.0 / 1024.0 / 1024.0), True)
disk = VirtualDisk(conn)
disk.path = os.path.join(poolpath, name)
disk.set_create_storage(vol_install=vol_install)
disk.validate()
disk.setup(meter=meter)
vol = disk.get_vol_object()
if not vol:
raise RuntimeError(_("Failed to lookup scratch media volume"))
try:
# Register upload
offset = 0
length = size
flags = 0
stream.upload(vol, offset, length, flags)
# Open source file
fileobj = file(src, "r")
# Start transfer
total = 0
meter.start(size=size,
text=_("Transferring %s") % os.path.basename(src))
while True:
# blocksize = (1024 ** 2)
blocksize = 1024
data = fileobj.read(blocksize)
if not data:
break
safe_send(data)
total += len(data)
meter.update(total)
# Cleanup
stream.finish()
meter.end(size)
except:
if vol:
vol.delete(0)
raise
return vol
def get_blkdisk(path="/dev/disk-pool/diskvol1"):
d = VirtualDisk(_conn)
d.path = path
d.validate()
return d
def testDiskNumbers(self):
self.assertEquals("a", VirtualDisk.num_to_target(1))
self.assertEquals("b", VirtualDisk.num_to_target(2))
self.assertEquals("z", VirtualDisk.num_to_target(26))
self.assertEquals("aa", VirtualDisk.num_to_target(27))
self.assertEquals("ab", VirtualDisk.num_to_target(28))
self.assertEquals("az", VirtualDisk.num_to_target(52))
self.assertEquals("ba", VirtualDisk.num_to_target(53))
self.assertEquals("zz", VirtualDisk.num_to_target(27 * 26))
self.assertEquals("aaa", VirtualDisk.num_to_target(27 * 26 + 1))
self.assertEquals(VirtualDisk.target_to_num("hda"), 0)
self.assertEquals(VirtualDisk.target_to_num("hdb"), 1)
self.assertEquals(VirtualDisk.target_to_num("sdz"), 25)
self.assertEquals(VirtualDisk.target_to_num("sdaa"), 26)
self.assertEquals(VirtualDisk.target_to_num("vdab"), 27)
self.assertEquals(VirtualDisk.target_to_num("vdaz"), 51)
self.assertEquals(VirtualDisk.target_to_num("xvdba"), 52)
self.assertEquals(VirtualDisk.target_to_num("xvdzz"), 26 * (25 + 1) + 25)
self.assertEquals(VirtualDisk.target_to_num("xvdaaa"), 26 * 26 * 1 + 26 * 1 + 0)
disk = virtinst.VirtualDisk(utils.get_conn())
disk.bus = "ide"
self.assertEquals("hda", disk.generate_target([]))
self.assertEquals("hdb", disk.generate_target(["hda"]))
self.assertEquals("hdc", disk.generate_target(["hdb", "sda"]))
self.assertEquals("hdb", disk.generate_target(["hda", "hdd"]))
disk.bus = "virtio-scsi"
self.assertEquals("sdb", disk.generate_target(["sda", "sdg", "sdi"], 0))
self.assertEquals("sdh", disk.generate_target(["sda", "sdg"], 1))
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
def testManyDisks2(self):
i = utils.make_pxe_installer()
g = utils.get_basic_fullyvirt_guest(installer=i)
g.add_device(utils.get_filedisk())
g.add_device(utils.get_blkdisk())
d = VirtualDisk(g.conn)
d.type = "block"
d.path = "/dev/null"
d.device = d.DEVICE_CDROM
d.driver_type = "raw"
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.type = "block"
d.path = "/dev/null"
d.device = d.DEVICE_DISK
d.driver_name = "qemu"
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.path = None
d.device = d.DEVICE_CDROM
d.bus = "scsi"
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.path = None
d.device = d.DEVICE_FLOPPY
d.iotune_tbs = 1
d.iotune_tis = 2
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.type = "block"
d.path = "/dev/null"
d.device = d.DEVICE_FLOPPY
d.driver_name = "phy"
d.driver_cache = "none"
d.iotune_rbs = 5555
d.iotune_ris = 1234
d.iotune_wbs = 3
d.iotune_wis = 4
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.type = "block"
d.path = "/dev/null"
d.bus = "virtio"
d.driver_name = "qemu"
d.driver_type = "qcow2"
d.driver_cache = "none"
d.driver_io = "threads"
d.validate()
g.add_device(d)
self._compare(g, "boot-many-disks2", False)
def testManyDevices(self):
i = utils.make_pxe_installer()
g = utils.get_basic_fullyvirt_guest(installer=i)
g.description = "foooo barrrr somedesc"
g.hugepage = True
# Hostdevs
dev1 = VirtualHostDeviceUSB(g.conn)
dev1.product = "0x1234"
dev1.vendor = "0x4321"
g.hostdevs.append(dev1)
# Sound devices
g.sound_devs.append(VirtualAudio("sb16", conn=g.conn))
g.sound_devs.append(VirtualAudio("es1370", conn=g.conn))
# Disk devices
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
device=VirtualDisk.DEVICE_FLOPPY))
g.disks.append(VirtualDisk(conn=g.conn, path="/dev/loop0",
bus="scsi"))
g.disks.append(VirtualDisk(conn=g.conn, path="/tmp", device="floppy"))
d3 = VirtualDisk(conn=g.conn, path="/default-pool/testvol1.img",
bus="scsi", driverName="qemu")
g.disks.append(d3)
# Controller devices
c1 = VirtualController.get_class_for_type(VirtualController.CONTROLLER_TYPE_IDE)(g.conn)
c1.index = "3"
c2 = VirtualController.get_class_for_type(VirtualController.CONTROLLER_TYPE_VIRTIOSERIAL)(g.conn)
c2.ports = "32"
c2.vectors = "17"
g.add_device(c1)
g.add_device(c2)
# Network devices
net1 = utils.get_virtual_network()
net1.model = "e1000"
net2 = VirtualNetworkInterface(type="user",
macaddr="11:11:11:11:11:11")
g.nics.append(net1)
g.nics.append(net2)
# Character devices
cdev1 = VirtualCharDevice.get_dev_instance(g.conn,
VirtualCharDevice.DEV_SERIAL,
VirtualCharDevice.CHAR_NULL)
cdev2 = VirtualCharDevice.get_dev_instance(g.conn,
VirtualCharDevice.DEV_PARALLEL,
VirtualCharDevice.CHAR_UNIX)
cdev2.source_path = "/tmp/foobar"
cdev3 = VirtualCharDevice.get_dev_instance(g.conn,
VirtualCharDevice.DEV_CHANNEL,
VirtualCharDevice.CHAR_SPICEVMC)
g.add_device(cdev1)
g.add_device(cdev2)
g.add_device(cdev3)
# Video Devices
vdev1 = VirtualVideoDevice(g.conn)
vdev1.model_type = "vmvga"
vdev2 = VirtualVideoDevice(g.conn)
vdev2.model_type = "cirrus"
vdev2.vram = 10 * 1024
vdev2.heads = 3
vdev3 = VirtualVideoDevice(g.conn)
vdev4 = VirtualVideoDevice(g.conn)
vdev4.model_type = "qxl"
g.add_device(vdev1)
g.add_device(vdev2)
g.add_device(vdev3)
g.add_device(vdev4)
wdev2 = VirtualWatchdog(g.conn)
wdev2.model = "ib700"
wdev2.action = "none"
g.add_device(wdev2)
# Check keymap autoconfig
gdev1 = virtinst.VirtualGraphics(conn=g.conn, type="vnc")
self.assertTrue(gdev1.keymap != None)
gdev1.keymap = "en-us"
# Check keymap None
gdev2 = virtinst.VirtualGraphics(conn=g.conn, type="vnc")
gdev2.keymap = None
gdev3 = virtinst.VirtualGraphics(conn=g.conn, type="sdl")
gdev4 = virtinst.VirtualGraphics(conn=g.conn, type="spice")
gdev5 = virtinst.VirtualGraphics(conn=g.conn, type="sdl")
gdev5.xauth = "fooxauth"
gdev5.display = "foodisplay"
g.add_device(gdev1)
g.add_device(gdev2)
g.add_device(gdev3)
g.add_device(gdev4)
g.add_device(gdev5)
g.clock.offset = "localtime"
g.seclabel.type = g.seclabel.SECLABEL_TYPE_STATIC
g.seclabel.model = "selinux"
g.seclabel.label = "foolabel"
g.seclabel.imagelabel = "imagelabel"
self._compare(g, "boot-many-devices", False)
def testDiskValidation(self):
disk = VirtualDisk("/dev/loop0")
self._testArgs(disk, VirtualDisk, 'disk')
def testManyDevices(self):
i = utils.make_pxe_installer()
g = utils.get_basic_fullyvirt_guest(installer=i)
g.description = "foooo barrrr somedesc"
g.memoryBacking.hugepages = True
# Hostdevs
dev1 = VirtualHostDevice(g.conn)
dev1.type = "usb"
dev1.vendor = "0x4321"
dev1.product = "0x1234"
g.add_device(dev1)
# Sound devices
d = VirtualAudio(g.conn)
d.model = "sb16"
g.add_device(d)
d = VirtualAudio(g.conn)
d.model = "es1370"
g.add_device(d)
# Disk devices
d = VirtualDisk(g.conn)
d.type = "block"
d.path = "/dev/null"
d.device = d.DEVICE_FLOPPY
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.type = "block"
d.path = "/dev/null"
d.bus = "scsi"
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.path = "/tmp"
d.device = d.DEVICE_FLOPPY
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.path = "/dev/default-pool/testvol1.img"
d.bus = "scsi"
d.driver_name = "qemu"
d.address.type = "spapr-vio"
d.validate()
g.add_device(d)
# Controller devices
c1 = VirtualController(g.conn)
c1.type = "ide"
c1.index = "3"
c2 = VirtualController(g.conn)
c2.type = "virtio-serial"
c2.ports = "32"
c2.vectors = "17"
g.add_device(c1)
g.add_device(c2)
# Network devices
net1 = utils.get_virtual_network()
net1.model = "e1000"
net2 = VirtualNetworkInterface(g.conn)
net2.type = "user"
net2.macaddr = "22:11:11:11:11:11"
net3 = VirtualNetworkInterface(g.conn)
net3.type = virtinst.VirtualNetworkInterface.TYPE_VIRTUAL
net3.macaddr = "22:22:22:22:22:22"
net3.source = "default"
net3.model = "spapr-vlan"
net3.address.set_addrstr("spapr-vio")
g.add_device(net1)
g.add_device(net2)
g.add_device(net3)
# Character devices
cdev1 = VirtualSerialDevice(g.conn)
cdev1.type = "null"
cdev2 = VirtualParallelDevice(g.conn)
cdev2.type = "unix"
cdev2.source_path = "/dev/default-pool/foobar"
cdev3 = VirtualChannelDevice(g.conn)
cdev3.type = "spicevmc"
g.add_device(cdev1)
g.add_device(cdev2)
g.add_device(cdev3)
# Video Devices
vdev1 = VirtualVideoDevice(g.conn)
vdev1.model = "vmvga"
vdev2 = VirtualVideoDevice(g.conn)
vdev2.model = "cirrus"
vdev2.vram = 10 * 1024
vdev2.heads = 3
vdev3 = VirtualVideoDevice(g.conn)
vdev4 = VirtualVideoDevice(g.conn)
vdev4.model = "qxl"
g.add_device(vdev1)
g.add_device(vdev2)
g.add_device(vdev3)
g.add_device(vdev4)
# Watchdog Devices
wdev2 = VirtualWatchdog(g.conn)
wdev2.model = "ib700"
wdev2.action = "none"
g.add_device(wdev2)
# Memballoon Devices
mdev1 = VirtualMemballoon(g.conn)
mdev1.model = "virtio"
g.add_device(mdev1)
# Check keymap autoconfig
gdev1 = virtinst.VirtualGraphics(g.conn)
gdev1.type = "vnc"
self.assertTrue(gdev1.keymap is not None)
gdev1.keymap = "en-us"
# Check keymap None
gdev2 = virtinst.VirtualGraphics(g.conn)
gdev2.type = "vnc"
gdev2.keymap = None
gdev3 = virtinst.VirtualGraphics(g.conn)
gdev3.type = "sdl"
gdev3.xauth = "/dev/default-pool/.Xauthority"
gdev3.display = ":3.4"
gdev4 = virtinst.VirtualGraphics(g.conn)
gdev4.type = "spice"
gdev4.passwdValidTo = "foobar"
gdev5 = virtinst.VirtualGraphics(g.conn)
gdev5.type = "sdl"
gdev5.xauth = "fooxauth"
gdev5.display = "foodisplay"
g.add_device(gdev1)
g.add_device(gdev2)
g.add_device(gdev3)
g.add_device(gdev4)
g.add_device(gdev5)
g.clock.offset = "localtime"
g.seclabel.type = g.seclabel.TYPE_STATIC
g.seclabel.model = "selinux"
g.seclabel.label = "foolabel"
g.seclabel.imagelabel = "imagelabel"
redir1 = virtinst.VirtualRedirDevice(g.conn)
redir1.type = "spicevmc"
redir2 = virtinst.VirtualRedirDevice(g.conn)
redir2.type = "tcp"
redir2.parse_friendly_server("foobar.com:1234")
g.add_device(redir1)
g.add_device(redir2)
# Panic Notifier device
pdev = VirtualPanicDevice(g.conn)
g.add_device(pdev)
self._compare(g, "boot-many-devices", False)
def get_blkdisk():
return VirtualDisk("/dev/loop0", conn=conn)
def get_blkdisk(path="/dev/disk-pool/diskvol1"):
d = VirtualDisk(_conn)
d.path = path
d.validate()
return d
def get_blkdisk(path="/dev/loop0"):
return VirtualDisk(path, conn=_conn)
def get_filedisk(path=None):
if not path:
path = "/tmp/test.img"
return VirtualDisk(path, size=.0001, conn=_conn)
def get_floppy(path=None):
if not path:
path = "/default-pool/testvol1.img"
return VirtualDisk(path, conn=_conn, device=VirtualDisk.DEVICE_FLOPPY)
def testManyDisks2(self):
i = utils.make_pxe_installer()
g = utils.get_basic_fullyvirt_guest(installer=i)
g.add_device(utils.get_filedisk())
g.add_device(utils.get_blkdisk())
d = VirtualDisk(g.conn)
d.path = "/dev/loop0"
d.device = d.DEVICE_CDROM
d.driver_type = "raw"
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.path = "/dev/loop0"
d.device = d.DEVICE_DISK
d.driver_name = "qemu"
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.path = None
d.device = d.DEVICE_CDROM
d.bus = "scsi"
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.path = None
d.device = d.DEVICE_FLOPPY
d.iotune_tbs = 1
d.iotune_tis = 2
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.path = "/dev/loop0"
d.device = d.DEVICE_FLOPPY
d.driver_name = "phy"
d.driver_cache = "none"
d.iotune_rbs = 5555
d.iotune_ris = 1234
d.iotune_wbs = 3
d.iotune_wis = 4
d.validate()
g.add_device(d)
d = VirtualDisk(g.conn)
d.path = "/dev/loop0"
d.bus = "virtio"
d.driver_name = "qemu"
d.driver_type = "qcow2"
d.driver_cache = "none"
d.driver_io = "threads"
d.validate()
g.add_device(d)
self._compare(g, "boot-many-disks2", False)
def testDiskNumbers(self):
# Various testing our target generation
self.assertEqual("a", VirtualDisk.num_to_target(1))
self.assertEqual("b", VirtualDisk.num_to_target(2))
self.assertEqual("z", VirtualDisk.num_to_target(26))
self.assertEqual("aa", VirtualDisk.num_to_target(27))
self.assertEqual("ab", VirtualDisk.num_to_target(28))
self.assertEqual("az", VirtualDisk.num_to_target(52))
self.assertEqual("ba", VirtualDisk.num_to_target(53))
self.assertEqual("zz", VirtualDisk.num_to_target(27 * 26))
self.assertEqual("aaa", VirtualDisk.num_to_target(27 * 26 + 1))
self.assertEqual(VirtualDisk.target_to_num("hda"), 0)
self.assertEqual(VirtualDisk.target_to_num("hdb"), 1)
self.assertEqual(VirtualDisk.target_to_num("sdz"), 25)
self.assertEqual(VirtualDisk.target_to_num("sdaa"), 26)
self.assertEqual(VirtualDisk.target_to_num("vdab"), 27)
self.assertEqual(VirtualDisk.target_to_num("vdaz"), 51)
self.assertEqual(VirtualDisk.target_to_num("xvdba"), 52)
self.assertEqual(VirtualDisk.target_to_num("xvdzz"),
26 * (25 + 1) + 25)
self.assertEqual(VirtualDisk.target_to_num("xvdaaa"),
26 * 26 * 1 + 26 * 1 + 0)
disk = virtinst.VirtualDisk(_default_conn)
disk.bus = "ide"
self.assertEqual("hda", disk.generate_target([]))
self.assertEqual("hdb", disk.generate_target(["hda"]))
self.assertEqual("hdc", disk.generate_target(["hdb", "sda"]))
self.assertEqual("hdb", disk.generate_target(["hda", "hdd"]))
disk.bus = "virtio-scsi"
self.assertEqual("sdb",
disk.generate_target(["sda", "sdg", "sdi"], 0))
self.assertEqual("sdh", disk.generate_target(["sda", "sdg"], 1))
def _make_guest(installer=None, conn=None, os_variant=None):
if conn is None:
conn = _default_conn
g = conn.caps.lookup_virtinst_guest()
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"
if os_variant:
g.os_variant = os_variant
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
def get_blkdisk(path="/dev/loop0"):
d = VirtualDisk(_conn)
d.path = path
d.validate()
return d
