mirror of
https://github.com/virt-manager/virt-manager.git
synced 2024-10-26 08:55:13 +03:00
virtinst: Give device classes consistent DeviceX naming
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:
parent
93c22eff79
commit
1c911ce567
@ -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)
|
||||
|
||||
|
@ -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([]))
|
||||
|
@ -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)
|
||||
|
@ -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
|
||||
|
@ -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):
|
||||
|
@ -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)
|
||||
|
@ -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') %
|
||||
|
@ -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"),
|
||||
|
@ -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
|
||||
|
@ -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:
|
||||
|
@ -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 = ""
|
||||
|
@ -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):
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
@ -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(
|
||||
|
@ -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:
|
||||
|
@ -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
|
||||
|
@ -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)
|
||||
|
@ -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
110
virtinst/cli.py
@ -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):
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
@ -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):
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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,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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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()
|
||||
|
@ -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)
|
||||
|
@ -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()
|
||||
|
@ -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)
|
||||
|
@ -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
|
||||
|
@ -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()
|
||||
|
||||
|
@ -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
|
||||
|
@ -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]
|
||||
|
@ -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
|
||||
|
Loading…
Reference in New Issue
Block a user