shaba/virt-manager
1
0
Fork 0
mirror of https://github.com/virt-manager/virt-manager.git synced 2024-10-26 08:55:13 +03:00
Code Issues Projects Releases Wiki Activity

virtinst: Give device classes consistent DeviceX naming

Browse Source 
Previous state was inconsistenty and needlessly wordy. Fix up
a few other class namings that have redundant Virtual in the name
This commit is contained in:
Cole Robinson 2018-03-20 12:18:35 -04:00
parent 93c22eff79
commit 1c911ce567
50 changed files with 595 additions and 595 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/nodedev.py
View File

@ -21,7 +21,7 @@ import os.path
import unittest
from virtinst import NodeDevice
from virtinst import VirtualHostDevice
from virtinst import DeviceHostdev
from tests import utils
@ -95,7 +95,7 @@ class TestNodeDev(unittest.TestCase):
if not nodedev:
nodedev = self._nodeDevFromName(nodename)
dev = VirtualHostDevice(self.conn)
dev = DeviceHostdev(self.conn)
dev.set_from_nodedev(nodedev)
utils.diff_compare(dev.get_xml_config() + "\n", devfile)

62
tests/xmlconfig.py
View File

@ -20,7 +20,7 @@ import tempfile
import unittest
import virtinst
from virtinst import VirtualDisk
from virtinst import DeviceDisk
from virtcli import CLIConfig
from tests import utils
@ -41,7 +41,7 @@ def _make_guest(installer=None, conn=None, os_variant=None):
g.memory = int(200 * 1024)
g.maxmemory = int(400 * 1024)
g.uuid = "12345678-1234-1234-1234-123456789012"
gdev = virtinst.VirtualGraphics(conn)
gdev = virtinst.DeviceGraphics(conn)
gdev.type = "vnc"
gdev.keymap = "ja"
g.add_device(gdev)
@ -57,11 +57,11 @@ def _make_guest(installer=None, conn=None, os_variant=None):
g.os_variant = os_variant
g.add_default_input_device()
g.add_default_console_device()
g.add_device(virtinst.VirtualAudio(g.conn))
g.add_device(virtinst.DeviceSound(g.conn))
# Floppy disk
path = "/dev/default-pool/testvol1.img"
d = VirtualDisk(conn)
d = DeviceDisk(conn)
d.path = path
d.device = d.DEVICE_FLOPPY
d.validate()
@ -69,12 +69,12 @@ def _make_guest(installer=None, conn=None, os_variant=None):
# File disk
path = "/dev/default-pool/new-test-suite.img"
d = virtinst.VirtualDisk(conn)
d = virtinst.DeviceDisk(conn)
d.path = path
if d.wants_storage_creation():
parent_pool = d.get_parent_pool()
vol_install = virtinst.VirtualDisk.build_vol_install(conn,
vol_install = virtinst.DeviceDisk.build_vol_install(conn,
os.path.basename(path), parent_pool, .0000001, True)
d.set_vol_install(vol_install)
@ -83,15 +83,15 @@ def _make_guest(installer=None, conn=None, os_variant=None):
# Block disk
path = "/dev/disk-pool/diskvol1"
d = virtinst.VirtualDisk(conn)
d = virtinst.DeviceDisk(conn)
d.path = path
d.validate()
g.add_device(d)
# Network device
dev = virtinst.VirtualNetworkInterface(conn)
dev = virtinst.DeviceInterface(conn)
dev.macaddr = "22:22:33:44:55:66"
dev.type = virtinst.VirtualNetworkInterface.TYPE_VIRTUAL
dev.type = virtinst.DeviceInterface.TYPE_VIRTUAL
dev.source = "default"
g.add_device(dev)
@ -140,16 +140,16 @@ class TestXMLMisc(unittest.TestCase):
return "bzz0"
setattr(deviceinterface, "_default_bridge", newbridge)
dev1 = virtinst.VirtualNetworkInterface(self.conn)
dev1 = virtinst.DeviceInterface(self.conn)
dev1.macaddr = "22:22:33:44:55:66"
dev2 = virtinst.VirtualNetworkInterface(self.conn,
dev2 = virtinst.DeviceInterface(self.conn,
parsexml=dev1.get_xml_config())
dev2.source = None
dev2.source = "foobr0"
dev2.macaddr = "22:22:33:44:55:67"
dev3 = virtinst.VirtualNetworkInterface(self.conn,
dev3 = virtinst.DeviceInterface(self.conn,
parsexml=dev1.get_xml_config())
dev3.source = None
dev3.macaddr = "22:22:33:44:55:68"
@ -192,29 +192,29 @@ class TestXMLMisc(unittest.TestCase):
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("a", DeviceDisk.num_to_target(1))
self.assertEqual("b", DeviceDisk.num_to_target(2))
self.assertEqual("z", DeviceDisk.num_to_target(26))
self.assertEqual("aa", DeviceDisk.num_to_target(27))
self.assertEqual("ab", DeviceDisk.num_to_target(28))
self.assertEqual("az", DeviceDisk.num_to_target(52))
self.assertEqual("ba", DeviceDisk.num_to_target(53))
self.assertEqual("zz", DeviceDisk.num_to_target(27 * 26))
self.assertEqual("aaa", DeviceDisk.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"),
self.assertEqual(DeviceDisk.target_to_num("hda"), 0)
self.assertEqual(DeviceDisk.target_to_num("hdb"), 1)
self.assertEqual(DeviceDisk.target_to_num("sdz"), 25)
self.assertEqual(DeviceDisk.target_to_num("sdaa"), 26)
self.assertEqual(DeviceDisk.target_to_num("vdab"), 27)
self.assertEqual(DeviceDisk.target_to_num("vdaz"), 51)
self.assertEqual(DeviceDisk.target_to_num("xvdba"), 52)
self.assertEqual(DeviceDisk.target_to_num("xvdzz"),
26 * (25 + 1) + 25)
self.assertEqual(VirtualDisk.target_to_num("xvdaaa"),
self.assertEqual(DeviceDisk.target_to_num("xvdaaa"),
26 * 26 * 1 + 26 * 1 + 0)
disk = virtinst.VirtualDisk(self.conn)
disk = virtinst.DeviceDisk(self.conn)
disk.bus = "ide"
self.assertEqual("hda", disk.generate_target([]))

10
tests/xmlparse.py
View File

@ -341,7 +341,7 @@ class XMLParseTest(unittest.TestCase):
def testAlterDisk(self):
"""
Test changing VirtualDisk() parameters after parsing
Test changing DeviceDisk() parameters after parsing
"""
guest, outfile = self._get_test_content("change-disk")
@ -432,7 +432,7 @@ class XMLParseTest(unittest.TestCase):
def testSingleDisk(self):
xml = ("""<disk type="file" device="disk"><source file="/a.img"/>\n"""
"""<target dev="hda" bus="ide"/></disk>\n""")
d = virtinst.VirtualDisk(self.conn, parsexml=xml)
d = virtinst.DeviceDisk(self.conn, parsexml=xml)
self._set_and_check(d, "target", "hda", "hdb")
self.assertEqual(xml.replace("hda", "hdb"), d.get_xml_config())
@ -1004,10 +1004,10 @@ class XMLParseTest(unittest.TestCase):
guest.remove_device(rmdev)
# Basic device add
guest.add_device(virtinst.VirtualWatchdog(self.conn))
guest.add_device(virtinst.DeviceWatchdog(self.conn))
# Test adding device with child properties (address value)
adddev = virtinst.VirtualNetworkInterface(self.conn)
adddev = virtinst.DeviceInterface(self.conn)
adddev.type = "network"
adddev.source = "default"
adddev.macaddr = "1A:2A:3A:4A:5A:6A"
@ -1019,7 +1019,7 @@ class XMLParseTest(unittest.TestCase):
guest.add_device(adddev)
# Test adding device built from parsed XML
guest.add_device(virtinst.VirtualAudio(self.conn,
guest.add_device(virtinst.DeviceSound(self.conn,
parsexml="""<sound model='pcspk'/>"""))
self._alter_compare(guest.get_xml_config(), outfile)

2
virt-install
View File

@ -46,7 +46,7 @@ def cdrom_specified(guest, disk=None):
disks = guest.get_devices("disk")
for d in disks:
if d.device == virtinst.VirtualDisk.DEVICE_CDROM:
if d.device == virtinst.DeviceDisk.DEVICE_CDROM:
return True
# Probably haven't set up disks yet

162
virtManager/addhardware.py
View File

@ -25,12 +25,12 @@ from gi.repository import Gtk
from gi.repository import Gdk
import virtinst
from virtinst import (VirtualChannelDevice, VirtualParallelDevice,
VirtualSerialDevice, VirtualConsoleDevice,
VirtualVideoDevice, VirtualWatchdog,
VirtualSmartCardDevice, VirtualRedirDevice,
VirtualTPMDevice, VirtualPanicDevice)
from virtinst import VirtualController
from virtinst import (DeviceChannel, DeviceParallel,
DeviceSerial, DeviceConsole,
DeviceVideo, DeviceWatchdog,
DeviceSmartcard, DeviceRedirdev,
DeviceTpm, DevicePanic)
from virtinst import DeviceController
from . import uiutil
from .fsdetails import vmmFSDetails
@ -212,14 +212,14 @@ class vmmAddHardware(vmmGObjectUI):
text.set_property("xpad", 6)
target_list.pack_start(text, True)
target_list.add_attribute(text, 'text', 2)
target_model.append([virtinst.VirtualDisk.DEVICE_DISK,
target_model.append([virtinst.DeviceDisk.DEVICE_DISK,
"drive-harddisk", _("Disk device")])
target_model.append([virtinst.VirtualDisk.DEVICE_CDROM,
target_model.append([virtinst.DeviceDisk.DEVICE_CDROM,
"media-cdrom", _("CDROM device")])
target_model.append([virtinst.VirtualDisk.DEVICE_FLOPPY,
target_model.append([virtinst.DeviceDisk.DEVICE_FLOPPY,
"media-floppy", _("Floppy device")])
if self.conn.is_qemu() or self.conn.is_test():
target_model.append([virtinst.VirtualDisk.DEVICE_LUN,
target_model.append([virtinst.DeviceDisk.DEVICE_LUN,
"drive-harddisk", _("LUN Passthrough")])
target_list.set_active(0)
@ -260,8 +260,8 @@ class vmmAddHardware(vmmGObjectUI):
char_mode.set_model(char_mode_model)
uiutil.init_combo_text_column(char_mode, 1)
char_mode_model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
for t in VirtualSerialDevice.MODES:
desc = VirtualSerialDevice.pretty_mode(t)
for t in DeviceSerial.MODES:
desc = DeviceSerial.pretty_mode(t)
char_mode_model.append([t, desc + " (%s)" % t])
# Char target type
@ -279,7 +279,7 @@ class vmmAddHardware(vmmGObjectUI):
model = Gtk.ListStore(str)
lst.set_model(model)
uiutil.init_combo_text_column(lst, 0)
for n in VirtualChannelDevice.CHANNEL_NAMES:
for n in DeviceChannel.CHANNEL_NAMES:
model.append([n])
# Char device type
@ -404,7 +404,7 @@ class vmmAddHardware(vmmGObjectUI):
add_hw_option(_("RNG"), "system-run", PAGE_RNG, True, None)
add_hw_option(_("Panic Notifier"), "system-run", PAGE_PANIC,
self.conn.check_support(self.conn.SUPPORT_CONN_PANIC_DEVICE) and
virtinst.VirtualPanicDevice.get_models(self.vm.get_xmlobj().os),
virtinst.DevicePanic.get_models(self.vm.get_xmlobj().os),
_("Not supported for this hypervisor/libvirt/arch combination."))
def _reset_state(self):
@ -416,7 +416,7 @@ class vmmAddHardware(vmmGObjectUI):
self.addstorage.reset_state()
# Network init
newmac = virtinst.VirtualNetworkInterface.generate_mac(
newmac = virtinst.DeviceInterface.generate_mac(
self.conn.get_backend())
self.widget("mac-address").set_active(bool(newmac))
self.widget("create-mac-address").set_text(newmac)
@ -495,7 +495,7 @@ class vmmAddHardware(vmmGObjectUI):
uiutil.init_combo_text_column(combo, 1)
combo.get_model().set_sort_column_id(1, Gtk.SortType.ASCENDING)
tmpdev = virtinst.VirtualVideoDevice(vm.conn.get_backend())
tmpdev = virtinst.DeviceVideo(vm.conn.get_backend())
for m in tmpdev.MODELS:
model.append([m, tmpdev.pretty_model(m)])
@ -512,7 +512,7 @@ class vmmAddHardware(vmmGObjectUI):
stable_defaults = vm.stable_defaults()
stable_soundmodels = ["ich6", "ich9", "ac97"]
for m in virtinst.VirtualAudio.MODELS:
for m in virtinst.DeviceSound.MODELS:
if (stable_defaults and m not in stable_soundmodels):
continue
@ -527,7 +527,7 @@ class vmmAddHardware(vmmGObjectUI):
combo.set_model(model)
uiutil.init_combo_text_column(combo, 0)
for m in virtinst.VirtualWatchdog.MODELS:
for m in virtinst.DeviceWatchdog.MODELS:
model.append([m])
if len(model) > 0:
combo.set_active(0)
@ -539,8 +539,8 @@ class vmmAddHardware(vmmGObjectUI):
combo.set_model(model)
uiutil.init_combo_text_column(combo, 1)
for m in virtinst.VirtualWatchdog.ACTIONS:
model.append([m, virtinst.VirtualWatchdog.get_action_desc(m)])
for m in virtinst.DeviceWatchdog.ACTIONS:
model.append([m, virtinst.DeviceWatchdog.get_action_desc(m)])
if len(model) > 0:
combo.set_active(0)
@ -598,7 +598,7 @@ class vmmAddHardware(vmmGObjectUI):
idx = -1
for rowid, row in enumerate(combo.get_model()):
idx = 0
if row[0] == virtinst.VirtualSmartCardDevice.MODE_DEFAULT:
if row[0] == virtinst.DeviceSmartcard.MODE_DEFAULT:
idx = rowid
break
combo.set_active(idx)
@ -629,8 +629,8 @@ class vmmAddHardware(vmmGObjectUI):
types.clear()
# [xml value, label]
for t in virtinst.VirtualTPMDevice.TYPES:
types.append([t, virtinst.VirtualTPMDevice.get_pretty_type(t)])
for t in virtinst.DeviceTpm.TYPES:
types.append([t, virtinst.DeviceTpm.get_pretty_type(t)])
@staticmethod
def build_tpm_type_combo(vm, combo):
@ -644,7 +644,7 @@ class vmmAddHardware(vmmGObjectUI):
idx = -1
for rowid, row in enumerate(combo.get_model()):
idx = 0
if row[0] == virtinst.VirtualTPMDevice.TYPE_DEFAULT:
if row[0] == virtinst.DeviceTpm.TYPE_DEFAULT:
idx = rowid
break
combo.set_active(idx)
@ -657,7 +657,7 @@ class vmmAddHardware(vmmGObjectUI):
uiutil.init_combo_text_column(combo, 1)
combo.set_active(-1)
for m in virtinst.VirtualDisk.cache_types:
for m in virtinst.DeviceDisk.cache_types:
model.append([m, m])
_iter = model.insert(0, [None, _("Hypervisor default")])
@ -672,7 +672,7 @@ class vmmAddHardware(vmmGObjectUI):
model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
combo.set_active(-1)
for m in virtinst.VirtualDisk.io_modes:
for m in virtinst.DeviceDisk.io_modes:
model.append([m, m])
if not no_default:
@ -721,7 +721,7 @@ class vmmAddHardware(vmmGObjectUI):
rows = []
for bus in disk_bus_types:
rows.append([bus, virtinst.VirtualDisk.pretty_disk_bus(bus)])
rows.append([bus, virtinst.DeviceDisk.pretty_disk_bus(bus)])
model.clear()
@ -741,10 +741,10 @@ class vmmAddHardware(vmmGObjectUI):
model.clear()
model.append([None, _("Hypervisor default")])
if controller_type == virtinst.VirtualController.TYPE_USB:
if controller_type == virtinst.DeviceController.TYPE_USB:
model.append(["ich9-ehci1", "USB 2"])
model.append(["nec-xhci", "USB 3"])
elif controller_type == virtinst.VirtualController.TYPE_SCSI:
elif controller_type == virtinst.DeviceController.TYPE_SCSI:
model.append(["virtio-scsi", "VirtIO SCSI"])
combo.set_active(0)
@ -887,12 +887,12 @@ class vmmAddHardware(vmmGObjectUI):
model = widget.get_model()
model.clear()
for t in VirtualController.TYPES:
if t in [VirtualController.TYPE_IDE,
VirtualController.TYPE_PCI,
VirtualController.TYPE_FDC]:
for t in DeviceController.TYPES:
if t in [DeviceController.TYPE_IDE,
DeviceController.TYPE_PCI,
DeviceController.TYPE_FDC]:
continue
model.append([t, VirtualController.pretty_type(t)])
model.append([t, DeviceController.pretty_type(t)])
if len(model) > 0:
widget.set_active(0)
@ -917,9 +917,9 @@ class vmmAddHardware(vmmGObjectUI):
show_tooltip(model_tooltip, False)
controllers = self.vm.get_controller_devices()
if controller_type == VirtualController.TYPE_USB:
if controller_type == DeviceController.TYPE_USB:
usb_controllers = [x for x in controllers if
(x.type == VirtualController.TYPE_USB)]
(x.type == DeviceController.TYPE_USB)]
if (len(usb_controllers) == 0):
self.widget("create-finish").set_sensitive(True)
elif (len(usb_controllers) == 1 and
@ -950,28 +950,28 @@ class vmmAddHardware(vmmGObjectUI):
def _build_rng_type_combo(self, combo):
types = []
for t in virtinst.VirtualRNGDevice.TYPES:
types.append([t, virtinst.VirtualRNGDevice.get_pretty_type(t)])
for t in virtinst.DeviceRng.TYPES:
types.append([t, virtinst.DeviceRng.get_pretty_type(t)])
self._build_combo_with_values(combo, types,
virtinst.VirtualRNGDevice.TYPE_RANDOM)
virtinst.DeviceRng.TYPE_RANDOM)
def _build_rng_backend_type_combo(self, combo):
default = virtinst.VirtualRNGDevice.BACKEND_TYPE_TCP
default = virtinst.DeviceRng.BACKEND_TYPE_TCP
types = []
for t in virtinst.VirtualRNGDevice.BACKEND_TYPES:
pprint = virtinst.VirtualRNGDevice.get_pretty_backend_type(t)
for t in virtinst.DeviceRng.BACKEND_TYPES:
pprint = virtinst.DeviceRng.get_pretty_backend_type(t)
types.append([t, pprint])
self._build_combo_with_values(combo, types, default)
def _build_rng_backend_mode_combo(self, combo):
default = virtinst.VirtualRNGDevice.BACKEND_MODE_CONNECT
default = virtinst.DeviceRng.BACKEND_MODE_CONNECT
types = []
for t in virtinst.VirtualRNGDevice.BACKEND_MODES:
pprint = virtinst.VirtualRNGDevice.get_pretty_backend_type(t)
for t in virtinst.DeviceRng.BACKEND_MODES:
pprint = virtinst.DeviceRng.get_pretty_backend_type(t)
types.append([t, pprint])
self._build_combo_with_values(combo, types, default)
@ -979,11 +979,11 @@ class vmmAddHardware(vmmGObjectUI):
def _build_panic_models(self, combo):
models = []
for m in virtinst.VirtualPanicDevice.get_models(self.vm.get_xmlobj().os):
models.append([m, virtinst.VirtualPanicDevice.get_pretty_model(m)])
for m in virtinst.DevicePanic.get_models(self.vm.get_xmlobj().os):
models.append([m, virtinst.DevicePanic.get_pretty_model(m)])
self._build_combo_with_values(combo, models,
virtinst.VirtualPanicDevice.get_default_model(
virtinst.DevicePanic.get_default_model(
self.vm.get_xmlobj().os))
@ -999,12 +999,12 @@ class vmmAddHardware(vmmGObjectUI):
label = row[5]
if label == "parallel":
return VirtualParallelDevice
return DeviceParallel
elif label == "channel":
return VirtualChannelDevice
return DeviceChannel
elif label == "console":
return VirtualConsoleDevice
return VirtualSerialDevice
return DeviceConsole
return DeviceSerial
def _set_hw_selection(self, page):
uiutil.set_list_selection_by_number(self.widget("hw-list"), page)
@ -1161,7 +1161,7 @@ class vmmAddHardware(vmmGObjectUI):
"device_path": "tpm-device-path",
}
self._dev = VirtualTPMDevice(self.conn.get_backend())
self._dev = DeviceTpm(self.conn.get_backend())
self._dev.type = devtype
for param_name, widget_name in tpm_widget_mappings.items():
@ -1183,13 +1183,13 @@ class vmmAddHardware(vmmGObjectUI):
text = src.get_child().get_text()
settype = None
if text == VirtualChannelDevice.CHANNEL_NAME_SPICE:
if text == DeviceChannel.CHANNEL_NAME_SPICE:
settype = "spicevmc"
elif text == VirtualChannelDevice.CHANNEL_NAME_SPICE_WEBDAV:
elif text == DeviceChannel.CHANNEL_NAME_SPICE_WEBDAV:
settype = "spiceport"
self.widget("char-channel").set_text(text)
elif (text == VirtualChannelDevice.CHANNEL_NAME_QEMUGA or
text == VirtualChannelDevice.CHANNEL_NAME_LIBGUESTFS):
elif (text == DeviceChannel.CHANNEL_NAME_QEMUGA or
text == DeviceChannel.CHANNEL_NAME_LIBGUESTFS):
settype = "unix"
if settype:
uiutil.set_list_selection(
@ -1244,7 +1244,7 @@ class vmmAddHardware(vmmGObjectUI):
def _change_rng(self, ignore1):
rtype = uiutil.get_list_selection(self.widget("rng-type"))
is_egd = rtype == virtinst.VirtualRNGDevice.TYPE_EGD
is_egd = rtype == virtinst.DeviceRng.TYPE_EGD
uiutil.set_grid_row_visible(self.widget("rng-device"), not is_egd)
uiutil.set_grid_row_visible(self.widget("rng-backend-type"), is_egd)
@ -1252,8 +1252,8 @@ class vmmAddHardware(vmmGObjectUI):
self.widget("rng-backend-type"))
backend_mode = uiutil.get_list_selection(
self.widget("rng-backend-mode"))
udp = backend_type == virtinst.VirtualRNGDevice.BACKEND_TYPE_UDP
bind = backend_mode == virtinst.VirtualRNGDevice.BACKEND_MODE_BIND
udp = backend_type == virtinst.DeviceRng.BACKEND_TYPE_UDP
bind = backend_mode == virtinst.DeviceRng.BACKEND_MODE_BIND
v = is_egd and (udp or bind)
uiutil.set_grid_row_visible(self.widget("rng-bind-host-box"), v)
@ -1441,10 +1441,10 @@ class vmmAddHardware(vmmGObjectUI):
# Get SCSI controllers
controllers = self.vm.get_controller_devices()
ctrls_scsi = [x for x in controllers if
(x.type == VirtualController.TYPE_SCSI)]
(x.type == DeviceController.TYPE_SCSI)]
# Create possible new controller
controller = VirtualController(self.conn.get_backend())
controller = DeviceController(self.conn.get_backend())
controller.type = "scsi"
controller.model = controller_model
@ -1462,7 +1462,7 @@ class vmmAddHardware(vmmGObjectUI):
for d in used_disks:
if (d.get_target_prefix() == disk.get_target_prefix() and
d.bus == "scsi"):
num = virtinst.VirtualDisk.target_to_num(d.target)
num = virtinst.DeviceDisk.target_to_num(d.target)
idx = num // 7
if idx not in occupied:
occupied[idx] = []
@ -1550,7 +1550,7 @@ class vmmAddHardware(vmmGObjectUI):
def _validate_page_input(self):
row = uiutil.get_list_selected_row(self.widget("input-type"))
dev = virtinst.VirtualInputDevice(self.conn.get_backend())
dev = virtinst.DeviceInput(self.conn.get_backend())
dev.type = row[1]
dev.bus = row[2]
@ -1561,7 +1561,7 @@ class vmmAddHardware(vmmGObjectUI):
(gtype, port, tlsport, listen,
addr, passwd, keymap, gl, rendernode) = self._gfxdetails.get_values()
self._dev = virtinst.VirtualGraphics(self.conn.get_backend())
self._dev = virtinst.DeviceGraphics(self.conn.get_backend())
self._dev.type = gtype
self._dev.passwd = passwd
self._dev.gl = gl
@ -1584,7 +1584,7 @@ class vmmAddHardware(vmmGObjectUI):
smodel = uiutil.get_list_selection(self.widget("sound-model"))
try:
self._dev = virtinst.VirtualAudio(self.conn.get_backend())
self._dev = virtinst.DeviceSound(self.conn.get_backend())
self._dev.model = smodel
except Exception as e:
return self.err.val_err(_("Sound device parameter error"), e)
@ -1596,7 +1596,7 @@ class vmmAddHardware(vmmGObjectUI):
_("A device must be selected."))
try:
dev = virtinst.VirtualHostDevice(self.conn.get_backend())
dev = virtinst.DeviceHostdev(self.conn.get_backend())
# Hostdev collision
names = []
for vm in self.conn.list_vms():
@ -1637,9 +1637,9 @@ class vmmAddHardware(vmmGObjectUI):
target_type = uiutil.get_list_selection(typebox)
if self.widget("char-use-telnet").get_active():
protocol = VirtualSerialDevice.PROTOCOL_TELNET
protocol = DeviceSerial.PROTOCOL_TELNET
else:
protocol = VirtualSerialDevice.PROTOCOL_RAW
protocol = DeviceSerial.PROTOCOL_RAW
if not self.widget("char-target-name").get_visible():
target_name = None
@ -1687,7 +1687,7 @@ class vmmAddHardware(vmmGObjectUI):
model = uiutil.get_list_selection(self.widget("video-model"))
try:
self._dev = VirtualVideoDevice(conn)
self._dev = DeviceVideo(conn)
self._dev.model = model
except Exception as e:
return self.err.val_err(_("Video device parameter error"), e)
@ -1698,7 +1698,7 @@ class vmmAddHardware(vmmGObjectUI):
action = uiutil.get_list_selection(self.widget("watchdog-action"))
try:
self._dev = VirtualWatchdog(conn)
self._dev = DeviceWatchdog(conn)
self._dev.model = model
self._dev.action = action
except Exception as e:
@ -1714,7 +1714,7 @@ class vmmAddHardware(vmmGObjectUI):
mode = uiutil.get_list_selection(self.widget("smartcard-mode"))
try:
self._dev = VirtualSmartCardDevice(conn)
self._dev = DeviceSmartcard(conn)
self._dev.mode = mode
except Exception as e:
return self.err.val_err(_("Smartcard device parameter error"), e)
@ -1729,7 +1729,7 @@ class vmmAddHardware(vmmGObjectUI):
service = uiutil.spin_get_helper(self.widget("usbredir-service"))
try:
self._dev = VirtualRedirDevice(conn)
self._dev = DeviceRedirdev(conn)
self._dev.type = stype
if host:
self._dev.host = host
@ -1750,7 +1750,7 @@ class vmmAddHardware(vmmGObjectUI):
}
try:
self._dev = VirtualTPMDevice(conn)
self._dev = DeviceTpm(conn)
self._dev.type = typ
for param_name, val in value_mappings.items():
if self._dev.supports_property(param_name):
@ -1764,7 +1764,7 @@ class vmmAddHardware(vmmGObjectUI):
model = uiutil.get_list_selection(self.widget("panic-model"))
try:
self._dev = VirtualPanicDevice(conn)
self._dev = DevicePanic(conn)
self._dev.model = model
except Exception as e:
return self.err.val_err(_("Panic device parameter error"), e)
@ -1775,7 +1775,7 @@ class vmmAddHardware(vmmGObjectUI):
self.widget("controller-type"))
model = uiutil.get_list_selection(self.widget("controller-model"))
self._dev = VirtualController(conn)
self._dev = DeviceController(conn)
self._selected_model = model
controllers = self.vm.get_controller_devices()
@ -1808,7 +1808,7 @@ class vmmAddHardware(vmmGObjectUI):
device = self.widget("rng-device").get_text()
if rtype == virtinst.VirtualRNGDevice.TYPE_RANDOM:
if rtype == virtinst.DeviceRng.TYPE_RANDOM:
if not device:
return self.err.val_err(_("RNG selection error."),
_("A device must be specified."))
@ -1819,8 +1819,8 @@ class vmmAddHardware(vmmGObjectUI):
else:
device = None
if rtype == virtinst.VirtualRNGDevice.TYPE_EGD:
if (backend_type == virtinst.VirtualRNGDevice.BACKEND_TYPE_UDP):
if rtype == virtinst.DeviceRng.TYPE_EGD:
if (backend_type == virtinst.DeviceRng.BACKEND_TYPE_UDP):
if not connect_host or not bind_host:
return self.err.val_err(_("RNG selection error."),
_("Please specify both bind and connect host"))
@ -1829,7 +1829,7 @@ class vmmAddHardware(vmmGObjectUI):
_("Please specify both bind and connect service"))
else:
if (backend_mode ==
virtinst.VirtualRNGDevice.BACKEND_MODE_CONNECT):
virtinst.DeviceRng.BACKEND_MODE_CONNECT):
bind_host = None
bind_service = None
else:
@ -1854,7 +1854,7 @@ class vmmAddHardware(vmmGObjectUI):
}
try:
self._dev = virtinst.VirtualRNGDevice(self.conn.get_backend())
self._dev = virtinst.DeviceRng(self.conn.get_backend())
self._dev.type = rtype
for param_name, val in value_mappings.items():
if self._dev.supports_property(param_name):

8
virtManager/addstorage.py
View File

@ -129,7 +129,7 @@ class vmmAddStorage(vmmGObjectUI):
@staticmethod
def check_path_search(src, conn, path):
skip_paths = src.config.get_perms_fix_ignore()
user, broken_paths = virtinst.VirtualDisk.check_path_search(
user, broken_paths = virtinst.DeviceDisk.check_path_search(
conn.get_backend(), path)
for p in broken_paths[:]:
@ -153,7 +153,7 @@ class vmmAddStorage(vmmGObjectUI):
return
logging.debug("Attempting to correct permission issues.")
errors = virtinst.VirtualDisk.fix_path_search_for_user(
errors = virtinst.DeviceDisk.fix_path_search_for_user(
conn.get_backend(), path, user)
if not errors:
return
@ -257,7 +257,7 @@ class vmmAddStorage(vmmGObjectUI):
if not path and device in ["disk", "lun"]:
return self.err.val_err(_("A storage path must be specified."))
disk = virtinst.VirtualDisk(self.conn.get_backend())
disk = virtinst.DeviceDisk(self.conn.get_backend())
disk.path = path or None
disk.device = device
@ -266,7 +266,7 @@ class vmmAddStorage(vmmGObjectUI):
size = uiutil.spin_get_helper(self.widget("storage-size"))
sparse = False
vol_install = virtinst.VirtualDisk.build_vol_install(
vol_install = virtinst.DeviceDisk.build_vol_install(
disk.conn, os.path.basename(disk.path), pool,
size, sparse)
disk.set_vol_install(vol_install)

4
virtManager/choosecd.py
View File

@ -20,7 +20,7 @@
import logging
from virtinst import VirtualDisk
from virtinst import DeviceDisk
from .baseclass import vmmGObjectUI
from .mediacombo import vmmMediaCombo
@ -114,7 +114,7 @@ class vmmChooseCD(vmmGObjectUI):
return self.err.val_err(_("Invalid Media Path"),
_("A media path must be specified."))
names = VirtualDisk.path_in_use_by(self.disk.conn, path)
names = DeviceDisk.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') %

20
virtManager/clone.py
View File

@ -26,7 +26,7 @@ from gi.repository import Gdk
import virtinst
from virtinst import Cloner
from virtinst import VirtualNetworkInterface
from virtinst import DeviceInterface
from . import uiutil
from .baseclass import vmmGObjectUI
@ -103,8 +103,8 @@ def do_we_default(conn, vol, path, ro, shared, devtype):
str1 += str2
return str1
if (devtype == virtinst.VirtualDisk.DEVICE_CDROM or
devtype == virtinst.VirtualDisk.DEVICE_FLOPPY):
if (devtype == virtinst.DeviceDisk.DEVICE_CDROM or
devtype == virtinst.DeviceDisk.DEVICE_FLOPPY):
info = append_str(info, _("Removable"))
if ro:
@ -331,14 +331,14 @@ class vmmCloneVM(vmmGObjectUI):
net_type = net.type
# Generate a new MAC
newmac = VirtualNetworkInterface.generate_mac(
newmac = DeviceInterface.generate_mac(
self.conn.get_backend())
# [ interface type, device name, origmac, newmac, label ]
if net_type == VirtualNetworkInterface.TYPE_USER:
if net_type == DeviceInterface.TYPE_USER:
label = _("Usermode")
elif net_type == VirtualNetworkInterface.TYPE_VIRTUAL:
elif net_type == DeviceInterface.TYPE_VIRTUAL:
net = None
for netobj in self.vm.conn.list_nets():
if netobj.get_name() == net_dev:
@ -525,9 +525,9 @@ class vmmCloneVM(vmmGObjectUI):
# Build icon
icon = Gtk.Image()
if devtype == virtinst.VirtualDisk.DEVICE_FLOPPY:
if devtype == virtinst.DeviceDisk.DEVICE_FLOPPY:
iconname = "media-floppy"
elif devtype == virtinst.VirtualDisk.DEVICE_CDROM:
elif devtype == virtinst.DeviceDisk.DEVICE_CDROM:
iconname = "media-optical"
else:
iconname = "drive-harddisk"
@ -712,7 +712,7 @@ class vmmCloneVM(vmmGObjectUI):
row = self.net_list[orig]
try:
ignore, msg = VirtualNetworkInterface.is_conflict_net(
ignore, msg = DeviceInterface.is_conflict_net(
self.conn.get_backend(), new)
if msg:
raise RuntimeError(msg)
@ -742,7 +742,7 @@ class vmmCloneVM(vmmGObjectUI):
new_path = self.widget("change-storage-new").get_text()
if virtinst.VirtualDisk.path_definitely_exists(self.clone_design.conn,
if virtinst.DeviceDisk.path_definitely_exists(self.clone_design.conn,
new_path):
res = self.err.yes_no(_("Cloning will overwrite the existing "
"file"),

6
virtManager/connection.py
View File

@ -189,7 +189,7 @@ class vmmConnection(vmmGObject):
vmmGObject.__init__(self)
self._state = self._STATE_DISCONNECTED
self._backend = virtinst.VirtualConnection(self._uri)
self._backend = virtinst.VirtinstConnection(self._uri)
self._closing = False
# Error strings are stored here if open() fails
@ -449,9 +449,9 @@ class vmmConnection(vmmGObject):
#######################
for _supportname in [_supportname for _supportname in
dir(virtinst.VirtualConnection) if
dir(virtinst.VirtinstConnection) if
_supportname.startswith("SUPPORT_")]:
locals()[_supportname] = getattr(virtinst.VirtualConnection,
locals()[_supportname] = getattr(virtinst.VirtinstConnection,
_supportname)
def check_support(self, *args):
# pylint: disable=no-value-for-parameter

12
virtManager/create.py
View File

@ -1643,9 +1643,9 @@ class vmmCreate(vmmGObjectUI):
expand = (ntype != "network" and ntype != "bridge")
no_network = ntype is None
if (no_network or ntype == virtinst.VirtualNetworkInterface.TYPE_USER):
if (no_network or ntype == virtinst.DeviceInterface.TYPE_USER):
can_pxe = False
elif ntype != virtinst.VirtualNetworkInterface.TYPE_VIRTUAL:
elif ntype != virtinst.DeviceInterface.TYPE_VIRTUAL:
can_pxe = True
else:
can_pxe = self.conn.get_net(connkey).can_pxe()
@ -2000,7 +2000,7 @@ class vmmCreate(vmmGObjectUI):
return self.err.val_err(
_("A storage path to import is required."))
if not virtinst.VirtualDisk.path_definitely_exists(
if not virtinst.DeviceDisk.path_definitely_exists(
self.conn.get_backend(),
import_path):
return self.err.val_err(_("The import path must point to "
@ -2086,13 +2086,13 @@ class vmmCreate(vmmGObjectUI):
self._guest.os.init = init
if fs:
fsdev = virtinst.VirtualFilesystem(self._guest.conn)
fsdev = virtinst.DeviceFilesystem(self._guest.conn)
fsdev.target = "/"
fsdev.source = fs
self._guest.add_device(fsdev)
if template:
fsdev = virtinst.VirtualFilesystem(self._guest.conn)
fsdev = virtinst.DeviceFilesystem(self._guest.conn)
fsdev.target = "/"
fsdev.type = "template"
fsdev.source = template
@ -2291,7 +2291,7 @@ class vmmCreate(vmmGObjectUI):
_("Network device required for %s install.") %
methname)
macaddr = virtinst.VirtualNetworkInterface.generate_mac(
macaddr = virtinst.DeviceInterface.generate_mac(
self.conn.get_backend())
nic = self._netlist.validate_network(macaddr)
if nic is False:

2
virtManager/delete.py
View File

@ -402,7 +402,7 @@ def do_we_default(conn, vm_name, vol, path, ro, shared, is_media):
info = append_str(info, _("Storage is a media device."))
try:
names = virtinst.VirtualDisk.path_in_use_by(conn.get_backend(), path)
names = virtinst.DeviceDisk.path_in_use_by(conn.get_backend(), path)
if len(names) > 1:
namestr = ""

26
virtManager/details.py
View File

@ -28,7 +28,7 @@ import libvirt
import virtinst
from virtinst import util
from virtinst import VirtualRNGDevice
from virtinst import DeviceRng
from . import vmmenu
from . import uiutil
@ -167,7 +167,7 @@ def _label_for_device(dev):
devtype = dev.virtual_device_type
if devtype == "disk":
busstr = virtinst.VirtualDisk.pretty_disk_bus(dev.bus) or ""
busstr = virtinst.DeviceDisk.pretty_disk_bus(dev.bus) or ""
if dev.device == "floppy":
devstr = _("Floppy")
@ -2614,8 +2614,8 @@ class vmmDetails(vmmGObjectUI):
if vol:
size = vol.get_pretty_capacity()
is_cdrom = (devtype == virtinst.VirtualDisk.DEVICE_CDROM)
is_floppy = (devtype == virtinst.VirtualDisk.DEVICE_FLOPPY)
is_cdrom = (devtype == virtinst.DeviceDisk.DEVICE_CDROM)
is_floppy = (devtype == virtinst.DeviceDisk.DEVICE_FLOPPY)
is_usb = (bus == "usb")
can_set_removable = (is_usb and (self.conn.is_qemu() or
@ -2637,7 +2637,7 @@ class vmmDetails(vmmGObjectUI):
uiutil.set_grid_row_visible(self.widget("disk-removable"),
can_set_removable)
is_lun = disk.device == virtinst.VirtualDisk.DEVICE_LUN
is_lun = disk.device == virtinst.DeviceDisk.DEVICE_LUN
uiutil.set_grid_row_visible(self.widget("disk-sgio"), is_lun)
if is_lun:
self.build_disk_sgio(self.vm, self.widget("disk-sgio"))
@ -2765,7 +2765,7 @@ class vmmDetails(vmmGObjectUI):
dev_type = tpmdev.type
self.widget("tpm-dev-type").set_text(
virtinst.VirtualTPMDevice.get_pretty_type(dev_type))
virtinst.DeviceTpm.get_pretty_type(dev_type))
# Device type specific properties, only show if apply to the cur dev
show_ui("device_path")
@ -2776,7 +2776,7 @@ class vmmDetails(vmmGObjectUI):
return
model = dev.model or "isa"
pmodel = virtinst.VirtualPanicDevice.get_pretty_model(model)
pmodel = virtinst.DevicePanic.get_pretty_model(model)
self.widget("panic-model").set_text(pmodel)
def refresh_rng_page(self):
@ -2794,17 +2794,17 @@ class vmmDetails(vmmGObjectUI):
}
rewriter = {
"rng-type": lambda x:
VirtualRNGDevice.get_pretty_type(x),
DeviceRng.get_pretty_type(x),
"rng-backend-type": lambda x:
VirtualRNGDevice.get_pretty_backend_type(x),
DeviceRng.get_pretty_backend_type(x),
}
def set_visible(widget, v):
uiutil.set_grid_row_visible(self.widget(widget), v)
is_egd = dev.type == VirtualRNGDevice.TYPE_EGD
udp = dev.backend_type == VirtualRNGDevice.BACKEND_TYPE_UDP
bind = VirtualRNGDevice.BACKEND_MODE_BIND in dev.backend_mode()
is_egd = dev.type == DeviceRng.TYPE_EGD
udp = dev.backend_type == DeviceRng.BACKEND_TYPE_UDP
bind = DeviceRng.BACKEND_MODE_BIND in dev.backend_mode()
set_visible("rng-device", not is_egd)
set_visible("rng-mode", is_egd and not udp)
@ -2826,7 +2826,7 @@ class vmmDetails(vmmGObjectUI):
uiutil.set_grid_row_visible(self.widget(k), val != "-")
if is_egd and not udp:
mode = VirtualRNGDevice.get_pretty_mode(dev.backend_mode()[0])
mode = DeviceRng.get_pretty_mode(dev.backend_mode()[0])
self.widget("rng-mode").set_text(mode)
def refresh_char_page(self):

18
virtManager/domain.py
View File

@ -29,8 +29,8 @@ from virtinst import DomainCapabilities
from virtinst import DomainSnapshot
from virtinst import Guest
from virtinst import util
from virtinst import VirtualController
from virtinst import VirtualDisk
from virtinst import DeviceController
from virtinst import DeviceDisk
from .libvirtobject import vmmLibvirtObject
from .libvirtenummap import LibvirtEnumMap
@ -484,14 +484,14 @@ class vmmDomain(vmmLibvirtObject):
We need to do this copy magic because there is no Libvirt storage API
to rename storage volume.
"""
old_nvram = VirtualDisk(self.conn.get_backend())
old_nvram = DeviceDisk(self.conn.get_backend())
old_nvram.path = self.get_xmlobj().os.nvram
nvram_dir = os.path.dirname(old_nvram.path)
new_nvram_path = os.path.join(nvram_dir, "%s_VARS.fd" % new_name)
new_nvram = VirtualDisk(self.conn.get_backend())
new_nvram = DeviceDisk(self.conn.get_backend())
nvram_install = VirtualDisk.build_vol_install(
nvram_install = DeviceDisk.build_vol_install(
self.conn.get_backend(), os.path.basename(new_nvram_path),
old_nvram.get_parent_pool(), old_nvram.get_size(), False)
nvram_install.input_vol = old_nvram.get_vol_object()
@ -930,16 +930,16 @@ class vmmDomain(vmmLibvirtObject):
if editdev.type == "usb":
ctrls = xmlobj.get_devices("controller")
ctrls = [x for x in ctrls if (x.type ==
VirtualController.TYPE_USB)]
DeviceController.TYPE_USB)]
for dev in ctrls:
xmlobj.remove_device(dev)
if model == "ich9-ehci1":
for dev in VirtualController.get_usb2_controllers(
for dev in DeviceController.get_usb2_controllers(
xmlobj.conn):
xmlobj.add_device(dev)
else:
dev = VirtualController(xmlobj.conn)
dev = DeviceController(xmlobj.conn)
dev.type = "usb"
dev.model = model
xmlobj.add_device(dev)
@ -1332,7 +1332,7 @@ class vmmDomain(vmmLibvirtObject):
devs = self._build_device_list("disk", refresh_if_nec, inactive)
# Iterate through all disks and calculate what number they are
# HACK: We are making a variable in VirtualDisk to store the index
# HACK: We are making a variable in DeviceDisk to store the index
idx_mapping = {}
for dev in devs:
devtype = dev.device

66
virtManager/fsdetails.py
View File

@ -21,7 +21,7 @@
from gi.repository import Gtk
from virtinst import VirtualFilesystem, StorageVolume
from virtinst import DeviceFilesystem, StorageVolume
from . import uiutil
from .baseclass import vmmGObjectUI
from .storagebrowse import vmmStorageBrowser
@ -100,35 +100,35 @@ class vmmFSDetails(vmmGObjectUI):
# Filesystem widgets
if self.conn.is_openvz():
simple_store_set("fs-type-combo",
[VirtualFilesystem.TYPE_MOUNT,
VirtualFilesystem.TYPE_TEMPLATE], sort=False)
[DeviceFilesystem.TYPE_MOUNT,
DeviceFilesystem.TYPE_TEMPLATE], sort=False)
elif self.conn.is_lxc():
simple_store_set("fs-type-combo",
[VirtualFilesystem.TYPE_MOUNT,
VirtualFilesystem.TYPE_FILE,
VirtualFilesystem.TYPE_BLOCK,
VirtualFilesystem.TYPE_RAM], sort=False)
[DeviceFilesystem.TYPE_MOUNT,
DeviceFilesystem.TYPE_FILE,
DeviceFilesystem.TYPE_BLOCK,
DeviceFilesystem.TYPE_RAM], sort=False)
else:
simple_store_set("fs-type-combo", [VirtualFilesystem.TYPE_MOUNT])
self.widget("fs-type-label").set_text(VirtualFilesystem.TYPE_MOUNT)
simple_store_set("fs-type-combo", [DeviceFilesystem.TYPE_MOUNT])
self.widget("fs-type-label").set_text(DeviceFilesystem.TYPE_MOUNT)
simple_store_set("fs-mode-combo", VirtualFilesystem.MODES)
simple_store_set("fs-mode-combo", DeviceFilesystem.MODES)
if self.conn.is_qemu() or self.conn.is_test():
simple_store_set("fs-driver-combo",
[VirtualFilesystem.DRIVER_PATH,
VirtualFilesystem.DRIVER_HANDLE,
VirtualFilesystem.DRIVER_DEFAULT])
[DeviceFilesystem.DRIVER_PATH,
DeviceFilesystem.DRIVER_HANDLE,
DeviceFilesystem.DRIVER_DEFAULT])
elif self.conn.is_lxc():
simple_store_set("fs-driver-combo",
[VirtualFilesystem.DRIVER_LOOP,
VirtualFilesystem.DRIVER_NBD,
VirtualFilesystem.DRIVER_DEFAULT])
[DeviceFilesystem.DRIVER_LOOP,
DeviceFilesystem.DRIVER_NBD,
DeviceFilesystem.DRIVER_DEFAULT])
else:
simple_store_set("fs-driver-combo",
[VirtualFilesystem.DRIVER_DEFAULT])
[DeviceFilesystem.DRIVER_DEFAULT])
simple_store_set("fs-format-combo",
StorageVolume.ALL_FORMATS, capitalize=False)
simple_store_set("fs-wrpolicy-combo", VirtualFilesystem.WRPOLICIES)
simple_store_set("fs-wrpolicy-combo", DeviceFilesystem.WRPOLICIES)
self.show_pair_combo("fs-type",
self.conn.is_openvz() or self.conn.is_lxc())
self.show_check_button("fs-readonly",
@ -186,7 +186,7 @@ class vmmFSDetails(vmmGObjectUI):
self.set_config_value("fs-driver", dev.driver or "default")
self.set_config_value("fs-wrpolicy", dev.wrpolicy or "default")
self.set_config_value("fs-format", dev.format or "default")
if dev.type != VirtualFilesystem.TYPE_RAM:
if dev.type != DeviceFilesystem.TYPE_RAM:
self.widget("fs-source").set_text(dev.source)
else:
self.widget("fs-ram-source-spin").set_value(int(dev.source) // 1024)
@ -221,35 +221,35 @@ class vmmFSDetails(vmmGObjectUI):
fstype = self.get_config_fs_type()
fsdriver = self.get_config_fs_driver()
ismount = bool(
fstype == VirtualFilesystem.TYPE_MOUNT or
fstype == DeviceFilesystem.TYPE_MOUNT or
self.conn.is_qemu() or self.conn.is_test())
show_mode = bool(ismount and
(fsdriver == VirtualFilesystem.DRIVER_PATH or
fsdriver == VirtualFilesystem.DRIVER_DEFAULT))
(fsdriver == DeviceFilesystem.DRIVER_PATH or
fsdriver == DeviceFilesystem.DRIVER_DEFAULT))
uiutil.set_grid_row_visible(self.widget("fs-mode-box"), show_mode)
show_wrpol = bool(ismount and
fsdriver and (fsdriver == VirtualFilesystem.DRIVER_PATH or
fsdriver == VirtualFilesystem.DRIVER_HANDLE))
fsdriver and (fsdriver == DeviceFilesystem.DRIVER_PATH or
fsdriver == DeviceFilesystem.DRIVER_HANDLE))
uiutil.set_grid_row_visible(self.widget("fs-wrpolicy-box"),
show_wrpol)
show_ram_source = fstype == VirtualFilesystem.TYPE_RAM
show_ram_source = fstype == DeviceFilesystem.TYPE_RAM
uiutil.set_grid_row_visible(
self.widget("fs-ram-source-box"), show_ram_source)
uiutil.set_grid_row_visible(
self.widget("fs-source-box"), not show_ram_source)
show_format = bool(
fsdriver == VirtualFilesystem.DRIVER_NBD)
fsdriver == DeviceFilesystem.DRIVER_NBD)
uiutil.set_grid_row_visible(self.widget("fs-format-box"), show_format)
self.show_pair_combo("fs-format", True)
show_mode_combo = False
show_driver_combo = False
show_wrpolicy_combo = self.conn.is_qemu() or self.conn.is_test()
if fstype == VirtualFilesystem.TYPE_TEMPLATE:
if fstype == DeviceFilesystem.TYPE_TEMPLATE:
source_text = _("Te_mplate:")
else:
source_text = _("_Source path:")
@ -281,17 +281,17 @@ class vmmFSDetails(vmmGObjectUI):
fsformat = self.get_config_fs_format()
wrpolicy = self.get_config_fs_wrpolicy()
if not source and fstype != VirtualFilesystem.TYPE_RAM:
if not source and fstype != DeviceFilesystem.TYPE_RAM:
return self.err.val_err(_("A filesystem source must be specified"))
elif usage == 0 and fstype == VirtualFilesystem.TYPE_RAM:
elif usage == 0 and fstype == DeviceFilesystem.TYPE_RAM:
return self.err.val_err(
_("A RAM filesystem usage must be specified"))
if not target:
return self.err.val_err(_("A filesystem target must be specified"))
try:
self._dev = VirtualFilesystem(conn)
if fstype == VirtualFilesystem.TYPE_RAM:
self._dev = DeviceFilesystem(conn)
if fstype == DeviceFilesystem.TYPE_RAM:
self._dev.source = usage
self._dev.units = 'MiB'
else:
@ -305,9 +305,9 @@ class vmmFSDetails(vmmGObjectUI):
self._dev.readonly = readonly
if driver:
self._dev.driver = driver
if driver == VirtualFilesystem.DRIVER_LOOP:
if driver == DeviceFilesystem.DRIVER_LOOP:
self._dev.format = "raw"
elif driver == VirtualFilesystem.DRIVER_NBD:
elif driver == DeviceFilesystem.DRIVER_NBD:
self._dev.format = fsformat
if wrpolicy:
self._dev.wrpolicy = wrpolicy

4
virtManager/gfxdetails.py
View File

@ -106,9 +106,9 @@ class vmmGraphicsDetails(vmmGObjectUI):
uiutil.init_combo_text_column(combo, 1)
model.append(["auto", _("Auto")])
model.append([virtinst.VirtualGraphics.KEYMAP_LOCAL,
model.append([virtinst.DeviceGraphics.KEYMAP_LOCAL,
_("Copy local keymap")])
for k in virtinst.VirtualGraphics.valid_keymaps():
for k in virtinst.DeviceGraphics.valid_keymaps():
model.append([k, k])
# Host GPU rendernode

24
virtManager/netlist.py
View File

@ -104,13 +104,13 @@ class vmmNetworkList(vmmGObjectUI):
self.conn.connect("interface-removed", self._repopulate_network_list)
def _pretty_network_desc(self, nettype, source=None, netobj=None):
if nettype == virtinst.VirtualNetworkInterface.TYPE_USER:
if nettype == virtinst.DeviceInterface.TYPE_USER:
return _("Usermode networking")
extra = None
if nettype == virtinst.VirtualNetworkInterface.TYPE_BRIDGE:
if nettype == virtinst.DeviceInterface.TYPE_BRIDGE:
ret = _("Bridge")
elif nettype == virtinst.VirtualNetworkInterface.TYPE_VIRTUAL:
elif nettype == virtinst.DeviceInterface.TYPE_VIRTUAL:
ret = _("Virtual network")
if netobj:
extra = ": %s" % netobj.pretty_forward_mode()
@ -136,7 +136,7 @@ class vmmNetworkList(vmmGObjectUI):
default_label = None
for net in self.conn.list_nets():
nettype = virtinst.VirtualNetworkInterface.TYPE_VIRTUAL
nettype = virtinst.DeviceInterface.TYPE_VIRTUAL
label = self._pretty_network_desc(nettype, net.get_name(), net)
if not net.is_active():
@ -206,7 +206,7 @@ class vmmNetworkList(vmmGObjectUI):
label = _("Host device %s") % (name)
if is_bridge:
nettype = virtinst.VirtualNetworkInterface.TYPE_BRIDGE
nettype = virtinst.DeviceInterface.TYPE_BRIDGE
if slave_names:
extra = (_("Host device %s") % slave_names[0])
can_default = True
@ -216,7 +216,7 @@ class vmmNetworkList(vmmGObjectUI):
elif self.conn.check_support(
self.conn.SUPPORT_CONN_DIRECT_INTERFACE):
nettype = virtinst.VirtualNetworkInterface.TYPE_DIRECT
nettype = virtinst.DeviceInterface.TYPE_DIRECT
label += (": %s" % _("macvtap"))
else:
@ -244,7 +244,7 @@ class vmmNetworkList(vmmGObjectUI):
model.append(manual_row)
if self.conn.is_qemu_session():
nettype = virtinst.VirtualNetworkInterface.TYPE_USER
nettype = virtinst.DeviceInterface.TYPE_USER
r = self._build_source_row(
nettype, None, self._pretty_network_desc(nettype), True, True)
model.append(r)
@ -309,7 +309,7 @@ class vmmNetworkList(vmmGObjectUI):
net_check_bridge = row[5]
if net_check_bridge and bridge_entry:
net_type = virtinst.VirtualNetworkInterface.TYPE_BRIDGE
net_type = virtinst.DeviceInterface.TYPE_BRIDGE
net_src = bridge_entry.get_text() or None
mode = None
@ -341,7 +341,7 @@ class vmmNetworkList(vmmGObjectUI):
# Make sure VirtualNetwork is running
netobj = None
if nettype == virtinst.VirtualNetworkInterface.TYPE_VIRTUAL:
if nettype == virtinst.DeviceInterface.TYPE_VIRTUAL:
for net in self.conn.list_nets():
if net.get_name() == devname:
netobj = net
@ -365,7 +365,7 @@ class vmmNetworkList(vmmGObjectUI):
# Create network device
try:
net = virtinst.VirtualNetworkInterface(self.conn.get_backend())
net = virtinst.DeviceInterface(self.conn.get_backend())
net.type = nettype
net.source = devname
net.macaddr = macaddr
@ -526,7 +526,7 @@ class vmmNetworkList(vmmGObjectUI):
return
is_openvswitch = row[2].endswith("(OpenVSwitch)")
is_direct = (row[0] == virtinst.VirtualNetworkInterface.TYPE_DIRECT)
is_direct = (row[0] == virtinst.DeviceInterface.TYPE_DIRECT)
self.widget("vport-expander").set_visible(is_direct or is_openvswitch)
uiutil.set_grid_row_visible(self.widget("net-source-mode"), is_direct)
uiutil.set_grid_row_visible(
@ -540,7 +540,7 @@ class vmmNetworkList(vmmGObjectUI):
portgroups = []
connkey = row[6]
if connkey and row[0] == virtinst.VirtualNetworkInterface.TYPE_VIRTUAL:
if connkey and row[0] == virtinst.DeviceInterface.TYPE_VIRTUAL:
portgroups = self.conn.get_net(connkey).get_xmlobj().portgroups
uiutil.set_grid_row_visible(

4
virtManager/storagelist.py
View File

@ -23,7 +23,7 @@ from gi.repository import Gdk
from gi.repository import Gtk
from virtinst import StoragePool
from virtinst import VirtualDisk
from virtinst import DeviceDisk
from . import uiutil
from .asyncjob import vmmAsyncJob
@ -430,7 +430,7 @@ class vmmStorageList(vmmGObjectUI):
namestr = None
try:
if path:
names = VirtualDisk.path_in_use_by(vol.conn.get_backend(),
names = DeviceDisk.path_in_use_by(vol.conn.get_backend(),
path)
namestr = ", ".join(names)
if not namestr:

4
virtconv/ovf.py
View File

@ -216,7 +216,7 @@ def _import_file(conn, input_file):
ifaces = []
for node in _findall(vhnode, vhxpath % DEVICE_ETHERNET):
iface = virtinst.VirtualNetworkInterface(conn)
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():
@ -236,7 +236,7 @@ def _import_file(conn, input_file):
path = _lookup_disk_path(root, path)
fmt = "vmdk"
disk = virtinst.VirtualDisk(conn)
disk = virtinst.DeviceDisk(conn)
disk.path = path
disk.driver_type = fmt
disk.bus = bus

4
virtconv/vmx.py
View File

@ -148,7 +148,7 @@ def parse_netdev_entry(conn, ifaces, fullkey, value):
net = checkiface
break
if not net:
net = virtinst.VirtualNetworkInterface(conn)
net = virtinst.DeviceInterface(conn)
setattr(net, "vmx_inst", inst)
net.set_default_source()
ifaces.append(net)
@ -195,7 +195,7 @@ def parse_disk_entry(conn, disks, fullkey, value, topdir):
disk = checkdisk
break
if not disk:
disk = virtinst.VirtualDisk(conn)
disk = virtinst.DeviceDisk(conn)
disk.bus = bus
setattr(disk, "vmx_inst", inst)
disks.append(disk)

44
virtinst/__init__.py
View File

@ -62,27 +62,27 @@ from virtinst.network import Network
from virtinst.nodedev import NodeDevice
from virtinst.storage import StoragePool, StorageVolume
from virtinst.device import VirtualDevice
from virtinst.deviceinterface import VirtualNetworkInterface
from virtinst.devicegraphics import VirtualGraphics
from virtinst.deviceaudio import VirtualAudio
from virtinst.deviceinput import VirtualInputDevice
from virtinst.devicedisk import VirtualDisk
from virtinst.devicehostdev import VirtualHostDevice
from virtinst.devicechar import (VirtualChannelDevice,
VirtualConsoleDevice,
VirtualParallelDevice,
VirtualSerialDevice)
from virtinst.devicevideo import VirtualVideoDevice
from virtinst.devicecontroller import VirtualController
from virtinst.devicewatchdog import VirtualWatchdog
from virtinst.devicefilesystem import VirtualFilesystem
from virtinst.devicesmartcard import VirtualSmartCardDevice
from virtinst.deviceredirdev import VirtualRedirDevice
from virtinst.devicememballoon import VirtualMemballoon
from virtinst.devicetpm import VirtualTPMDevice
from virtinst.devicerng import VirtualRNGDevice
from virtinst.devicepanic import VirtualPanicDevice
from virtinst.device import Device
from virtinst.deviceinterface import DeviceInterface
from virtinst.devicegraphics import DeviceGraphics
from virtinst.deviceaudio import DeviceSound
from virtinst.deviceinput import DeviceInput
from virtinst.devicedisk import DeviceDisk
from virtinst.devicehostdev import DeviceHostdev
from virtinst.devicechar import (DeviceChannel,
DeviceConsole,
DeviceParallel,
DeviceSerial)
from virtinst.devicevideo import DeviceVideo
from virtinst.devicecontroller import DeviceController
from virtinst.devicewatchdog import DeviceWatchdog
from virtinst.devicefilesystem import DeviceFilesystem
from virtinst.devicesmartcard import DeviceSmartcard
from virtinst.deviceredirdev import DeviceRedirdev
from virtinst.devicememballoon import DeviceMemballoon
from virtinst.devicetpm import DeviceTpm
from virtinst.devicerng import DeviceRng
from virtinst.devicepanic import DevicePanic
from virtinst.installer import (ContainerInstaller, ImportInstaller,
PXEInstaller, Installer)
@ -93,4 +93,4 @@ from virtinst.guest import Guest
from virtinst.cloner import Cloner
from virtinst.snapshot import DomainSnapshot
from virtinst.connection import VirtualConnection
from virtinst.connection import VirtinstConnection

110
virtinst/cli.py
View File

@ -38,25 +38,25 @@ from . import util
from .clock import Clock
from .cpu import CPU
from .cputune import CPUTune
from .deviceaudio import VirtualAudio
from .devicechar import (VirtualChannelDevice, VirtualConsoleDevice,
VirtualSerialDevice, VirtualParallelDevice)
from .devicecontroller import VirtualController
from .devicedisk import VirtualDisk
from .devicefilesystem import VirtualFilesystem
from .devicegraphics import VirtualGraphics
from .devicehostdev import VirtualHostDevice
from .deviceinput import VirtualInputDevice
from .deviceinterface import VirtualNetworkInterface
from .devicememballoon import VirtualMemballoon
from .devicememory import VirtualMemoryDevice
from .devicepanic import VirtualPanicDevice
from .deviceredirdev import VirtualRedirDevice
from .devicerng import VirtualRNGDevice
from .devicesmartcard import VirtualSmartCardDevice
from .devicetpm import VirtualTPMDevice
from .devicevideo import VirtualVideoDevice
from .devicewatchdog import VirtualWatchdog
from .deviceaudio import DeviceSound
from .devicechar import (DeviceChannel, DeviceConsole,
DeviceSerial, DeviceParallel)
from .devicecontroller import DeviceController
from .devicedisk import DeviceDisk
from .devicefilesystem import DeviceFilesystem
from .devicegraphics import DeviceGraphics
from .devicehostdev import DeviceHostdev
from .deviceinput import DeviceInput
from .deviceinterface import DeviceInterface
from .devicememballoon import DeviceMemballoon
from .devicememory import DeviceMemory
from .devicepanic import DevicePanic
from .deviceredirdev import DeviceRedirdev
from .devicerng import DeviceRng
from .devicesmartcard import DeviceSmartcard
from .devicetpm import DeviceTpm
from .devicevideo import DeviceVideo
from .devicewatchdog import DeviceWatchdog
from .domainblkiotune import DomainBlkiotune
from .domainfeatures import DomainFeatures
from .domainmemorybacking import DomainMemorybacking
@ -277,10 +277,10 @@ def _in_testsuite():
##############################
def getConnection(uri):
from .connection import VirtualConnection
from .connection import VirtinstConnection
logging.debug("Requesting libvirt URI %s", (uri or "default"))
conn = VirtualConnection(uri)
conn = VirtinstConnection(uri)
conn.open(_do_creds_authname)
logging.debug("Received libvirt URI %s", conn.uri)
@ -383,7 +383,7 @@ def validate_disk(dev, warn_overwrite=False):
"""
if not warn_overwrite:
return
if not VirtualDisk.path_definitely_exists(dev.conn, dev.path):
if not DeviceDisk.path_definitely_exists(dev.conn, dev.path):
return
_optional_fail(
_("This will overwrite the existing path '%s'") % dev.path,
@ -490,8 +490,8 @@ def get_console_cb(guest):
gtype = gdevs[0].type
if gtype not in ["default",
VirtualGraphics.TYPE_VNC,
VirtualGraphics.TYPE_SPICE]:
DeviceGraphics.TYPE_VNC,
DeviceGraphics.TYPE_SPICE]:
logging.debug("No viewer to launch for graphics type '%s'", gtype)
return
@ -841,7 +841,7 @@ class _VirtCLIArgumentStatic(object):
form FOO=BAR, but just FOO.
@find_inst_cb: If specified, this can be used to return a different
'inst' to check and set attributes against. For example,
VirtualDisk has multiple seclabel children, this provides a hook
DeviceDisk has multiple seclabel children, this provides a hook
to lookup the specified child object.
"""
def __init__(self, attrname, cliname,
@ -1213,7 +1213,7 @@ class VirtCLIParser(object):
self.optdict into 'inst'.
For virt-xml, 'inst' is the virtinst object we are editing,
ex. a VirtualDisk from a parsed Guest object.
ex. a DeviceDisk from a parsed Guest object.
For virt-install, 'inst' is None, and we will create a new
inst from self.objclass, or edit a singleton object in place
like Guest.features/DomainFeatures
@ -1957,7 +1957,7 @@ ParserQemuCLI.add_arg(None, "env", cb=ParserQemuCLI.env_cb, can_comma=True)
def _add_device_address_args(cls):
"""
Add VirtualDeviceAddress parameters if we are parsing for a device
Add DeviceAddress parameters if we are parsing for a device
"""
cls.add_arg("address.type", "address.type")
cls.add_arg("address.domain", "address.domain")
@ -2012,7 +2012,7 @@ def _generate_new_volume_name(guest, poolobj, fmt):
class ParserDisk(VirtCLIParser):
cli_arg_name = "disk"
objclass = VirtualDisk
objclass = DeviceDisk
remove_first = "path"
stub_none = False
@ -2104,7 +2104,7 @@ class ParserDisk(VirtCLIParser):
if newvolname is None:
newvolname = _generate_new_volume_name(self.guest, poolobj,
fmt)
vol_install = VirtualDisk.build_vol_install(
vol_install = DeviceDisk.build_vol_install(
self.guest.conn, newvolname, poolobj, size, sparse,
fmt=fmt, backing_store=backing_store,
backing_format=backing_format)
@ -2168,7 +2168,7 @@ ParserDisk.add_arg("sgio", "sgio")
ParserDisk.add_arg("logical_block_size", "logical_block_size")
ParserDisk.add_arg("physical_block_size", "physical_block_size")
# VirtualDisk.seclabels properties
# DeviceDisk.seclabels properties
ParserDisk.add_arg("model", "seclabel[0-9]*.model",
find_inst_cb=ParserDisk.seclabel_find_inst_cb)
ParserDisk.add_arg("relabel", "seclabel[0-9]*.relabel", is_onoff=True,
@ -2183,7 +2183,7 @@ ParserDisk.add_arg("label", "seclabel[0-9]*.label", can_comma=True,
class ParserNetwork(VirtCLIParser):
cli_arg_name = "network"
objclass = VirtualNetworkInterface
objclass = DeviceInterface
remove_first = "type"
stub_none = False
@ -2218,10 +2218,10 @@ class ParserNetwork(VirtCLIParser):
if "type" not in self.optdict:
if "network" in self.optdict:
self.optdict["type"] = VirtualNetworkInterface.TYPE_VIRTUAL
self.optdict["type"] = DeviceInterface.TYPE_VIRTUAL
self.optdict["source"] = self.optdict.pop("network")
elif "bridge" in self.optdict:
self.optdict["type"] = VirtualNetworkInterface.TYPE_BRIDGE
self.optdict["type"] = DeviceInterface.TYPE_BRIDGE
self.optdict["source"] = self.optdict.pop("bridge")
return VirtCLIParser._parse(self, inst)
@ -2270,7 +2270,7 @@ ParserNetwork.add_arg("virtualport.interfaceid", "virtualport_interfaceid")
class ParserGraphics(VirtCLIParser):
cli_arg_name = "graphics"
objclass = VirtualGraphics
objclass = DeviceGraphics
remove_first = "type"
stub_none = False
@ -2280,7 +2280,7 @@ class ParserGraphics(VirtCLIParser):
if not val:
val = None
elif val.lower() == "local":
val = VirtualGraphics.KEYMAP_LOCAL
val = DeviceGraphics.KEYMAP_LOCAL
elif val.lower() == "none":
val = None
else:
@ -2371,7 +2371,7 @@ ParserGraphics.add_arg("rendernode", "rendernode")
class ParserController(VirtCLIParser):
cli_arg_name = "controller"
objclass = VirtualController
objclass = DeviceController
remove_first = "type"
def set_server_cb(self, inst, val, virtarg):
@ -2379,7 +2379,7 @@ class ParserController(VirtCLIParser):
def _parse(self, inst):
if self.optstr == "usb2":
return VirtualController.get_usb2_controllers(inst.conn)
return DeviceController.get_usb2_controllers(inst.conn)
elif self.optstr == "usb3":
inst.type = "usb"
inst.model = "nec-xhci"
@ -2403,7 +2403,7 @@ ParserController.add_arg(None, "address", cb=ParserController.set_server_cb)
class ParserInput(VirtCLIParser):
cli_arg_name = "input"
objclass = VirtualInputDevice
objclass = DeviceInput
remove_first = "type"
_register_virt_parser(ParserInput)
@ -2418,7 +2418,7 @@ ParserInput.add_arg("bus", "bus")
class ParserSmartcard(VirtCLIParser):
cli_arg_name = "smartcard"
objclass = VirtualSmartCardDevice
objclass = DeviceSmartcard
remove_first = "mode"
_register_virt_parser(ParserSmartcard)
@ -2433,7 +2433,7 @@ ParserSmartcard.add_arg("type", "type")
class ParserRedir(VirtCLIParser):
cli_arg_name = "redirdev"
objclass = VirtualRedirDevice
objclass = DeviceRedirdev
remove_first = "bus"
stub_none = False
@ -2460,7 +2460,7 @@ ParserRedir.add_arg(None, "server", cb=ParserRedir.set_server_cb)
class ParserTPM(VirtCLIParser):
cli_arg_name = "tpm"
objclass = VirtualTPMDevice
objclass = DeviceTpm
remove_first = "type"
def _parse(self, inst):
@ -2481,7 +2481,7 @@ ParserTPM.add_arg("device_path", "path")
class ParserRNG(VirtCLIParser):
cli_arg_name = "rng"
objclass = VirtualRNGDevice
objclass = DeviceRng
remove_first = "type"
stub_none = False
@ -2550,7 +2550,7 @@ ParserRNG.add_arg("rate_period", "rate_period")
class ParserWatchdog(VirtCLIParser):
cli_arg_name = "watchdog"
objclass = VirtualWatchdog
objclass = DeviceWatchdog
remove_first = "model"
_register_virt_parser(ParserWatchdog)
@ -2565,7 +2565,7 @@ ParserWatchdog.add_arg("action", "action")
class ParseMemdev(VirtCLIParser):
cli_arg_name = "memdev"
objclass = VirtualMemoryDevice
objclass = DeviceMemory
remove_first = "model"
def set_target_size(self, inst, val, virtarg):
@ -2589,7 +2589,7 @@ ParseMemdev.add_arg("source.nodemask", "source_nodemask", can_comma=True)
class ParserMemballoon(VirtCLIParser):
cli_arg_name = "memballoon"
objclass = VirtualMemballoon
objclass = DeviceMemballoon
remove_first = "model"
stub_none = False
@ -2604,13 +2604,13 @@ ParserMemballoon.add_arg("model", "model")
class ParserPanic(VirtCLIParser):
cli_arg_name = "panic"
objclass = VirtualPanicDevice
objclass = DevicePanic
remove_first = "model"
compat_mode = False
def set_model_cb(self, inst, val, virtarg):
if self.compat_mode and val.startswith("0x"):
inst.model = VirtualPanicDevice.MODEL_ISA
inst.model = DevicePanic.MODEL_ISA
inst.iobase = val
else:
inst.model = val
@ -2689,25 +2689,25 @@ _ParserChar.add_arg("log_append", "log.append", is_onoff=True)
class ParserSerial(_ParserChar):
cli_arg_name = "serial"
objclass = VirtualSerialDevice
objclass = DeviceSerial
_register_virt_parser(ParserSerial)
class ParserParallel(_ParserChar):
cli_arg_name = "parallel"
objclass = VirtualParallelDevice
objclass = DeviceParallel
_register_virt_parser(ParserParallel)
class ParserChannel(_ParserChar):
cli_arg_name = "channel"
objclass = VirtualChannelDevice
objclass = DeviceChannel
_register_virt_parser(ParserChannel)
class ParserConsole(_ParserChar):
cli_arg_name = "console"
objclass = VirtualConsoleDevice
objclass = DeviceConsole
_register_virt_parser(ParserConsole)
@ -2717,7 +2717,7 @@ _register_virt_parser(ParserConsole)
class ParserFilesystem(VirtCLIParser):
cli_arg_name = "filesystem"
objclass = VirtualFilesystem
objclass = DeviceFilesystem
remove_first = ["source", "target"]
_register_virt_parser(ParserFilesystem)
@ -2734,7 +2734,7 @@ ParserFilesystem.add_arg("target", "target")
class ParserVideo(VirtCLIParser):
cli_arg_name = "video"
objclass = VirtualVideoDevice
objclass = DeviceVideo
remove_first = "model"
def _parse(self, inst):
@ -2768,7 +2768,7 @@ ParserVideo.add_arg("vgamem", "vgamem")
class ParserSound(VirtCLIParser):
cli_arg_name = "sound"
objclass = VirtualAudio
objclass = DeviceSound
remove_first = "model"
stub_none = False
@ -2789,7 +2789,7 @@ ParserSound.add_arg("model", "model", ignore_default=True)
class ParserHostdev(VirtCLIParser):
cli_arg_name = "hostdev"
objclass = VirtualHostDevice
objclass = DeviceHostdev
remove_first = "name"
def set_name_cb(self, inst, val, virtarg):

42
virtinst/cloner.py
View File

@ -27,10 +27,10 @@ import libvirt
from . import util
from .guest import Guest
from .deviceinterface import VirtualNetworkInterface
from .devicedisk import VirtualDisk
from .deviceinterface import DeviceInterface
from .devicedisk import DeviceDisk
from .storage import StorageVolume
from .devicechar import VirtualChannelDevice
from .devicechar import DeviceChannel
class Cloner(object):
@ -126,17 +126,17 @@ class Cloner(object):
disklist = []
for path in util.listify(paths):
try:
device = VirtualDisk.DEVICE_DISK
device = DeviceDisk.DEVICE_DISK
if not path:
device = VirtualDisk.DEVICE_CDROM
device = DeviceDisk.DEVICE_CDROM
disk = VirtualDisk(self.conn)
disk = DeviceDisk(self.conn)
disk.path = path
disk.device = device
if (not self.preserve_dest_disks and
disk.wants_storage_creation()):
vol_install = VirtualDisk.build_vol_install(
vol_install = DeviceDisk.build_vol_install(
self.conn, os.path.basename(disk.path),
disk.get_parent_pool(), .000001, False)
disk.set_vol_install(vol_install)
@ -152,7 +152,7 @@ class Cloner(object):
return [d.path for d in self.clone_disks]
clone_paths = property(get_clone_paths, set_clone_paths)
# VirtualDisk instances for the new disk paths
# DeviceDisk instances for the new disk paths
@property
def clone_disks(self):
return self._clone_disks
@ -161,7 +161,7 @@ class Cloner(object):
def set_clone_macs(self, mac):
maclist = util.listify(mac)
for m in maclist:
msg = VirtualNetworkInterface.is_conflict_net(self.conn, m)[1]
msg = DeviceInterface.is_conflict_net(self.conn, m)[1]
if msg:
raise RuntimeError(msg)
@ -170,7 +170,7 @@ class Cloner(object):
return self._clone_macs
clone_macs = property(get_clone_macs, set_clone_macs)
# VirtualDisk instances of the original disks being cloned
# DeviceDisk instances of the original disks being cloned
@property
def original_disks(self):
return self._original_disks
@ -360,18 +360,18 @@ class Cloner(object):
self.clone_nvram = os.path.join(nvram_dir,
"%s_VARS.fd" % self._clone_name)
nvram = VirtualDisk(self.conn)
nvram = DeviceDisk(self.conn)
nvram.path = self.clone_nvram
if (not self.preserve_dest_disks and
nvram.wants_storage_creation()):
old_nvram = VirtualDisk(self.conn)
old_nvram = DeviceDisk(self.conn)
old_nvram.path = self._guest.os.nvram
if not old_nvram.get_vol_object():
raise RuntimeError(_("Path does not exist: %s") %
old_nvram.path)
nvram_install = VirtualDisk.build_vol_install(
nvram_install = DeviceDisk.build_vol_install(
self.conn, os.path.basename(nvram.path),
nvram.get_parent_pool(), nvram.get_size(), False)
nvram_install.input_vol = old_nvram.get_vol_object()
@ -416,7 +416,7 @@ class Cloner(object):
if clone_macs:
mac = clone_macs.pop()
else:
mac = VirtualNetworkInterface.generate_mac(self.conn)
mac = DeviceInterface.generate_mac(self.conn)
iface.macaddr = mac
# Changing storage XML
@ -439,7 +439,7 @@ class Cloner(object):
# For guest agent channel, remove a path to generate a new one with
# new guest name
for channel in self._guest.get_devices("channel"):
if channel.type == VirtualChannelDevice.TYPE_UNIX:
if channel.type == DeviceChannel.TYPE_UNIX:
channel.source_path = None
if self._guest.os.nvram:
@ -505,7 +505,7 @@ class Cloner(object):
clonebase = os.path.join(dirname, clonebase)
return util.generate_name(
clonebase,
lambda p: VirtualDisk.path_definitely_exists(self.conn, p),
lambda p: DeviceDisk.path_definitely_exists(self.conn, p),
suffix,
lib_collision=False)
@ -534,7 +534,7 @@ class Cloner(object):
############################
# Parse disk paths that need to be cloned from the original guest's xml
# Return a list of VirtualDisk instances pointing to the original
# Return a list of DeviceDisk instances pointing to the original
# storage
def _get_original_disks_info(self):
clonelist = []
@ -550,12 +550,12 @@ class Cloner(object):
validate = not self.preserve_dest_disks
try:
device = VirtualDisk.DEVICE_DISK
device = DeviceDisk.DEVICE_DISK
if not disk.path:
# Tell VirtualDisk we are a cdrom to allow empty media
device = VirtualDisk.DEVICE_CDROM
# Tell DeviceDisk we are a cdrom to allow empty media
device = DeviceDisk.DEVICE_CDROM
newd = VirtualDisk(self.conn)
newd = DeviceDisk(self.conn)
newd.path = disk.path
newd.device = device
newd.driver_name = disk.driver_name

2
virtinst/connection.py
View File

@ -33,7 +33,7 @@ from .storage import StoragePool, StorageVolume
from .uri import URI, MagicURI
class VirtualConnection(object):
class VirtinstConnection(object):
"""
Wrapper for libvirt connection that provides various bits like
- caching static data

100
virtinst/device.py
View File

@ -22,17 +22,17 @@
from .xmlbuilder import XMLBuilder, XMLChildProperty, XMLProperty
class VirtualDeviceAlias(XMLBuilder):
class DeviceAlias(XMLBuilder):
_XML_ROOT_NAME = "alias"
name = XMLProperty("./@name")
class VirtualDeviceBoot(XMLBuilder):
class DeviceBoot(XMLBuilder):
_XML_ROOT_NAME = "boot"
order = XMLProperty("./@order", is_int=True)
class VirtualDeviceAddress(XMLBuilder):
class DeviceAddress(XMLBuilder):
"""
Examples:
<address type='pci' domain='0x0000' bus='0x00' slot='0x04' function='0x0'/>
@ -111,63 +111,63 @@ class VirtualDeviceAddress(XMLBuilder):
base = XMLProperty("./@base")
class VirtualDevice(XMLBuilder):
class Device(XMLBuilder):
"""
Base class for all domain xml device objects.
"""
VIRTUAL_DEV_DISK = "disk"
VIRTUAL_DEV_NET = "interface"
VIRTUAL_DEV_INPUT = "input"
VIRTUAL_DEV_GRAPHICS = "graphics"
VIRTUAL_DEV_AUDIO = "sound"
VIRTUAL_DEV_HOSTDEV = "hostdev"
VIRTUAL_DEV_SERIAL = "serial"
VIRTUAL_DEV_PARALLEL = "parallel"
VIRTUAL_DEV_CHANNEL = "channel"
VIRTUAL_DEV_CONSOLE = "console"
VIRTUAL_DEV_VIDEO = "video"
VIRTUAL_DEV_CONTROLLER = "controller"
VIRTUAL_DEV_WATCHDOG = "watchdog"
VIRTUAL_DEV_FILESYSTEM = "filesystem"
VIRTUAL_DEV_SMARTCARD = "smartcard"
VIRTUAL_DEV_REDIRDEV = "redirdev"
VIRTUAL_DEV_MEMBALLOON = "memballoon"
VIRTUAL_DEV_TPM = "tpm"
VIRTUAL_DEV_RNG = "rng"
VIRTUAL_DEV_PANIC = "panic"
VIRTUAL_DEV_MEMORY = "memory"
DEVICE_DISK = "disk"
DEVICE_NET = "interface"
DEVICE_INPUT = "input"
DEVICE_GRAPHICS = "graphics"
DEVICE_AUDIO = "sound"
DEVICE_HOSTDEV = "hostdev"
DEVICE_SERIAL = "serial"
DEVICE_PARALLEL = "parallel"
DEVICE_CHANNEL = "channel"
DEVICE_CONSOLE = "console"
DEVICE_VIDEO = "video"
DEVICE_CONTROLLER = "controller"
DEVICE_WATCHDOG = "watchdog"
DEVICE_FILESYSTEM = "filesystem"
DEVICE_SMARTCARD = "smartcard"
DEVICE_REDIRDEV = "redirdev"
DEVICE_MEMBALLOON = "memballoon"
DEVICE_TPM = "tpm"
DEVICE_RNG = "rng"
DEVICE_PANIC = "panic"
DEVICE_MEMORY = "memory"
# Ordering in this list is important: it will be the order the
# Guest class outputs XML. So changing this may upset the test suite
virtual_device_types = [VIRTUAL_DEV_DISK,
VIRTUAL_DEV_CONTROLLER,
VIRTUAL_DEV_FILESYSTEM,
VIRTUAL_DEV_NET,
VIRTUAL_DEV_INPUT,
VIRTUAL_DEV_GRAPHICS,
VIRTUAL_DEV_SERIAL,
VIRTUAL_DEV_PARALLEL,
VIRTUAL_DEV_CONSOLE,
VIRTUAL_DEV_CHANNEL,
VIRTUAL_DEV_AUDIO,
VIRTUAL_DEV_VIDEO,
VIRTUAL_DEV_HOSTDEV,
VIRTUAL_DEV_WATCHDOG,
VIRTUAL_DEV_SMARTCARD,
VIRTUAL_DEV_REDIRDEV,
VIRTUAL_DEV_MEMBALLOON,
VIRTUAL_DEV_TPM,
VIRTUAL_DEV_RNG,
VIRTUAL_DEV_PANIC,
VIRTUAL_DEV_MEMORY]
virtual_device_types = [DEVICE_DISK,
DEVICE_CONTROLLER,
DEVICE_FILESYSTEM,
DEVICE_NET,
DEVICE_INPUT,
DEVICE_GRAPHICS,
DEVICE_SERIAL,
DEVICE_PARALLEL,
DEVICE_CONSOLE,
DEVICE_CHANNEL,
DEVICE_AUDIO,
DEVICE_VIDEO,
DEVICE_HOSTDEV,
DEVICE_WATCHDOG,
DEVICE_SMARTCARD,
DEVICE_REDIRDEV,
DEVICE_MEMBALLOON,
DEVICE_TPM,
DEVICE_RNG,
DEVICE_PANIC,
DEVICE_MEMORY]
virtual_device_classes = {}
@classmethod
def register_type(cls):
cls._XML_ROOT_NAME = cls.virtual_device_type
VirtualDevice.virtual_device_classes[cls.virtual_device_type] = cls
Device.virtual_device_classes[cls.virtual_device_type] = cls
# General device type (disk, interface, etc.)
virtual_device_type = None
@ -188,9 +188,9 @@ class VirtualDevice(XMLBuilder):
raise ValueError(_("Unknown virtual device type '%s'.") %
self.virtual_device_type)
alias = XMLChildProperty(VirtualDeviceAlias, is_single=True)
address = XMLChildProperty(VirtualDeviceAddress, is_single=True)
boot = XMLChildProperty(VirtualDeviceBoot, is_single=True)
alias = XMLChildProperty(DeviceAlias, is_single=True)
address = XMLChildProperty(DeviceAddress, is_single=True)
boot = XMLChildProperty(DeviceBoot, is_single=True)
def setup(self, meter=None):

8
virtinst/deviceaudio.py
View File

@ -17,12 +17,12 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualAudio(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_AUDIO
class DeviceSound(Device):
virtual_device_type = Device.DEVICE_AUDIO
MODEL_DEFAULT = "default"
MODELS = ["es1370", "sb16", "pcspk", "ac97", "ich6", "ich9"]
@ -31,4 +31,4 @@ class VirtualAudio(VirtualDevice):
default_cb=lambda s: "es1370",
default_name=MODEL_DEFAULT)
VirtualAudio.register_type()
DeviceSound.register_type()

62
virtinst/devicechar.py
View File

@ -17,11 +17,11 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class _VirtualCharDevice(VirtualDevice):
class _DeviceChar(Device):
"""
Base class for all character devices. Shouldn't be instantiated
directly.
@ -78,13 +78,13 @@ class _VirtualCharDevice(VirtualDevice):
@staticmethod
def pretty_channel_name(val):
if val == _VirtualCharDevice.CHANNEL_NAME_SPICE:
if val == _DeviceChar.CHANNEL_NAME_SPICE:
return "spice"
if val == _VirtualCharDevice.CHANNEL_NAME_QEMUGA:
if val == _DeviceChar.CHANNEL_NAME_QEMUGA:
return "qemu-ga"
if val == _VirtualCharDevice.CHANNEL_NAME_LIBGUESTFS:
if val == _DeviceChar.CHANNEL_NAME_LIBGUESTFS:
return "libguestfs"
if val == _VirtualCharDevice.CHANNEL_NAME_SPICE_WEBDAV:
if val == _DeviceChar.CHANNEL_NAME_SPICE_WEBDAV:
return "spice-webdav"
return None
@ -95,29 +95,29 @@ class _VirtualCharDevice(VirtualDevice):
"""
desc = ""
if ctype == _VirtualCharDevice.TYPE_PTY:
if ctype == _DeviceChar.TYPE_PTY:
desc = _("Pseudo TTY")
elif ctype == _VirtualCharDevice.TYPE_DEV:
elif ctype == _DeviceChar.TYPE_DEV:
desc = _("Physical host character device")
elif ctype == _VirtualCharDevice.TYPE_STDIO:
elif ctype == _DeviceChar.TYPE_STDIO:
desc = _("Standard input/output")
elif ctype == _VirtualCharDevice.TYPE_PIPE:
elif ctype == _DeviceChar.TYPE_PIPE:
desc = _("Named pipe")
elif ctype == _VirtualCharDevice.TYPE_FILE:
elif ctype == _DeviceChar.TYPE_FILE:
desc = _("Output to a file")
elif ctype == _VirtualCharDevice.TYPE_VC:
elif ctype == _DeviceChar.TYPE_VC:
desc = _("Virtual console")
elif ctype == _VirtualCharDevice.TYPE_NULL:
elif ctype == _DeviceChar.TYPE_NULL:
desc = _("Null device")
elif ctype == _VirtualCharDevice.TYPE_TCP:
elif ctype == _DeviceChar.TYPE_TCP:
desc = _("TCP net console")
elif ctype == _VirtualCharDevice.TYPE_UDP:
elif ctype == _DeviceChar.TYPE_UDP:
desc = _("UDP net console")
elif ctype == _VirtualCharDevice.TYPE_UNIX:
elif ctype == _DeviceChar.TYPE_UNIX:
desc = _("Unix socket")
elif ctype == _VirtualCharDevice.TYPE_SPICEVMC:
elif ctype == _DeviceChar.TYPE_SPICEVMC:
desc = _("Spice agent")
elif ctype == _VirtualCharDevice.TYPE_SPICEPORT:
elif ctype == _DeviceChar.TYPE_SPICEPORT:
desc = _("Spice port")
return desc
@ -129,9 +129,9 @@ class _VirtualCharDevice(VirtualDevice):
"""
desc = ""
if char_mode == _VirtualCharDevice.MODE_CONNECT:
if char_mode == _DeviceChar.MODE_CONNECT:
desc = _("Client mode")
elif char_mode == _VirtualCharDevice.MODE_BIND:
elif char_mode == _DeviceChar.MODE_BIND:
desc = _("Server mode")
return desc
@ -277,26 +277,26 @@ class _VirtualCharDevice(VirtualDevice):
log_append = XMLProperty("./log/@append", is_onoff=True)
class VirtualConsoleDevice(_VirtualCharDevice):
class DeviceConsole(_DeviceChar):
virtual_device_type = "console"
TYPES = [_VirtualCharDevice.TYPE_PTY]
TYPES = [_DeviceChar.TYPE_PTY]
class VirtualSerialDevice(_VirtualCharDevice):
class DeviceSerial(_DeviceChar):
virtual_device_type = "serial"
class VirtualParallelDevice(_VirtualCharDevice):
class DeviceParallel(_DeviceChar):
virtual_device_type = "parallel"
class VirtualChannelDevice(_VirtualCharDevice):
class DeviceChannel(_DeviceChar):
virtual_device_type = "channel"
TYPES = (_VirtualCharDevice._TYPES_FOR_CHANNEL +
_VirtualCharDevice._TYPES_FOR_ALL)
TYPES = (_DeviceChar._TYPES_FOR_CHANNEL +
_DeviceChar._TYPES_FOR_ALL)
VirtualConsoleDevice.register_type()
VirtualSerialDevice.register_type()
VirtualParallelDevice.register_type()
VirtualChannelDevice.register_type()
DeviceConsole.register_type()
DeviceSerial.register_type()
DeviceParallel.register_type()
DeviceChannel.register_type()

34
virtinst/devicecontroller.py
View File

@ -17,12 +17,12 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualController(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_CONTROLLER
class DeviceController(Device):
virtual_device_type = Device.DEVICE_CONTROLLER
TYPE_IDE = "ide"
TYPE_FDC = "fdc"
@ -40,14 +40,14 @@ class VirtualController(VirtualDevice):
@staticmethod
def pretty_type(ctype):
pretty_mappings = {
VirtualController.TYPE_IDE: "IDE",
VirtualController.TYPE_FDC: _("Floppy"),
VirtualController.TYPE_SCSI: "SCSI",
VirtualController.TYPE_SATA: "SATA",
VirtualController.TYPE_VIRTIOSERIAL: "VirtIO Serial",
VirtualController.TYPE_USB: "USB",
VirtualController.TYPE_PCI: "PCI",
VirtualController.TYPE_CCID: "CCID",
DeviceController.TYPE_IDE: "IDE",
DeviceController.TYPE_FDC: _("Floppy"),
DeviceController.TYPE_SCSI: "SCSI",
DeviceController.TYPE_SATA: "SATA",
DeviceController.TYPE_VIRTIOSERIAL: "VirtIO Serial",
DeviceController.TYPE_USB: "USB",
DeviceController.TYPE_PCI: "PCI",
DeviceController.TYPE_CCID: "CCID",
}
if ctype not in pretty_mappings:
@ -57,24 +57,24 @@ class VirtualController(VirtualDevice):
@staticmethod
def get_usb2_controllers(conn):
ret = []
ctrl = VirtualController(conn)
ctrl = DeviceController(conn)
ctrl.type = "usb"
ctrl.model = "ich9-ehci1"
ret.append(ctrl)
ctrl = VirtualController(conn)
ctrl = DeviceController(conn)
ctrl.type = "usb"
ctrl.model = "ich9-uhci1"
ctrl.master_startport = 0
ret.append(ctrl)
ctrl = VirtualController(conn)
ctrl = DeviceController(conn)
ctrl.type = "usb"
ctrl.model = "ich9-uhci2"
ctrl.master_startport = 2
ret.append(ctrl)
ctrl = VirtualController(conn)
ctrl = DeviceController(conn)
ctrl.type = "usb"
ctrl.model = "ich9-uhci3"
ctrl.master_startport = 4
@ -83,7 +83,7 @@ class VirtualController(VirtualDevice):
@staticmethod
def get_usb3_controller(conn, guest):
ctrl = VirtualController(conn)
ctrl = DeviceController(conn)
ctrl.type = "usb"
ctrl.model = "nec-xhci"
if ((guest.os.is_arm_machvirt() or guest.os.is_pseries()) and
@ -115,4 +115,4 @@ class VirtualController(VirtualDevice):
ret = "PCIe"
return ret
VirtualController.register_type()
DeviceController.register_type()

46
virtinst/devicedisk.py
View File

@ -28,7 +28,7 @@ import re
from . import diskbackend
from . import util
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLBuilder, XMLChildProperty, XMLProperty
@ -38,14 +38,14 @@ def _qemu_sanitize_drvtype(phystype, fmt, manual_format=False):
"""
raw_list = ["iso"]
if phystype == VirtualDisk.TYPE_BLOCK:
if phystype == DeviceDisk.TYPE_BLOCK:
if not fmt:
return VirtualDisk.DRIVER_TYPE_RAW
return DeviceDisk.DRIVER_TYPE_RAW
if fmt and not manual_format:
return VirtualDisk.DRIVER_TYPE_RAW
return DeviceDisk.DRIVER_TYPE_RAW
if fmt in raw_list:
return VirtualDisk.DRIVER_TYPE_RAW
return DeviceDisk.DRIVER_TYPE_RAW
return fmt
@ -110,8 +110,8 @@ class _DiskSeclabel(XMLBuilder):
label = XMLProperty("./label")
class VirtualDisk(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_DISK
class DeviceDisk(Device):
virtual_device_type = Device.DEVICE_DISK
DRIVER_NAME_PHY = "phy"
DRIVER_NAME_QEMU = "qemu"
@ -151,12 +151,12 @@ class VirtualDisk(VirtualDevice):
@staticmethod
def disk_type_to_xen_driver_name(disk_type):
"""
Convert a value of VirtualDisk.type to it's associated Xen
Convert a value of DeviceDisk.type to it's associated Xen
<driver name=/> property
"""
if disk_type == VirtualDisk.TYPE_BLOCK:
if disk_type == DeviceDisk.TYPE_BLOCK:
return "phy"
elif disk_type == VirtualDisk.TYPE_FILE:
elif disk_type == DeviceDisk.TYPE_FILE:
return "file"
return "file"
@ -269,7 +269,7 @@ class VirtualDisk(VirtualDevice):
logging.debug("Exception grabbing qemu DAC user", exc_info=True)
return None, []
return user, VirtualDisk.check_path_search_for_user(conn, path, user)
return user, DeviceDisk.check_path_search_for_user(conn, path, user)
@staticmethod
def fix_path_search_for_user(conn, path, username):
@ -303,7 +303,7 @@ class VirtualDisk(VirtualDevice):
raise ValueError(_("Permissions on '%s' did not stick") %
dirname)
fixlist = VirtualDisk.check_path_search_for_user(conn, path, username)
fixlist = DeviceDisk.check_path_search_for_user(conn, path, username)
if not fixlist:
return []
@ -386,7 +386,7 @@ class VirtualDisk(VirtualDevice):
def build_vol_install(conn, volname, poolobj, size, sparse,
fmt=None, backing_store=None, backing_format=None):
"""
Helper for building a StorageVolume instance to pass to VirtualDisk
Helper for building a StorageVolume instance to pass to DeviceDisk
for eventual storage creation.
:param volname: name of the volume to be created
@ -488,7 +488,7 @@ class VirtualDisk(VirtualDevice):
]
def __init__(self, *args, **kwargs):
VirtualDevice.__init__(self, *args, **kwargs)
Device.__init__(self, *args, **kwargs)
self._source_volume_err = None
self._storage_backend = None
@ -686,11 +686,11 @@ class VirtualDisk(VirtualDevice):
def _get_default_type(self):
if self.source_pool or self.source_volume:
return VirtualDisk.TYPE_VOLUME
return DeviceDisk.TYPE_VOLUME
if self._storage_backend:
return self._storage_backend.get_dev_type()
if self.source_protocol:
return VirtualDisk.TYPE_NETWORK
return DeviceDisk.TYPE_NETWORK
return self.TYPE_FILE
type = XMLProperty("./@type", default_cb=_get_default_type)
@ -712,11 +712,11 @@ class VirtualDisk(VirtualDevice):
def _disk_type_to_object_prop_name(self):
disk_type = self.type
if disk_type == VirtualDisk.TYPE_BLOCK:
if disk_type == DeviceDisk.TYPE_BLOCK:
return "_source_dev"
elif disk_type == VirtualDisk.TYPE_DIR:
elif disk_type == DeviceDisk.TYPE_DIR:
return "_source_dir"
elif disk_type == VirtualDisk.TYPE_FILE:
elif disk_type == DeviceDisk.TYPE_FILE:
return "_source_file"
return None
@ -797,11 +797,11 @@ class VirtualDisk(VirtualDevice):
self._source_volume_err = None
typ = self._get_default_type()
if self.type == VirtualDisk.TYPE_NETWORK:
if self.type == DeviceDisk.TYPE_NETWORK:
# Fill in a completed URL for virt-manager UI, path comparison, etc
path = self._build_url_from_network_source()
if typ == VirtualDisk.TYPE_VOLUME:
if typ == DeviceDisk.TYPE_VOLUME:
conn = self.conn
if "weakref" in str(type(conn)):
conn = conn()
@ -877,7 +877,7 @@ class VirtualDisk(VirtualDevice):
return
if (self.type == VirtualDisk.TYPE_DIR and
if (self.type == DeviceDisk.TYPE_DIR and
not self.is_floppy()):
raise ValueError(_("The path '%s' must be a file or a "
"device, not a directory") % self.path)
@ -1053,4 +1053,4 @@ class VirtualDisk(VirtualDevice):
raise ValueError(_("Only %s disks for bus '%s' are supported"
% (maxnode, self.bus)))
VirtualDisk.register_type()
DeviceDisk.register_type()

16
virtinst/devicefilesystem.py
View File

@ -19,12 +19,12 @@
import os
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualFilesystem(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_FILESYSTEM
class DeviceFilesystem(Device):
virtual_device_type = Device.DEVICE_FILESYSTEM
TYPE_MOUNT = "mount"
TYPE_TEMPLATE = "template"
@ -94,13 +94,13 @@ class VirtualFilesystem(VirtualDevice):
_source_dev = XMLProperty("./source/@dev")
_source_usage = XMLProperty("./source/@usage")
def _type_to_source_prop(self):
if self.type == VirtualFilesystem.TYPE_TEMPLATE:
if self.type == DeviceFilesystem.TYPE_TEMPLATE:
return "_source_name"
elif self.type == VirtualFilesystem.TYPE_FILE:
elif self.type == DeviceFilesystem.TYPE_FILE:
return "_source_file"
elif self.type == VirtualFilesystem.TYPE_BLOCK:
elif self.type == DeviceFilesystem.TYPE_BLOCK:
return "_source_dev"
elif self.type == VirtualFilesystem.TYPE_RAM:
elif self.type == DeviceFilesystem.TYPE_RAM:
return "_source_usage"
else:
return "_source_dir"
@ -146,4 +146,4 @@ class VirtualFilesystem(VirtualDevice):
self.accessmode = self.MODE_MAPPED
VirtualFilesystem.register_type()
DeviceFilesystem.register_type()

16
virtinst/devicegraphics.py
View File

@ -19,7 +19,7 @@
import os
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLBuilder, XMLChildProperty, XMLProperty
@ -48,8 +48,8 @@ class _GraphicsListen(XMLBuilder):
socket = XMLProperty("./@socket")
class VirtualGraphics(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_GRAPHICS
class DeviceGraphics(Device):
virtual_device_type = Device.DEVICE_GRAPHICS
TYPE_SDL = "sdl"
TYPE_VNC = "vnc"
@ -96,15 +96,15 @@ class VirtualGraphics(VirtualDevice):
@staticmethod
def pretty_type_simple(gtype):
if (gtype in [VirtualGraphics.TYPE_VNC,
VirtualGraphics.TYPE_SDL,
VirtualGraphics.TYPE_RDP]):
if (gtype in [DeviceGraphics.TYPE_VNC,
DeviceGraphics.TYPE_SDL,
DeviceGraphics.TYPE_RDP]):
return str(gtype).upper()
return str(gtype).capitalize()
def __init__(self, *args, **kwargs):
VirtualDevice.__init__(self, *args, **kwargs)
Device.__init__(self, *args, **kwargs)
self._local_keymap = -1
@ -250,4 +250,4 @@ class VirtualGraphics(VirtualDevice):
gl = XMLProperty("./gl/@enable", is_yesno=True)
rendernode = XMLProperty("./gl/@rendernode")
VirtualGraphics.register_type()
DeviceGraphics.register_type()

8
virtinst/devicehostdev.py
View File

@ -17,13 +17,13 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .nodedev import NodeDevice
from .xmlbuilder import XMLProperty
class VirtualHostDevice(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_HOSTDEV
class DeviceHostdev(Device):
virtual_device_type = Device.DEVICE_HOSTDEV
def set_from_nodedev(self, nodedev):
"""
@ -146,4 +146,4 @@ class VirtualHostDevice(VirtualDevice):
scsi_unit = XMLProperty("./source/address/@unit", is_int=True)
VirtualHostDevice.register_type()
DeviceHostdev.register_type()

8
virtinst/deviceinput.py
View File

@ -17,12 +17,12 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualInputDevice(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_INPUT
class DeviceInput(Device):
virtual_device_type = Device.DEVICE_INPUT
TYPE_MOUSE = "mouse"
TYPE_TABLET = "tablet"
@ -51,4 +51,4 @@ class VirtualInputDevice(VirtualDevice):
default_name=BUS_DEFAULT)
VirtualInputDevice.register_type()
DeviceInput.register_type()

22
virtinst/deviceinterface.py
View File

@ -22,7 +22,7 @@ import os
import random
from . import util
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLBuilder, XMLChildProperty, XMLProperty
@ -112,7 +112,7 @@ def _default_network(conn):
return ["network", "default"]
class VirtualPort(XMLBuilder):
class _VirtualPort(XMLBuilder):
_XML_ROOT_NAME = "virtualport"
type = XMLProperty("./@type")
@ -124,8 +124,8 @@ class VirtualPort(XMLBuilder):
interfaceid = XMLProperty("./parameters/@interfaceid")
class VirtualNetworkInterface(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_NET
class DeviceInterface(Device):
virtual_device_type = Device.DEVICE_NET
TYPE_BRIDGE = "bridge"
TYPE_VIRTUAL = "network"
@ -143,11 +143,11 @@ class VirtualNetworkInterface(VirtualDevice):
"""
desc = net_type.capitalize()
if net_type == VirtualNetworkInterface.TYPE_BRIDGE:
if net_type == DeviceInterface.TYPE_BRIDGE:
desc = _("Shared physical device")
elif net_type == VirtualNetworkInterface.TYPE_VIRTUAL:
elif net_type == DeviceInterface.TYPE_VIRTUAL:
desc = _("Virtual networking")
elif net_type == VirtualNetworkInterface.TYPE_USER:
elif net_type == DeviceInterface.TYPE_USER:
desc = _("Usermode networking")
return desc
@ -164,7 +164,7 @@ class VirtualNetworkInterface(VirtualDevice):
for ignore in range(256):
mac = _random_mac(conn)
ret = VirtualNetworkInterface.is_conflict_net(conn, mac)
ret = DeviceInterface.is_conflict_net(conn, mac)
if ret[1] is None:
return mac
@ -195,7 +195,7 @@ class VirtualNetworkInterface(VirtualDevice):
def __init__(self, *args, **kwargs):
VirtualDevice.__init__(self, *args, **kwargs)
Device.__init__(self, *args, **kwargs)
self._random_mac = None
self._default_bridge = None
@ -279,7 +279,7 @@ class VirtualNetworkInterface(VirtualDevice):
_network = XMLProperty("./source/@network")
_source_dev = XMLProperty("./source/@dev")
virtualport = XMLChildProperty(VirtualPort, is_single=True)
virtualport = XMLChildProperty(_VirtualPort, is_single=True)
type = XMLProperty("./@type",
default_cb=lambda s: s.TYPE_BRIDGE)
trustGuestRxFilters = XMLProperty("./@trustGuestRxFilters", is_yesno=True)
@ -329,4 +329,4 @@ class VirtualNetworkInterface(VirtualDevice):
self.type, self.source = _default_network(self.conn)
VirtualNetworkInterface.register_type()
DeviceInterface.register_type()

8
virtinst/devicememballoon.py
View File

@ -18,12 +18,12 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualMemballoon(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_MEMBALLOON
class DeviceMemballoon(Device):
virtual_device_type = Device.DEVICE_MEMBALLOON
MODEL_DEFAULT = "default"
MODELS = ["virtio", "xen", "none"]
@ -33,4 +33,4 @@ class VirtualMemballoon(VirtualDevice):
default_cb=lambda s: "virtio")
VirtualMemballoon.register_type()
DeviceMemballoon.register_type()

16
virtinst/devicememory.py
View File

@ -17,11 +17,11 @@
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLBuilder, XMLChildProperty, XMLProperty
class VirtualMemoryTarget(XMLBuilder):
class _DeviceMemoryTarget(XMLBuilder):
_XML_ROOT_NAME = "target"
size = XMLProperty("./size", is_int=True)
@ -29,7 +29,7 @@ class VirtualMemoryTarget(XMLBuilder):
label_size = XMLProperty("./label/size", is_int=True)
class VirtualMemorySource(XMLBuilder):
class _DeviceMemorySource(XMLBuilder):
_XML_ROOT_NAME = "source"
pagesize = XMLProperty("./pagesize", is_int=True)
@ -37,8 +37,8 @@ class VirtualMemorySource(XMLBuilder):
path = XMLProperty("./path")
class VirtualMemoryDevice(VirtualDevice):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_MEMORY
class DeviceMemory(Device):
virtual_device_type = Device.DEVICE_MEMORY
MODEL_DIMM = "dimm"
MODEL_NVDIMM = "nvdimm"
@ -51,8 +51,8 @@ class VirtualMemoryDevice(VirtualDevice):
model = XMLProperty("./@model")
access = XMLProperty("./@access")
source = XMLChildProperty(VirtualMemorySource, is_single=True)
target = XMLChildProperty(VirtualMemoryTarget, is_single=True)
source = XMLChildProperty(_DeviceMemorySource, is_single=True)
target = XMLChildProperty(_DeviceMemoryTarget, is_single=True)
VirtualMemoryDevice.register_type()
DeviceMemory.register_type()

30
virtinst/devicepanic.py
View File

@ -17,13 +17,13 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualPanicDevice(VirtualDevice):
class DevicePanic(Device):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_PANIC
virtual_device_type = Device.DEVICE_PANIC
MODEL_DEFAULT = "default"
MODEL_ISA = "isa"
@ -36,44 +36,44 @@ class VirtualPanicDevice(VirtualDevice):
@staticmethod
def get_pretty_model(panic_model):
if panic_model == VirtualPanicDevice.MODEL_ISA:
if panic_model == DevicePanic.MODEL_ISA:
return _("ISA")
elif panic_model == VirtualPanicDevice.MODEL_PSERIES:
elif panic_model == DevicePanic.MODEL_PSERIES:
return _("pSeries")
elif panic_model == VirtualPanicDevice.MODEL_HYPERV:
elif panic_model == DevicePanic.MODEL_HYPERV:
return _("Hyper-V")
elif panic_model == VirtualPanicDevice.MODEL_S390:
elif panic_model == DevicePanic.MODEL_S390:
return _("s390")
return panic_model
@staticmethod
def get_models(os):
if os.is_x86():
return [VirtualPanicDevice.MODEL_ISA,
VirtualPanicDevice.MODEL_HYPERV]
return [DevicePanic.MODEL_ISA,
DevicePanic.MODEL_HYPERV]
elif os.is_pseries():
return [VirtualPanicDevice.MODEL_PSERIES]
return [DevicePanic.MODEL_PSERIES]
elif os.is_s390x():
return [VirtualPanicDevice.MODEL_S390]
return [DevicePanic.MODEL_S390]
return []
@staticmethod
def get_default_model(os):
models = VirtualPanicDevice.get_models(os)
models = DevicePanic.get_models(os)
if models:
return models[0]
return None
def _get_default_address_type(self):
if self.iobase:
return VirtualPanicDevice.ISA_ADDRESS_TYPE
return DevicePanic.ISA_ADDRESS_TYPE
return None
model = XMLProperty("./@model",
default_cb=lambda s: VirtualPanicDevice.MODEL_ISA,
default_cb=lambda s: DevicePanic.MODEL_ISA,
default_name=MODEL_DEFAULT)
type = XMLProperty("./address/@type",
default_cb=_get_default_address_type)
iobase = XMLProperty("./address/@iobase")
VirtualPanicDevice.register_type()
DevicePanic.register_type()

8
virtinst/deviceredirdev.py
View File

@ -18,13 +18,13 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualRedirDevice(VirtualDevice):
class DeviceRedirdev(Device):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_REDIRDEV
virtual_device_type = Device.DEVICE_REDIRDEV
BUS_DEFAULT = "default"
BUSES = ["usb"]
@ -60,4 +60,4 @@ class VirtualRedirDevice(VirtualDevice):
service = XMLProperty("./source/@service", is_int=True)
VirtualRedirDevice.register_type()
DeviceRedirdev.register_type()

20
virtinst/devicerng.py
View File

@ -17,13 +17,13 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualRNGDevice(VirtualDevice):
class DeviceRng(Device):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_RNG
virtual_device_type = Device.DEVICE_RNG
TYPE_RANDOM = "random"
TYPE_EGD = "egd"
@ -39,9 +39,9 @@ class VirtualRNGDevice(VirtualDevice):
@staticmethod
def get_pretty_type(rng_type):
if rng_type == VirtualRNGDevice.TYPE_RANDOM:
if rng_type == DeviceRng.TYPE_RANDOM:
return _("Random")
if rng_type == VirtualRNGDevice.TYPE_EGD:
if rng_type == DeviceRng.TYPE_EGD:
return _("Entropy Gathering Daemon")
return rng_type
@ -79,9 +79,9 @@ class VirtualRNGDevice(VirtualDevice):
def backend_mode(self):
ret = []
if self._has_mode_bind:
ret.append(VirtualRNGDevice.BACKEND_MODE_BIND)
ret.append(DeviceRng.BACKEND_MODE_BIND)
if self._has_mode_connect:
ret.append(VirtualRNGDevice.BACKEND_MODE_CONNECT)
ret.append(DeviceRng.BACKEND_MODE_CONNECT)
return ret
_XML_PROP_ORDER = ["_has_mode_bind", "_has_mode_connect"]
@ -89,13 +89,13 @@ class VirtualRNGDevice(VirtualDevice):
_has_mode_connect = XMLProperty("./backend/source[@mode='connect']/@mode")
def _set_connect_validate(self, val):
if val:
self._has_mode_connect = VirtualRNGDevice.BACKEND_MODE_CONNECT
self._has_mode_connect = DeviceRng.BACKEND_MODE_CONNECT
return val
_has_mode_bind = XMLProperty("./backend/source[@mode='bind']/@mode")
def _set_bind_validate(self, val):
if val:
self._has_mode_bind = VirtualRNGDevice.BACKEND_MODE_BIND
self._has_mode_bind = DeviceRng.BACKEND_MODE_BIND
return val
type = XMLProperty("./backend/@model")
@ -118,4 +118,4 @@ class VirtualRNGDevice(VirtualDevice):
device = XMLProperty("./backend[@model='random']")
VirtualRNGDevice.register_type()
DeviceRng.register_type()

8
virtinst/devicesmartcard.py
View File

@ -18,13 +18,13 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualSmartCardDevice(VirtualDevice):
class DeviceSmartcard(Device):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_SMARTCARD
virtual_device_type = Device.DEVICE_SMARTCARD
# Default models list
MODE_DEFAULT = "default"
@ -49,4 +49,4 @@ class VirtualSmartCardDevice(VirtualDevice):
default_name=TYPE_DEFAULT)
VirtualSmartCardDevice.register_type()
DeviceSmartcard.register_type()

10
virtinst/devicetpm.py
View File

@ -21,13 +21,13 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualTPMDevice(VirtualDevice):
class DeviceTpm(Device):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_TPM
virtual_device_type = Device.DEVICE_TPM
TYPE_PASSTHROUGH = "passthrough"
TYPE_DEFAULT = "default"
@ -39,7 +39,7 @@ class VirtualTPMDevice(VirtualDevice):
@staticmethod
def get_pretty_type(tpm_type):
if tpm_type == VirtualTPMDevice.TYPE_PASSTHROUGH:
if tpm_type == DeviceTpm.TYPE_PASSTHROUGH:
return _("Passthrough device")
return tpm_type
@ -64,4 +64,4 @@ class VirtualTPMDevice(VirtualDevice):
default_cb=lambda s: "/dev/tpm0")
VirtualTPMDevice.register_type()
DeviceTpm.register_type()

8
virtinst/devicevideo.py
View File

@ -17,13 +17,13 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualVideoDevice(VirtualDevice):
class DeviceVideo(Device):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_VIDEO
virtual_device_type = Device.DEVICE_VIDEO
# Default models list
MODEL_DEFAULT = "default"
@ -47,4 +47,4 @@ class VirtualVideoDevice(VirtualDevice):
accel3d = XMLProperty("./model/acceleration/@accel3d", is_yesno=True)
VirtualVideoDevice.register_type()
DeviceVideo.register_type()

20
virtinst/devicewatchdog.py
View File

@ -17,13 +17,13 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
from .device import VirtualDevice
from .device import Device
from .xmlbuilder import XMLProperty
class VirtualWatchdog(VirtualDevice):
class DeviceWatchdog(Device):
virtual_device_type = VirtualDevice.VIRTUAL_DEV_WATCHDOG
virtual_device_type = Device.DEVICE_WATCHDOG
MODEL_I6300 = "i6300esb"
MODEL_IB700 = "ib700"
@ -44,17 +44,17 @@ class VirtualWatchdog(VirtualDevice):
@staticmethod
def get_action_desc(action):
if action == VirtualWatchdog.ACTION_RESET:
if action == DeviceWatchdog.ACTION_RESET:
return _("Forcefully reset the guest")
if action == VirtualWatchdog.ACTION_SHUTDOWN:
if action == DeviceWatchdog.ACTION_SHUTDOWN:
return _("Gracefully shutdown the guest")
if action == VirtualWatchdog.ACTION_POWEROFF:
if action == DeviceWatchdog.ACTION_POWEROFF:
return _("Forcefully power off the guest")
if action == VirtualWatchdog.ACTION_PAUSE:
if action == DeviceWatchdog.ACTION_PAUSE:
return _("Pause the guest")
if action == VirtualWatchdog.ACTION_NONE:
if action == DeviceWatchdog.ACTION_NONE:
return _("No action")
if action == VirtualWatchdog.ACTION_DUMP:
if action == DeviceWatchdog.ACTION_DUMP:
return _("Dump guest memory core")
return action
@ -67,4 +67,4 @@ class VirtualWatchdog(VirtualDevice):
default_cb=lambda s: s.ACTION_RESET)
VirtualWatchdog.register_type()
DeviceWatchdog.register_type()

4
virtinst/diskbackend.py
View File

@ -240,7 +240,7 @@ def _get_dev_type(path, vol_xml, vol_object, pool_xml, remote):
class _StorageBase(object):
"""
Storage base class, defining the API used by VirtualDisk
Storage base class, defining the API used by DeviceDisk
"""
def __init__(self, conn):
self._conn = conn
@ -491,7 +491,7 @@ class ManagedStorageCreator(_StorageCreator):
"""
Handles storage creation via libvirt APIs. All the actual creation
logic lives in StorageVolume, this is mostly about pulling out bits
from that class and mapping them to VirtualDisk elements
from that class and mapping them to DeviceDisk elements
"""
def __init__(self, conn, vol_install):
_StorageCreator.__init__(self, conn)

4
virtinst/distroinstaller.py
View File

@ -22,7 +22,7 @@ import os
from . import urlfetcher
from . import util
from .devicedisk import VirtualDisk
from .devicedisk import DeviceDisk
from .initrdinject import perform_initrd_injections
from .kernelupload import upload_kernel_initrd
from .installer import Installer
@ -181,7 +181,7 @@ class DistroInstaller(Installer):
return _sanitize_url(val)
try:
dev = VirtualDisk(self.conn)
dev = DeviceDisk(self.conn)
dev.device = dev.DEVICE_CDROM
dev.path = val
dev.validate()

68
virtinst/guest.py
View File

@ -32,17 +32,17 @@ from .osdict import OSDB
from .clock import Clock
from .cpu import CPU
from .cputune import CPUTune
from .device import VirtualDevice
from .deviceaudio import VirtualAudio
from .devicechar import VirtualChannelDevice, VirtualConsoleDevice
from .devicecontroller import VirtualController
from .devicedisk import VirtualDisk
from .devicegraphics import VirtualGraphics
from .deviceinput import VirtualInputDevice
from .devicepanic import VirtualPanicDevice
from .deviceredirdev import VirtualRedirDevice
from .devicerng import VirtualRNGDevice
from .devicevideo import VirtualVideoDevice
from .device import Device
from .deviceaudio import DeviceSound
from .devicechar import DeviceChannel, DeviceConsole
from .devicecontroller import DeviceController
from .devicedisk import DeviceDisk
from .devicegraphics import DeviceGraphics
from .deviceinput import DeviceInput
from .devicepanic import DevicePanic
from .deviceredirdev import DeviceRedirdev
from .devicerng import DeviceRng
from .devicevideo import DeviceVideo
from .distroinstaller import DistroInstaller
from .domainblkiotune import DomainBlkiotune
from .domainfeatures import DomainFeatures
@ -261,7 +261,7 @@ class Guest(XMLBuilder):
"""
Add the passed device to the guest's device list.
:param dev: VirtualDevice instance to attach to guest
:param dev: Device instance to attach to guest
"""
self.add_child(dev)
@ -269,7 +269,7 @@ class Guest(XMLBuilder):
"""
Remove the passed device from the guest's device list
:param dev: VirtualDevice instance
:param dev: Device instance
"""
self.remove_child(dev)
@ -279,7 +279,7 @@ class Guest(XMLBuilder):
the guest.
:param devtype: Device type to search for (one of
VirtualDevice.virtual_device_types)
Device.virtual_device_types)
"""
newlist = []
for i in self._devices:
@ -288,8 +288,8 @@ class Guest(XMLBuilder):
return newlist
_devices = XMLChildProperty(
[VirtualDevice.virtual_device_classes[_n]
for _n in VirtualDevice.virtual_device_types],
[Device.virtual_device_classes[_n]
for _n in Device.virtual_device_types],
relative_xpath="./devices")
def get_all_devices(self):
@ -297,7 +297,7 @@ class Guest(XMLBuilder):
Return a list of all devices being installed with the guest
"""
retlist = []
for devtype in VirtualDevice.virtual_device_types:
for devtype in Device.virtual_device_types:
retlist.extend(self.get_devices(devtype))
return retlist
@ -633,12 +633,12 @@ class Guest(XMLBuilder):
usb_keyboard = True
if usb_tablet:
dev = VirtualInputDevice(self.conn)
dev = DeviceInput(self.conn)
dev.type = "tablet"
dev.bus = "usb"
self.add_device(dev)
if usb_keyboard:
dev = VirtualInputDevice(self.conn)
dev = DeviceInput(self.conn)
dev.type = "keyboard"
dev.bus = "usb"
self.add_device(dev)
@ -649,7 +649,7 @@ class Guest(XMLBuilder):
if self.get_devices("console") or self.get_devices("serial"):
return
dev = VirtualConsoleDevice(self.conn)
dev = DeviceConsole(self.conn)
dev.type = dev.TYPE_PTY
if self.os.is_s390x():
dev.target_type = "sclp"
@ -662,7 +662,7 @@ class Guest(XMLBuilder):
return
if not self.get_devices("graphics"):
return
self.add_device(VirtualVideoDevice(self.conn))
self.add_device(DeviceVideo(self.conn))
def add_default_usb_controller(self):
if self.os.is_container():
@ -687,12 +687,12 @@ class Guest(XMLBuilder):
if not self.conn.check_support(
self.conn.SUPPORT_CONN_DEFAULT_USB2):
return
for dev in VirtualController.get_usb2_controllers(self.conn):
for dev in DeviceController.get_usb2_controllers(self.conn):
self.add_device(dev)
if usb3:
self.add_device(
VirtualController.get_usb3_controller(self.conn, self))
DeviceController.get_usb3_controller(self.conn, self))
def add_default_channels(self):
if self.skip_default_channel:
@ -706,7 +706,7 @@ class Guest(XMLBuilder):
if (self.conn.is_qemu() and
self._os_object.supports_qemu_ga() and
self.conn.check_support(self.conn.SUPPORT_CONN_AUTOSOCKET)):
dev = VirtualChannelDevice(self.conn)
dev = DeviceChannel(self.conn)
dev.type = "unix"
dev.target_type = "virtio"
dev.target_name = dev.CHANNEL_NAME_QEMUGA
@ -721,7 +721,7 @@ class Guest(XMLBuilder):
return
if self.os.arch not in ["x86_64", "i686", "ppc64", "ppc64le"]:
return
self.add_device(VirtualGraphics(self.conn))
self.add_device(DeviceGraphics(self.conn))
def add_default_rng(self):
if self.skip_default_rng:
@ -736,7 +736,7 @@ class Guest(XMLBuilder):
if (self.conn.is_qemu() and
self._os_object.supports_virtiorng() and
self.conn.check_support(self.conn.SUPPORT_CONN_RNG_URANDOM)):
dev = VirtualRNGDevice(self.conn)
dev = DeviceRng(self.conn)
dev.type = "random"
dev.device = "/dev/urandom"
self.add_device(dev)
@ -756,7 +756,7 @@ class Guest(XMLBuilder):
if not self.installer.needs_cdrom():
return
dev = VirtualDisk(self.conn)
dev = DeviceDisk(self.conn)
dev.device = dev.DEVICE_CDROM
setattr(dev, "installer_media", not self.installer.livecd)
self._install_cdrom_device = dev
@ -1002,7 +1002,7 @@ class Guest(XMLBuilder):
if not has_spapr_scsi:
for dev in self.get_devices("disk"):
if dev.address.type == "spapr-vio":
ctrl = VirtualController(self.conn)
ctrl = DeviceController(self.conn)
ctrl.type = "scsi"
ctrl.address.set_addrstr("spapr-vio")
self.add_device(ctrl)
@ -1014,7 +1014,7 @@ class Guest(XMLBuilder):
not has_virtio_scsi):
for dev in self.get_devices("disk"):
if dev.bus == "scsi":
ctrl = VirtualController(self.conn)
ctrl = DeviceController(self.conn)
ctrl.type = "scsi"
ctrl.model = "virtio-scsi"
self.add_device(ctrl)
@ -1194,7 +1194,7 @@ class Guest(XMLBuilder):
return
if self.conn.check_support(self.conn.SUPPORT_CONN_CHAR_SPICEVMC):
agentdev = VirtualChannelDevice(self.conn)
agentdev = DeviceChannel(self.conn)
agentdev.type = agentdev.TYPE_SPICEVMC
self.add_device(agentdev)
@ -1209,7 +1209,7 @@ class Guest(XMLBuilder):
self.os.is_arm_machvirt):
return
self.add_device(VirtualAudio(self.conn))
self.add_device(DeviceSound(self.conn))
def _add_spice_usbredir(self):
if self.skip_default_usbredir:
@ -1225,7 +1225,7 @@ class Guest(XMLBuilder):
# and directly assigned devices are forced to fall back to USB1
# https://bugzilla.redhat.com/show_bug.cgi?id=1135488
for ignore in range(2):
dev = VirtualRedirDevice(self.conn)
dev = DeviceRedirdev(self.conn)
dev.bus = "usb"
dev.type = "spicevmc"
self.add_device(dev)
@ -1265,5 +1265,5 @@ class Guest(XMLBuilder):
def _set_panic_defaults(self):
for panic in self.get_devices("panic"):
if panic.model == VirtualPanicDevice.MODEL_DEFAULT:
panic.model = VirtualPanicDevice.get_default_model(self.os)
if panic.model == DevicePanic.MODEL_DEFAULT:
panic.model = DevicePanic.get_default_model(self.os)

8
virtinst/installer.py
View File

@ -22,7 +22,7 @@
import os
import logging
from .devicedisk import VirtualDisk
from .devicedisk import DeviceDisk
from .osxml import OSXML
@ -253,11 +253,11 @@ class ImportInstaller(Installer):
return self._disk_to_bootdev(disks[0])
def _disk_to_bootdev(self, disk):
if disk.device == VirtualDisk.DEVICE_DISK:
if disk.device == DeviceDisk.DEVICE_DISK:
return OSXML.BOOT_DEVICE_HARDDISK
elif disk.device == VirtualDisk.DEVICE_CDROM:
elif disk.device == DeviceDisk.DEVICE_CDROM:
return OSXML.BOOT_DEVICE_CDROM
elif disk.device == VirtualDisk.DEVICE_FLOPPY:
elif disk.device == DeviceDisk.DEVICE_FLOPPY:
return OSXML.BOOT_DEVICE_FLOPPY
else:
return OSXML.BOOT_DEVICE_HARDDISK

6
virtinst/kernelupload.py
View File

@ -21,7 +21,7 @@ import logging
import os
from . import util
from .devicedisk import VirtualDisk
from .devicedisk import DeviceDisk
from .storage import StoragePool, StorageVolume
@ -73,10 +73,10 @@ def _upload_file(conn, meter, destpool, src):
if name != basename:
logging.debug("Generated non-colliding volume name %s", name)
vol_install = VirtualDisk.build_vol_install(conn, name, destpool,
vol_install = DeviceDisk.build_vol_install(conn, name, destpool,
(float(size) / 1024.0 / 1024.0 / 1024.0), True)
disk = VirtualDisk(conn)
disk = DeviceDisk(conn)
disk.set_vol_install(vol_install)
disk.validate()

4
virtinst/nodedev.py
View File

@ -339,8 +339,8 @@ class DRMDevice(NodeDevice):
def _AddressStringToHostdev(conn, addrstr):
from .devicehostdev import VirtualHostDevice
hostdev = VirtualHostDevice(conn)
from .devicehostdev import DeviceHostdev
hostdev = DeviceHostdev(conn)
try:
# Determine addrstr type

4
virtinst/support.py
View File

@ -181,7 +181,7 @@ class _SupportCheck(object):
return ret
# Do this after the function check, since there's an ordering issue
# with VirtualConnection
# with VirtinstConnection
hv_type = conn.get_uri_driver()
actual_libvirt_version = conn.daemon_version()
actual_hv_version = conn.conn_version()
@ -429,7 +429,7 @@ def check_support(virtconn, feature, data=None):
:returns: True if feature is supported, False otherwise
"""
if "VirtualConnection" in repr(data):
if "VirtinstConnection" in repr(data):
data = data.get_conn_for_api_arg()
sobj = _support_objs[feature - 1]

4
virtinst/xmlbuilder.py
View File

@ -483,7 +483,7 @@ class _XMLState(object):
def make_abs_xpath(self, xpath):
"""
Convert a relative xpath to an absolute xpath. So for VirtualDisk
Convert a relative xpath to an absolute xpath. So for DeviceDisk
that's part of a Guest, accessing driver_name will do convert:
./driver/@name
to an absolute xpath like:
@ -516,7 +516,7 @@ class XMLBuilder(object):
"""
Initialize state
:param conn: VirtualConnection to validate device against
:param conn: VirtinstConnection to validate device against
:param parsexml: Optional XML string to parse
The rest of the parameters are for internal use only