1448 lines
43 KiB
Python
1448 lines
43 KiB
Python
#
|
|
# Copyright (C) 2009, 2013, 2014 Red Hat, Inc.
|
|
# Copyright (C) 2009 Cole Robinson <crobinso@redhat.com>
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
# MA 02110-1301 USA.
|
|
#
|
|
|
|
import logging
|
|
import os
|
|
import statvfs
|
|
import pwd
|
|
|
|
# pylint: disable=E0611
|
|
from gi.repository import GObject
|
|
from gi.repository import Gtk
|
|
# pylint: enable=E0611
|
|
|
|
import libvirt
|
|
|
|
import virtinst
|
|
from virtManager import config
|
|
|
|
OPTICAL_DEV_PATH = 0
|
|
OPTICAL_LABEL = 1
|
|
OPTICAL_IS_MEDIA_PRESENT = 2
|
|
OPTICAL_DEV_KEY = 3
|
|
OPTICAL_MEDIA_KEY = 4
|
|
OPTICAL_IS_VALID = 5
|
|
|
|
try:
|
|
import gi
|
|
gi.check_version("3.7.4")
|
|
can_set_row_none = True
|
|
except (ValueError, AttributeError):
|
|
can_set_row_none = False
|
|
|
|
vm_status_icons = {
|
|
libvirt.VIR_DOMAIN_BLOCKED: "state_running",
|
|
libvirt.VIR_DOMAIN_CRASHED: "state_shutoff",
|
|
libvirt.VIR_DOMAIN_PAUSED: "state_paused",
|
|
libvirt.VIR_DOMAIN_RUNNING: "state_running",
|
|
libvirt.VIR_DOMAIN_SHUTDOWN: "state_shutoff",
|
|
libvirt.VIR_DOMAIN_SHUTOFF: "state_shutoff",
|
|
libvirt.VIR_DOMAIN_NOSTATE: "state_running",
|
|
# VIR_DOMAIN_PMSUSPENDED
|
|
7: "state_paused",
|
|
}
|
|
|
|
|
|
############################################################
|
|
# Helpers for shared storage UI between create/addhardware #
|
|
############################################################
|
|
|
|
def set_sparse_tooltip(widget):
|
|
sparse_str = _("Fully allocating storage may take longer now, "
|
|
"but the OS install phase will be quicker. \n\n"
|
|
"Skipping allocation can also cause space issues on "
|
|
"the host machine, if the maximum image size exceeds "
|
|
"available storage space. \n\n"
|
|
"Tip: Storage format qcow2 and qed "
|
|
"do not support full allocation.")
|
|
widget.set_tooltip_text(sparse_str)
|
|
|
|
|
|
def host_disk_space(conn):
|
|
pool = get_default_pool(conn)
|
|
path = get_default_dir(conn)
|
|
|
|
avail = 0
|
|
if pool and pool.is_active():
|
|
# FIXME: make sure not inactive?
|
|
# FIXME: use a conn specific function after we send pool-added
|
|
pool.refresh()
|
|
avail = int(pool.get_available())
|
|
|
|
elif not conn.is_remote() and os.path.exists(path):
|
|
vfs = os.statvfs(os.path.dirname(path))
|
|
avail = vfs[statvfs.F_FRSIZE] * vfs[statvfs.F_BAVAIL]
|
|
|
|
return float(avail / 1024.0 / 1024.0 / 1024.0)
|
|
|
|
|
|
def update_host_space(conn, widget):
|
|
try:
|
|
max_storage = host_disk_space(conn)
|
|
except:
|
|
logging.exception("Error determining host disk space")
|
|
return
|
|
|
|
def pretty_storage(size):
|
|
return "%.1f GB" % float(size)
|
|
|
|
hd_label = ("%s available in the default location" %
|
|
pretty_storage(max_storage))
|
|
hd_label = ("<span color='#484848'>%s</span>" % hd_label)
|
|
widget.set_markup(hd_label)
|
|
|
|
|
|
def check_default_pool_active(err, conn):
|
|
default_pool = get_default_pool(conn)
|
|
if default_pool and not default_pool.is_active():
|
|
res = err.yes_no(_("Default pool is not active."),
|
|
_("Storage pool '%s' is not active. "
|
|
"Would you like to start the pool "
|
|
"now?") % default_pool.get_name())
|
|
if not res:
|
|
return False
|
|
|
|
# Try to start the pool
|
|
try:
|
|
default_pool.start()
|
|
logging.info("Started pool '%s'", default_pool.get_name())
|
|
except Exception, e:
|
|
return err.show_err(_("Could not start storage_pool "
|
|
"'%s': %s") %
|
|
(default_pool.get_name(), str(e)))
|
|
return True
|
|
|
|
|
|
#####################################################
|
|
# Hardware model list building (for details, addhw) #
|
|
#####################################################
|
|
|
|
def set_combo_text_column(combo, col):
|
|
if combo.get_has_entry():
|
|
combo.set_entry_text_column(col)
|
|
else:
|
|
text = Gtk.CellRendererText()
|
|
combo.pack_start(text, True)
|
|
combo.add_attribute(text, 'text', col)
|
|
|
|
|
|
def build_video_combo(vm, combo, no_default=None):
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
combo.get_model().set_sort_column_id(1, Gtk.SortType.ASCENDING)
|
|
|
|
populate_video_combo(vm, combo, no_default)
|
|
|
|
|
|
def populate_video_combo(vm, combo, no_default=None):
|
|
model = combo.get_model()
|
|
has_spice = bool([g for g in vm.get_graphics_devices()
|
|
if g.type == g.TYPE_SPICE])
|
|
has_qxl = bool([v for v in vm.get_video_devices()
|
|
if v.model == "qxl"])
|
|
|
|
model.clear()
|
|
tmpdev = virtinst.VirtualVideoDevice(vm.conn.get_backend())
|
|
for m in tmpdev.MODELS:
|
|
if vm.stable_defaults():
|
|
if m == "qxl" and not has_spice and not has_qxl:
|
|
# Only list QXL video option when VM has SPICE video
|
|
continue
|
|
|
|
if m == tmpdev.MODEL_DEFAULT and no_default:
|
|
continue
|
|
model.append([m, tmpdev.pretty_model(m)])
|
|
|
|
if len(model) > 0:
|
|
combo.set_active(0)
|
|
|
|
|
|
def build_sound_combo(vm, combo, no_default=False):
|
|
model = Gtk.ListStore(str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 0)
|
|
model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
|
|
|
|
stable_defaults = vm.stable_defaults()
|
|
stable_soundmodels = ["ich6", "ac97"]
|
|
|
|
for m in virtinst.VirtualAudio.MODELS:
|
|
if m == virtinst.VirtualAudio.MODEL_DEFAULT and no_default:
|
|
continue
|
|
|
|
if (stable_defaults and m not in stable_soundmodels):
|
|
continue
|
|
|
|
model.append([m])
|
|
if len(model) > 0:
|
|
combo.set_active(0)
|
|
|
|
|
|
def build_watchdogmodel_combo(vm, combo, no_default=False):
|
|
ignore = vm
|
|
model = Gtk.ListStore(str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 0)
|
|
model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
|
|
|
|
for m in virtinst.VirtualWatchdog.MODELS:
|
|
if m == virtinst.VirtualAudio.MODEL_DEFAULT and no_default:
|
|
continue
|
|
model.append([m])
|
|
if len(model) > 0:
|
|
combo.set_active(0)
|
|
|
|
|
|
def build_watchdogaction_combo(vm, combo, no_default=False):
|
|
ignore = vm
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
|
|
|
|
for m in virtinst.VirtualWatchdog.ACTIONS:
|
|
if m == virtinst.VirtualWatchdog.ACTION_DEFAULT and no_default:
|
|
continue
|
|
model.append([m, virtinst.VirtualWatchdog.get_action_desc(m)])
|
|
if len(model) > 0:
|
|
combo.set_active(0)
|
|
|
|
|
|
def build_source_mode_combo(vm, combo):
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
|
|
populate_source_mode_combo(vm, combo)
|
|
combo.set_active(0)
|
|
|
|
|
|
def populate_source_mode_combo(vm, combo):
|
|
ignore = vm
|
|
model = combo.get_model()
|
|
model.clear()
|
|
|
|
# [xml value, label]
|
|
model.append([None, "Default"])
|
|
model.append(["vepa", "VEPA"])
|
|
model.append(["bridge", "Bridge"])
|
|
model.append(["private", "Private"])
|
|
model.append(["passthrough", "Passthrough"])
|
|
|
|
|
|
def build_smartcard_mode_combo(vm, combo):
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
|
|
|
|
populate_smartcard_mode_combo(vm, combo)
|
|
|
|
idx = -1
|
|
for rowid in range(len(combo.get_model())):
|
|
idx = 0
|
|
row = combo.get_model()[rowid]
|
|
if row[0] == virtinst.VirtualSmartCardDevice.MODE_DEFAULT:
|
|
idx = rowid
|
|
break
|
|
combo.set_active(idx)
|
|
|
|
|
|
def populate_smartcard_mode_combo(vm, combo):
|
|
ignore = vm
|
|
model = combo.get_model()
|
|
model.clear()
|
|
|
|
# [xml value, label]
|
|
model.append(["passthrough", "Passthrough"])
|
|
model.append(["host", "Host"])
|
|
|
|
|
|
def build_redir_type_combo(vm, combo):
|
|
model = Gtk.ListStore(str, str, bool)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
|
|
populate_redir_type_combo(vm, combo)
|
|
combo.set_active(0)
|
|
|
|
|
|
def populate_redir_type_combo(vm, combo):
|
|
ignore = vm
|
|
model = combo.get_model()
|
|
model.clear()
|
|
|
|
# [xml value, label, conn details]
|
|
model.append(["spicevmc", "Spice channel", False])
|
|
model.append(["tcp", "TCP", True])
|
|
|
|
|
|
def build_tpm_type_combo(vm, combo):
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
|
|
|
|
populate_tpm_type_combo(vm, combo)
|
|
|
|
idx = -1
|
|
for rowid in range(len(combo.get_model())):
|
|
idx = 0
|
|
row = combo.get_model()[rowid]
|
|
if row[0] == virtinst.VirtualTPMDevice.TYPE_DEFAULT:
|
|
idx = rowid
|
|
break
|
|
combo.set_active(idx)
|
|
|
|
|
|
def populate_tpm_type_combo(vm, combo):
|
|
ignore = vm
|
|
types = combo.get_model()
|
|
types.clear()
|
|
|
|
# [xml value, label]
|
|
for t in virtinst.VirtualTPMDevice.TYPES:
|
|
types.append([t, virtinst.VirtualTPMDevice.get_pretty_type(t)])
|
|
|
|
|
|
def build_netmodel_combo(vm, combo):
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
|
|
|
|
populate_netmodel_combo(vm, combo)
|
|
combo.set_active(0)
|
|
|
|
|
|
def populate_netmodel_combo(vm, combo):
|
|
model = combo.get_model()
|
|
model.clear()
|
|
|
|
# [xml value, label]
|
|
model.append([None, _("Hypervisor default")])
|
|
if vm.is_hvm():
|
|
mod_list = ["rtl8139", "ne2k_pci", "pcnet", "e1000"]
|
|
if vm.get_hv_type() in ["kvm", "qemu", "test"]:
|
|
mod_list.append("virtio")
|
|
if (vm.get_hv_type() == "kvm" and
|
|
vm.get_machtype() == "pseries"):
|
|
mod_list.append("spapr-vlan")
|
|
if vm.get_hv_type() in ["xen", "test"]:
|
|
mod_list.append("netfront")
|
|
mod_list.sort()
|
|
|
|
for m in mod_list:
|
|
model.append([m, m])
|
|
|
|
|
|
def build_cache_combo(vm, combo):
|
|
ignore = vm
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
|
|
combo.set_active(-1)
|
|
for m in virtinst.VirtualDisk.cache_types:
|
|
model.append([m, m])
|
|
|
|
_iter = model.insert(0, [None, "default"])
|
|
combo.set_active_iter(_iter)
|
|
|
|
|
|
def build_io_combo(vm, combo, no_default=False):
|
|
ignore = vm
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
model.set_sort_column_id(0, Gtk.SortType.ASCENDING)
|
|
|
|
combo.set_active(-1)
|
|
for m in virtinst.VirtualDisk.io_modes:
|
|
model.append([m, m])
|
|
|
|
if not no_default:
|
|
model.append([None, "default"])
|
|
combo.set_active(0)
|
|
|
|
|
|
def build_disk_bus_combo(vm, combo, no_default=False):
|
|
ignore = vm
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
model.set_sort_column_id(1, Gtk.SortType.ASCENDING)
|
|
|
|
if not no_default:
|
|
model.append([None, "default"])
|
|
combo.set_active(-1)
|
|
|
|
|
|
def build_vnc_keymap_combo(vm, combo, no_default=False):
|
|
ignore = vm
|
|
model = Gtk.ListStore(str, str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 1)
|
|
|
|
if not no_default:
|
|
model.append([None, "default"])
|
|
else:
|
|
model.append([None, "Auto"])
|
|
|
|
model.append([virtinst.VirtualGraphics.KEYMAP_LOCAL,
|
|
"Copy local keymap"])
|
|
for k in virtinst.VirtualGraphics.valid_keymaps():
|
|
model.append([k, k])
|
|
|
|
combo.set_active(-1)
|
|
|
|
|
|
#####################################
|
|
# Storage format list/combo helpers #
|
|
#####################################
|
|
|
|
def update_storage_format_combo(vm, combo, create):
|
|
model = Gtk.ListStore(str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 0)
|
|
|
|
formats = ["raw", "qcow2", "qed"]
|
|
no_create_formats = []
|
|
if not vm.stable_defaults():
|
|
formats.append("vmdk")
|
|
no_create_formats.append("vdi")
|
|
|
|
for m in formats:
|
|
model.append([m])
|
|
if not create:
|
|
for m in no_create_formats:
|
|
model.append([m])
|
|
|
|
if create:
|
|
combo.set_active(0)
|
|
|
|
|
|
#######################################################################
|
|
# Widgets for listing network device options (in create, addhardware) #
|
|
#######################################################################
|
|
|
|
def pretty_network_desc(nettype, source=None, netobj=None):
|
|
if nettype == virtinst.VirtualNetworkInterface.TYPE_USER:
|
|
return _("Usermode networking")
|
|
|
|
extra = None
|
|
if nettype == virtinst.VirtualNetworkInterface.TYPE_BRIDGE:
|
|
ret = _("Bridge")
|
|
elif nettype == virtinst.VirtualNetworkInterface.TYPE_VIRTUAL:
|
|
ret = _("Virtual network")
|
|
if netobj:
|
|
extra = ": %s" % netobj.pretty_forward_mode()
|
|
else:
|
|
ret = nettype.capitalize()
|
|
|
|
if source:
|
|
ret += " '%s'" % source
|
|
if extra:
|
|
ret += " %s" % extra
|
|
|
|
return ret
|
|
|
|
|
|
def init_network_list(net_list, bridge_box, source_mode_combo=None,
|
|
vport_expander=None):
|
|
# [ network type, source name, label, sensitive?, net is active,
|
|
# manual bridge, net instance]
|
|
net_model = Gtk.ListStore(str, str, str, bool, bool, bool, object)
|
|
net_list.set_model(net_model)
|
|
|
|
net_list.connect("changed", net_list_changed, bridge_box,
|
|
source_mode_combo, vport_expander)
|
|
|
|
text = Gtk.CellRendererText()
|
|
net_list.pack_start(text, True)
|
|
net_list.add_attribute(text, 'text', 2)
|
|
net_list.add_attribute(text, 'sensitive', 3)
|
|
|
|
|
|
def net_list_changed(net_list, bridge_box,
|
|
source_mode_combo, vport_expander):
|
|
active = net_list.get_active()
|
|
if active < 0:
|
|
return
|
|
|
|
if not bridge_box:
|
|
return
|
|
|
|
row = net_list.get_model()[active]
|
|
|
|
if source_mode_combo is not None:
|
|
doshow = (row[0] == virtinst.VirtualNetworkInterface.TYPE_DIRECT)
|
|
set_grid_row_visible(source_mode_combo, doshow)
|
|
vport_expander.set_visible(doshow)
|
|
|
|
show_bridge = row[5]
|
|
set_grid_row_visible(bridge_box, show_bridge)
|
|
|
|
|
|
def get_network_selection(net_list, bridge_entry):
|
|
idx = net_list.get_active()
|
|
if idx == -1:
|
|
return None, None
|
|
|
|
row = net_list.get_model()[net_list.get_active()]
|
|
net_type = row[0]
|
|
net_src = row[1]
|
|
net_check_bridge = row[5]
|
|
|
|
if net_check_bridge and bridge_entry:
|
|
net_type = virtinst.VirtualNetworkInterface.TYPE_BRIDGE
|
|
net_src = bridge_entry.get_text()
|
|
|
|
return net_type, net_src
|
|
|
|
|
|
def populate_network_list(net_list, conn, show_direct_interfaces=True):
|
|
model = net_list.get_model()
|
|
model.clear()
|
|
|
|
vnet_bridges = []
|
|
vnet_dict = {}
|
|
bridge_dict = {}
|
|
iface_dict = {}
|
|
|
|
def build_row(nettype, name, label, is_sensitive, is_running,
|
|
manual_bridge=False, key=None):
|
|
return [nettype, name, label,
|
|
is_sensitive, is_running, manual_bridge,
|
|
key]
|
|
|
|
def set_active(idx):
|
|
net_list.set_active(idx)
|
|
|
|
def add_dict(indict, model):
|
|
keylist = indict.keys()
|
|
keylist.sort()
|
|
rowlist = [indict[k] for k in keylist]
|
|
for row in rowlist:
|
|
model.append(row)
|
|
|
|
# For qemu:///session
|
|
if conn.is_qemu_session():
|
|
nettype = virtinst.VirtualNetworkInterface.TYPE_USER
|
|
r = build_row(nettype, None, pretty_network_desc(nettype), True, True)
|
|
model.append(r)
|
|
set_active(0)
|
|
return
|
|
|
|
hasNet = False
|
|
netIdxLabel = None
|
|
# Virtual Networks
|
|
for uuid in conn.list_net_uuids():
|
|
net = conn.get_net(uuid)
|
|
nettype = virtinst.VirtualNetworkInterface.TYPE_VIRTUAL
|
|
|
|
label = pretty_network_desc(nettype, net.get_name(), net)
|
|
if not net.is_active():
|
|
label += " (%s)" % _("Inactive")
|
|
|
|
hasNet = True
|
|
# FIXME: Should we use 'default' even if it's inactive?
|
|
# FIXME: This preference should be configurable
|
|
if net.get_name() == "default":
|
|
netIdxLabel = label
|
|
|
|
vnet_dict[label] = build_row(nettype, net.get_name(), label, True,
|
|
net.is_active(), key=net.get_uuid())
|
|
|
|
# Build a list of vnet bridges, so we know not to list them
|
|
# in the physical interface list
|
|
vnet_bridge = net.get_bridge_device()
|
|
if vnet_bridge:
|
|
vnet_bridges.append(vnet_bridge)
|
|
|
|
if not hasNet:
|
|
label = _("No virtual networks available")
|
|
vnet_dict[label] = build_row(None, None, label, False, False)
|
|
|
|
vnet_taps = []
|
|
for vm in conn.vms.values():
|
|
for nic in vm.get_network_devices(refresh_if_nec=False):
|
|
if nic.target_dev and nic.target_dev not in vnet_taps:
|
|
vnet_taps.append(nic.target_dev)
|
|
|
|
skip_ifaces = ["lo"]
|
|
|
|
# Physical devices
|
|
hasShared = False
|
|
brIdxLabel = None
|
|
for name in conn.list_net_device_paths():
|
|
br = conn.get_net_device(name)
|
|
bridge_name = br.get_bridge()
|
|
nettype = virtinst.VirtualNetworkInterface.TYPE_BRIDGE
|
|
|
|
if ((bridge_name in vnet_bridges) or
|
|
(br.get_name() in vnet_bridges) or
|
|
(br.get_name() in vnet_taps) or
|
|
(br.get_name() in [v + "-nic" for v in vnet_bridges]) or
|
|
(br.get_name() in skip_ifaces)):
|
|
# Don't list this, as it is basically duplicating virtual net info
|
|
continue
|
|
|
|
if br.is_shared():
|
|
sensitive = True
|
|
if br.get_bridge():
|
|
hasShared = True
|
|
brlabel = "(%s)" % pretty_network_desc(nettype, bridge_name)
|
|
else:
|
|
bridge_name = name
|
|
brlabel = _("(Empty bridge)")
|
|
else:
|
|
if (show_direct_interfaces and
|
|
conn.check_support(
|
|
conn.SUPPORT_CONN_DIRECT_INTERFACE)):
|
|
sensitive = True
|
|
nettype = virtinst.VirtualNetworkInterface.TYPE_DIRECT
|
|
bridge_name = name
|
|
brlabel = ": %s" % _("macvtap")
|
|
else:
|
|
sensitive = False
|
|
brlabel = "(%s)" % _("Not bridged")
|
|
|
|
label = _("Host device %s %s") % (br.get_name(), brlabel)
|
|
if hasShared and not brIdxLabel:
|
|
brIdxLabel = label
|
|
|
|
row = build_row(nettype, bridge_name, label, sensitive, True,
|
|
key=br.get_name())
|
|
|
|
if sensitive:
|
|
bridge_dict[label] = row
|
|
else:
|
|
iface_dict[label] = row
|
|
|
|
add_dict(bridge_dict, model)
|
|
add_dict(vnet_dict, model)
|
|
add_dict(iface_dict, model)
|
|
|
|
# If there is a bridge device, default to that
|
|
# If not, use 'default' network
|
|
# If not present, use first list entry
|
|
# If list empty, use no network devices
|
|
return_warn = False
|
|
label = brIdxLabel or netIdxLabel
|
|
|
|
for idx in range(len(model)):
|
|
row = model[idx]
|
|
is_inactive = not row[4]
|
|
if label:
|
|
if row[2] == label:
|
|
default = idx
|
|
return_warn = is_inactive
|
|
break
|
|
else:
|
|
if row[3] is True:
|
|
default = idx
|
|
return_warn = is_inactive
|
|
break
|
|
else:
|
|
return_warn = True
|
|
row = build_row(None, None, _("No networking"), True, False)
|
|
model.insert(0, row)
|
|
default = 0
|
|
|
|
# After all is said and done, add a manual bridge option
|
|
manual_row = build_row(None, None, _("Specify shared device name"),
|
|
True, False, manual_bridge=True)
|
|
model.append(manual_row)
|
|
|
|
set_active(default)
|
|
return return_warn
|
|
|
|
|
|
def validate_network(err, conn, nettype, devname, macaddr, model=None):
|
|
net = None
|
|
|
|
if nettype is None:
|
|
return None
|
|
|
|
# Make sure VirtualNetwork is running
|
|
netobj = None
|
|
if nettype == virtinst.VirtualNetworkInterface.TYPE_VIRTUAL:
|
|
for net in conn.nets.values():
|
|
if net.get_name() == devname:
|
|
netobj = net
|
|
break
|
|
|
|
if netobj and not netobj.is_active():
|
|
res = err.yes_no(_("Virtual Network is not active."),
|
|
_("Virtual Network '%s' is not active. "
|
|
"Would you like to start the network "
|
|
"now?") % devname)
|
|
if not res:
|
|
return False
|
|
|
|
# Try to start the network
|
|
try:
|
|
netobj.start()
|
|
netobj.tick()
|
|
logging.info("Started network '%s'", devname)
|
|
except Exception, e:
|
|
return err.show_err(_("Could not start virtual network "
|
|
"'%s': %s") % (devname, str(e)))
|
|
|
|
# Create network device
|
|
try:
|
|
net = virtinst.VirtualNetworkInterface(conn.get_backend())
|
|
net.type = nettype
|
|
net.source = devname
|
|
net.macaddr = macaddr
|
|
net.model = model
|
|
if net.model == "spapr-vlan":
|
|
net.address.set_addrstr("spapr-vio")
|
|
|
|
|
|
except Exception, e:
|
|
return err.val_err(_("Error with network parameters."), e)
|
|
|
|
# Make sure there is no mac address collision
|
|
isfatal, errmsg = net.is_conflict_net(conn.get_backend(), net.macaddr)
|
|
if isfatal:
|
|
return err.val_err(_("Mac address collision."), errmsg)
|
|
elif errmsg is not None:
|
|
retv = err.yes_no(_("Mac address collision."),
|
|
_("%s Are you sure you want to use this "
|
|
"address?") % errmsg)
|
|
if not retv:
|
|
return False
|
|
|
|
return net
|
|
|
|
|
|
############################################
|
|
# Populate media widget (choosecd, create) #
|
|
############################################
|
|
|
|
def init_mediadev_combo(widget):
|
|
# [Device path, pretty label, has_media?, device key, media key,
|
|
# vmmMediaDevice, is valid device]
|
|
model = Gtk.ListStore(str, str, bool, str, str, bool)
|
|
widget.set_model(model)
|
|
model.clear()
|
|
|
|
text = Gtk.CellRendererText()
|
|
widget.pack_start(text, True)
|
|
widget.add_attribute(text, 'text', OPTICAL_LABEL)
|
|
widget.add_attribute(text, 'sensitive', OPTICAL_IS_VALID)
|
|
|
|
|
|
def populate_mediadev_combo(conn, widget, devtype):
|
|
sigs = []
|
|
|
|
model = widget.get_model()
|
|
model.clear()
|
|
set_mediadev_default(model)
|
|
|
|
sigs.append(conn.connect("mediadev-added", mediadev_added, widget, devtype))
|
|
sigs.append(conn.connect("mediadev-removed", mediadev_removed, widget))
|
|
|
|
widget.set_active(-1)
|
|
mediadev_set_default_selection(widget)
|
|
|
|
return sigs
|
|
|
|
|
|
def set_mediadev_default(model):
|
|
if len(model) == 0:
|
|
model.append([None, _("No device present"), False, None, None, False])
|
|
|
|
|
|
def set_row_from_object(row, obj):
|
|
row[OPTICAL_DEV_PATH] = obj.get_path()
|
|
row[OPTICAL_LABEL] = obj.pretty_label()
|
|
row[OPTICAL_IS_MEDIA_PRESENT] = obj.has_media()
|
|
row[OPTICAL_DEV_KEY] = obj.get_key()
|
|
row[OPTICAL_MEDIA_KEY] = obj.get_media_key()
|
|
row[OPTICAL_IS_VALID] = True
|
|
|
|
|
|
def mediadev_removed(ignore_helper, key, widget):
|
|
model = widget.get_model()
|
|
active = widget.get_active()
|
|
idx = 0
|
|
|
|
for row in model:
|
|
if row[OPTICAL_DEV_KEY] == key:
|
|
# Whole device removed
|
|
del(model[idx])
|
|
|
|
if idx > active and active != -1:
|
|
widget.set_active(active - 1)
|
|
elif idx == active:
|
|
widget.set_active(-1)
|
|
|
|
idx += 1
|
|
|
|
set_mediadev_default(model)
|
|
mediadev_set_default_selection(widget)
|
|
|
|
|
|
def mediadev_added(ignore_helper, newobj, widget, devtype):
|
|
model = widget.get_model()
|
|
|
|
if newobj.get_media_type() != devtype:
|
|
return
|
|
if model is None:
|
|
return
|
|
|
|
if len(model) == 1 and model[0][OPTICAL_IS_VALID] is False:
|
|
# Only entry is the 'No device' entry
|
|
model.clear()
|
|
|
|
newobj.connect("media-added", mediadev_media_changed, widget)
|
|
newobj.connect("media-removed", mediadev_media_changed, widget)
|
|
|
|
# Brand new device
|
|
row = [None, None, None, None, None, None]
|
|
set_row_from_object(row, newobj)
|
|
model.append(row)
|
|
|
|
mediadev_set_default_selection(widget)
|
|
|
|
|
|
def mediadev_media_changed(newobj, widget):
|
|
model = widget.get_model()
|
|
active = widget.get_active()
|
|
idx = 0
|
|
|
|
# Search for the row with matching device node and
|
|
# fill in info about inserted media. If model has no current
|
|
# selection, select the new media.
|
|
for row in model:
|
|
if row[OPTICAL_DEV_PATH] == newobj.get_path():
|
|
set_row_from_object(row, newobj)
|
|
has_media = row[OPTICAL_IS_MEDIA_PRESENT]
|
|
|
|
if has_media and active == -1:
|
|
widget.set_active(idx)
|
|
elif not has_media and active == idx:
|
|
widget.set_active(-1)
|
|
|
|
idx = idx + 1
|
|
|
|
mediadev_set_default_selection(widget)
|
|
|
|
|
|
def mediadev_set_default_selection(widget):
|
|
# Set the first active cdrom device as selected, otherwise none
|
|
model = widget.get_model()
|
|
idx = 0
|
|
active = widget.get_active()
|
|
|
|
if active != -1:
|
|
# already a selection, don't change it
|
|
return
|
|
|
|
for row in model:
|
|
if row[OPTICAL_IS_MEDIA_PRESENT] is True:
|
|
widget.set_active(idx)
|
|
return
|
|
idx += 1
|
|
|
|
widget.set_active(-1)
|
|
|
|
|
|
####################################################################
|
|
# Build toolbar shutdown button menu (manager and details toolbar) #
|
|
####################################################################
|
|
|
|
class _VMMenu(Gtk.Menu):
|
|
# pylint: disable=E1101
|
|
# pylint can't detect functions we inheirit from Gtk, ex self.add
|
|
|
|
def __init__(self, src, current_vm_cb, show_open=True):
|
|
Gtk.Menu.__init__(self)
|
|
self._parent = src
|
|
self._current_vm_cb = current_vm_cb
|
|
self._show_open = show_open
|
|
|
|
self._init_state()
|
|
|
|
def _add_action(self, label, signal,
|
|
iconname="system-shutdown", addcb=True):
|
|
if label.startswith("gtk-"):
|
|
item = Gtk.ImageMenuItem.new_from_stock(label, None)
|
|
else:
|
|
item = Gtk.ImageMenuItem.new_with_mnemonic(label)
|
|
|
|
if iconname:
|
|
if iconname.startswith("gtk-"):
|
|
icon = Gtk.Image.new_from_stock(iconname, Gtk.IconSize.MENU)
|
|
else:
|
|
icon = Gtk.Image.new_from_icon_name(iconname,
|
|
Gtk.IconSize.MENU)
|
|
item.set_image(icon)
|
|
|
|
item.vmm_widget_name = signal
|
|
if addcb:
|
|
item.connect("activate", self._action_cb)
|
|
self.add(item)
|
|
return item
|
|
|
|
def _action_cb(self, src):
|
|
vm = self._current_vm_cb()
|
|
if not vm:
|
|
return
|
|
self._parent.emit("action-%s-domain" % src.vmm_widget_name,
|
|
vm.conn.get_uri(), vm.get_uuid())
|
|
|
|
def _init_state(self):
|
|
raise NotImplementedError()
|
|
def update_widget_states(self, vm):
|
|
raise NotImplementedError()
|
|
|
|
|
|
class VMShutdownMenu(_VMMenu):
|
|
# pylint: disable=E1101
|
|
# pylint can't detect functions we inheirit from Gtk, ex self.add
|
|
|
|
def _init_state(self):
|
|
self._add_action(_("_Reboot"), "reboot")
|
|
self._add_action(_("_Shut Down"), "shutdown")
|
|
self._add_action(_("F_orce Reset"), "reset")
|
|
self._add_action(_("_Force Off"), "destroy")
|
|
self.add(Gtk.SeparatorMenuItem())
|
|
self._add_action(_("Sa_ve"), "save", iconname=Gtk.STOCK_SAVE)
|
|
|
|
self.show_all()
|
|
|
|
def update_widget_states(self, vm):
|
|
statemap = {
|
|
"reboot": bool(vm and vm.is_stoppable()),
|
|
"shutdown": bool(vm and vm.is_stoppable()),
|
|
"reset": bool(vm and vm.is_stoppable()),
|
|
"save": bool(vm and vm.is_destroyable()),
|
|
"destroy": bool(vm and vm.is_destroyable()),
|
|
}
|
|
|
|
for child in self.get_children():
|
|
name = getattr(child, "vmm_widget_name", None)
|
|
if name in statemap:
|
|
child.set_sensitive(statemap[name])
|
|
|
|
|
|
class VMActionMenu(_VMMenu):
|
|
# pylint: disable=E1101
|
|
# pylint can't detect functions we inheirit from Gtk, ex self.add
|
|
|
|
def _init_state(self):
|
|
self._add_action(_("_Run"), "run", Gtk.STOCK_MEDIA_PLAY)
|
|
self._add_action(_("_Pause"), "suspend", Gtk.STOCK_MEDIA_PAUSE)
|
|
self._add_action(_("R_esume"), "resume", Gtk.STOCK_MEDIA_PAUSE)
|
|
s = self._add_action(_("_Shut Down"), "shutdown", addcb=False)
|
|
s.set_submenu(VMShutdownMenu(self._parent, self._current_vm_cb))
|
|
|
|
self.add(Gtk.SeparatorMenuItem())
|
|
self._add_action(_("Clone..."), "clone", None)
|
|
self._add_action(_("Migrate..."), "migrate", None)
|
|
self._add_action(_("_Delete"), "delete", Gtk.STOCK_DELETE)
|
|
|
|
if self._show_open:
|
|
self.add(Gtk.SeparatorMenuItem())
|
|
self._add_action(Gtk.STOCK_OPEN, "show", None)
|
|
|
|
self.show_all()
|
|
|
|
def update_widget_states(self, vm):
|
|
statemap = {
|
|
"run": bool(vm and vm.is_runable()),
|
|
"shutdown": bool(vm and vm.is_stoppable()),
|
|
"suspend": bool(vm and vm.is_stoppable()),
|
|
"resume": bool(vm and vm.is_paused()),
|
|
"migrate": bool(vm and vm.is_stoppable()),
|
|
"clone": bool(vm and not vm.is_read_only()),
|
|
}
|
|
vismap = {
|
|
"suspend": bool(vm and not vm.is_paused()),
|
|
"resume": bool(vm and vm.is_paused()),
|
|
}
|
|
|
|
for child in self.get_children():
|
|
name = getattr(child, "vmm_widget_name", None)
|
|
if hasattr(child, "update_widget_states"):
|
|
child.update_widget_states(vm)
|
|
if name in statemap:
|
|
child.set_sensitive(statemap[name])
|
|
if name in vismap:
|
|
child.set_visible(vismap[name])
|
|
|
|
def change_run_text(self, text):
|
|
for child in self.get_children():
|
|
if getattr(child, "vmm_widget_name", None) == "run":
|
|
child.get_child().set_label(text)
|
|
|
|
|
|
#####################################
|
|
# Path permissions checker for qemu #
|
|
#####################################
|
|
|
|
def check_path_search_for_qemu(err, conn, path):
|
|
if conn.is_remote() or not conn.is_qemu_system():
|
|
return
|
|
|
|
user = config.running_config.default_qemu_user
|
|
|
|
for i in conn.caps.host.secmodels:
|
|
if i.model == "dac":
|
|
label = i.baselabels.get("kvm") or i.baselabels.get("qemu")
|
|
if not label:
|
|
continue
|
|
pwuid = pwd.getpwuid(int(label.split(":")[0].replace("+", "")))
|
|
if pwuid:
|
|
user = pwuid[0]
|
|
|
|
skip_paths = config.running_config.get_perms_fix_ignore()
|
|
broken_paths = virtinst.VirtualDisk.check_path_search_for_user(
|
|
conn.get_backend(),
|
|
path, user)
|
|
for p in broken_paths:
|
|
if p in skip_paths:
|
|
broken_paths.remove(p)
|
|
|
|
if not broken_paths:
|
|
return
|
|
|
|
logging.debug("No search access for dirs: %s", broken_paths)
|
|
resp, chkres = err.warn_chkbox(
|
|
_("The emulator may not have search permissions "
|
|
"for the path '%s'.") % path,
|
|
_("Do you want to correct this now?"),
|
|
_("Don't ask about these directories again."),
|
|
buttons=Gtk.ButtonsType.YES_NO)
|
|
|
|
if chkres:
|
|
config.running_config.add_perms_fix_ignore(broken_paths)
|
|
if not resp:
|
|
return
|
|
|
|
logging.debug("Attempting to correct permission issues.")
|
|
errors = virtinst.VirtualDisk.fix_path_search_for_user(conn.get_backend(),
|
|
path, user)
|
|
if not errors:
|
|
return
|
|
|
|
errmsg = _("Errors were encountered changing permissions for the "
|
|
"following directories:")
|
|
details = ""
|
|
for path, error in errors.items():
|
|
if path not in broken_paths:
|
|
continue
|
|
details += "%s : %s\n" % (path, error)
|
|
|
|
logging.debug("Permission errors:\n%s", details)
|
|
|
|
ignore, chkres = err.err_chkbox(errmsg, details,
|
|
_("Don't ask about these directories again."))
|
|
|
|
if chkres:
|
|
config.running_config.add_perms_fix_ignore(errors.keys())
|
|
|
|
|
|
######################################
|
|
# Interface startmode widget builder #
|
|
######################################
|
|
|
|
def build_startmode_combo(combo):
|
|
model = Gtk.ListStore(str)
|
|
combo.set_model(model)
|
|
set_combo_text_column(combo, 0)
|
|
|
|
model.append(["none"])
|
|
model.append(["onboot"])
|
|
model.append(["hotplug"])
|
|
|
|
|
|
#########################
|
|
# Console keycombo menu #
|
|
#########################
|
|
|
|
def build_keycombo_menu(cb):
|
|
menu = Gtk.Menu()
|
|
|
|
def make_item(name, combo):
|
|
item = Gtk.MenuItem.new_with_mnemonic(name)
|
|
item.connect("activate", cb, combo)
|
|
|
|
menu.add(item)
|
|
|
|
make_item("Ctrl+Alt+_Backspace", ["Control_L", "Alt_L", "BackSpace"])
|
|
make_item("Ctrl+Alt+_Delete", ["Control_L", "Alt_L", "Delete"])
|
|
menu.add(Gtk.SeparatorMenuItem())
|
|
|
|
for i in range(1, 13):
|
|
make_item("Ctrl+Alt+F_%d" % i, ["Control_L", "Alt_L", "F%d" % i])
|
|
menu.add(Gtk.SeparatorMenuItem())
|
|
|
|
make_item("_Printscreen", ["Print"])
|
|
|
|
menu.show_all()
|
|
return menu
|
|
|
|
|
|
#############
|
|
# Misc bits #
|
|
#############
|
|
|
|
def spin_get_helper(widget):
|
|
adj = widget.get_adjustment()
|
|
txt = widget.get_text()
|
|
|
|
try:
|
|
ret = int(txt)
|
|
except:
|
|
ret = adj.get_value()
|
|
return ret
|
|
|
|
|
|
def get_ideal_path_info(conn, name):
|
|
path = get_default_dir(conn)
|
|
suffix = ".img"
|
|
return (path, name, suffix)
|
|
|
|
|
|
def get_ideal_path(conn, name):
|
|
target, name, suffix = get_ideal_path_info(conn, name)
|
|
return os.path.join(target, name) + suffix
|
|
|
|
|
|
def get_default_pool(conn):
|
|
pool = None
|
|
for uuid in conn.list_pool_uuids():
|
|
p = conn.get_pool(uuid)
|
|
if p.get_name() == "default":
|
|
pool = p
|
|
|
|
return pool
|
|
|
|
|
|
def get_default_dir(conn):
|
|
pool = get_default_pool(conn)
|
|
|
|
if pool:
|
|
return pool.get_target_path()
|
|
else:
|
|
return config.running_config.get_default_image_dir(conn)
|
|
|
|
|
|
def get_default_path(conn, name, collidelist=None):
|
|
collidelist = collidelist or []
|
|
pool = get_default_pool(conn)
|
|
|
|
default_dir = get_default_dir(conn)
|
|
|
|
def path_exists(p):
|
|
return os.path.exists(p) or p in collidelist
|
|
|
|
if not pool:
|
|
# Use old generating method
|
|
origf = os.path.join(default_dir, name + ".img")
|
|
f = origf
|
|
|
|
n = 1
|
|
while path_exists(f) and n < 100:
|
|
f = os.path.join(default_dir, name +
|
|
"-" + str(n) + ".img")
|
|
n += 1
|
|
|
|
if path_exists(f):
|
|
f = origf
|
|
|
|
path = f
|
|
else:
|
|
target, ignore, suffix = get_ideal_path_info(conn, name)
|
|
|
|
# Sanitize collidelist to work with the collision checker
|
|
newcollidelist = []
|
|
for c in collidelist:
|
|
if c and os.path.dirname(c) == pool.get_target_path():
|
|
newcollidelist.append(os.path.basename(c))
|
|
|
|
path = virtinst.StorageVolume.find_free_name(
|
|
pool.get_backend(), name,
|
|
suffix=suffix, collidelist=newcollidelist)
|
|
|
|
path = os.path.join(target, path)
|
|
|
|
return path
|
|
|
|
|
|
def browse_local(parent, dialog_name, conn, start_folder=None,
|
|
_type=None, dialog_type=None,
|
|
confirm_func=None, browse_reason=None,
|
|
choose_button=None, default_name=None):
|
|
"""
|
|
Helper function for launching a filechooser
|
|
|
|
@param parent: Parent window for the filechooser
|
|
@param dialog_name: String to use in the title bar of the filechooser.
|
|
@param conn: vmmConnection used by calling class
|
|
@param start_folder: Folder the filechooser is viewing at startup
|
|
@param _type: File extension to filter by (e.g. "iso", "png")
|
|
@param dialog_type: Maps to FileChooserDialog 'action'
|
|
@param confirm_func: Optional callback function if file is chosen.
|
|
@param browse_reason: The vmmConfig.CONFIG_DIR* reason we are browsing.
|
|
If set, this will override the 'folder' parameter with the gconf
|
|
value, and store the user chosen path.
|
|
|
|
"""
|
|
# Initial setup
|
|
overwrite_confirm = False
|
|
|
|
if dialog_type is None:
|
|
dialog_type = Gtk.FileChooserAction.OPEN
|
|
if dialog_type == Gtk.FileChooserAction.SAVE:
|
|
if choose_button is None:
|
|
choose_button = Gtk.STOCK_SAVE
|
|
overwrite_confirm = True
|
|
|
|
if choose_button is None:
|
|
choose_button = Gtk.STOCK_OPEN
|
|
|
|
fcdialog = Gtk.FileChooserDialog(title=dialog_name,
|
|
parent=parent,
|
|
action=dialog_type,
|
|
buttons=(Gtk.STOCK_CANCEL,
|
|
Gtk.ResponseType.CANCEL,
|
|
choose_button,
|
|
Gtk.ResponseType.ACCEPT))
|
|
fcdialog.set_default_response(Gtk.ResponseType.ACCEPT)
|
|
|
|
if default_name:
|
|
fcdialog.set_current_name(default_name)
|
|
|
|
# If confirm is set, warn about a file overwrite
|
|
if confirm_func:
|
|
overwrite_confirm = True
|
|
fcdialog.connect("confirm-overwrite", confirm_func)
|
|
fcdialog.set_do_overwrite_confirmation(overwrite_confirm)
|
|
|
|
# Set file match pattern (ex. *.png)
|
|
if _type is not None:
|
|
pattern = _type
|
|
name = None
|
|
if type(_type) is tuple:
|
|
pattern = _type[0]
|
|
name = _type[1]
|
|
|
|
f = Gtk.FileFilter()
|
|
f.add_pattern("*." + pattern)
|
|
if name:
|
|
f.set_name(name)
|
|
fcdialog.set_filter(f)
|
|
|
|
# Set initial dialog folder
|
|
if browse_reason:
|
|
start_folder = config.running_config.get_default_directory(conn,
|
|
browse_reason)
|
|
|
|
if start_folder is not None:
|
|
if os.access(start_folder, os.R_OK):
|
|
fcdialog.set_current_folder(start_folder)
|
|
|
|
# Run the dialog and parse the response
|
|
ret = None
|
|
if fcdialog.run() == Gtk.ResponseType.ACCEPT:
|
|
ret = fcdialog.get_filename()
|
|
fcdialog.destroy()
|
|
|
|
# Store the chosen directory in gconf if necessary
|
|
if ret and browse_reason and not ret.startswith("/dev"):
|
|
config.running_config.set_default_directory(os.path.dirname(ret),
|
|
browse_reason)
|
|
return ret
|
|
|
|
|
|
def pretty_hv(gtype, domtype):
|
|
"""
|
|
Convert XML <domain type='foo'> and <os><type>bar</type>
|
|
into a more human relevant string.
|
|
"""
|
|
|
|
gtype = gtype.lower()
|
|
domtype = domtype.lower()
|
|
|
|
label = domtype
|
|
if domtype == "kvm":
|
|
if gtype == "xen":
|
|
label = "xenner"
|
|
elif domtype == "xen":
|
|
if gtype == "xen":
|
|
label = "xen (paravirt)"
|
|
elif gtype == "hvm":
|
|
label = "xen (fullvirt)"
|
|
elif domtype == "test":
|
|
if gtype == "xen":
|
|
label = "test (xen)"
|
|
elif gtype == "hvm":
|
|
label = "test (hvm)"
|
|
|
|
return label
|
|
|
|
|
|
def iface_in_use_by(conn, name):
|
|
use_str = ""
|
|
for i in conn.list_interface_names():
|
|
iface = conn.get_interface(i)
|
|
if name in iface.get_slave_names():
|
|
if use_str:
|
|
use_str += ", "
|
|
use_str += iface.get_name()
|
|
|
|
return use_str
|
|
|
|
|
|
def chkbox_helper(src, getcb, setcb, text1, text2=None,
|
|
alwaysrecord=False,
|
|
default=True,
|
|
chktext=_("Don't ask me again")):
|
|
"""
|
|
Helper to prompt user about proceeding with an operation
|
|
Returns True if the 'yes' or 'ok' button was selected, False otherwise
|
|
|
|
@alwaysrecord: Don't require user to select 'yes' to record chkbox value
|
|
@default: What value to return if getcb tells us not to prompt
|
|
"""
|
|
do_prompt = getcb()
|
|
if not do_prompt:
|
|
return default
|
|
|
|
res = src.err.warn_chkbox(text1=text1, text2=text2,
|
|
chktext=chktext,
|
|
buttons=Gtk.ButtonsType.YES_NO)
|
|
response, skip_prompt = res
|
|
if alwaysrecord or response:
|
|
setcb(not skip_prompt)
|
|
|
|
return response
|
|
|
|
|
|
def get_list_selection(widget):
|
|
selection = widget.get_selection()
|
|
active = selection.get_selected()
|
|
|
|
treestore, treeiter = active
|
|
if treeiter is not None:
|
|
return treestore[treeiter]
|
|
return None
|
|
|
|
|
|
def set_list_selection(widget, rownum):
|
|
path = str(rownum)
|
|
selection = widget.get_selection()
|
|
|
|
selection.unselect_all()
|
|
widget.set_cursor(path)
|
|
selection.select_path(path)
|
|
|
|
|
|
def set_row_selection(listwidget, prevkey):
|
|
model = listwidget.get_model()
|
|
_iter = None
|
|
if prevkey:
|
|
for row in model:
|
|
if row[0] == prevkey:
|
|
_iter = row.iter
|
|
break
|
|
if not _iter:
|
|
_iter = model.get_iter_first()
|
|
|
|
if hasattr(listwidget, "get_selection"):
|
|
selection = listwidget.get_selection()
|
|
cb = selection.select_iter
|
|
else:
|
|
selection = listwidget
|
|
cb = selection.set_active_iter
|
|
if _iter:
|
|
cb(_iter)
|
|
selection.emit("changed")
|
|
|
|
|
|
def child_get_property(parent, child, propname):
|
|
# Wrapper for child_get_property, which pygobject doesn't properly
|
|
# introspect
|
|
value = GObject.Value()
|
|
value.init(GObject.TYPE_INT)
|
|
parent.child_get_property(child, propname, value)
|
|
return value.get_int()
|
|
|
|
|
|
def set_grid_row_visible(child, visible):
|
|
# For the passed widget, find its parent GtkGrid, and hide/show all
|
|
# elements that are in the same row as it. Simplifies having to name
|
|
# every element in a row when we want to dynamically hide things
|
|
# based on UI interraction
|
|
|
|
parent = child.get_parent()
|
|
if not type(parent) is Gtk.Grid:
|
|
raise RuntimeError("Programming error, parent must be grid, "
|
|
"not %s" % type(parent))
|
|
|
|
row = child_get_property(parent, child, "top-attach")
|
|
for child in parent.get_children():
|
|
if child_get_property(parent, child, "top-attach") == row:
|
|
child.set_visible(visible)
|
|
|
|
|
|
def default_uri(always_system=False):
|
|
if os.path.exists('/var/lib/xend'):
|
|
if (os.path.exists('/dev/xen/evtchn') or
|
|
os.path.exists("/proc/xen")):
|
|
return 'xen:///'
|
|
|
|
if (os.path.exists("/usr/bin/qemu") or
|
|
os.path.exists("/usr/bin/qemu-kvm") or
|
|
os.path.exists("/usr/bin/kvm") or
|
|
os.path.exists("/usr/libexec/qemu-kvm")):
|
|
if always_system or os.geteuid() == 0:
|
|
return "qemu:///system"
|
|
else:
|
|
return "qemu:///session"
|
|
return None
|
|
|
|
|
|
def exception_is_libvirt_error(e, error):
|
|
return (hasattr(libvirt, error) and
|
|
e.get_error_code() == getattr(libvirt, error))
|
|
|
|
|
|
def log_redefine_xml_diff(obj, origxml, newxml):
|
|
objname = "<%s name=%s>" % (obj.__class__.__name__, obj.get_name())
|
|
if origxml == newxml:
|
|
logging.debug("Redefine requested for %s, but XML didn't change!",
|
|
objname)
|
|
return
|
|
|
|
import difflib
|
|
diff = "".join(difflib.unified_diff(origxml.splitlines(1),
|
|
newxml.splitlines(1),
|
|
fromfile="Original XML",
|
|
tofile="New XML"))
|
|
logging.debug("Redefining %s with XML diff:\n%s", objname, diff)
|