mirror of
https://github.com/virt-manager/virt-manager.git
synced 2024-12-23 17:34:21 +03:00
87e0ed5de0
This reverts commit aaabb44ac7
.
I figured out how to trigger this: it's when scaling is enabled.
To maintain VM aspect ratio, we have to constrain the size of the
viewer widget. When the widget is smaller than the VM window, the
viewport widget is visible. This change made the viewport the default
theme color, rather than black.
Problem is, in the non-scaling case, we don't shrink the viewer
widget but let it expand to fill the whole area. This is necessary
to get the 'Autoresize VM with window' option to work, but is also
simpler in the cdoe. The viewport widget is not visible, and gtk-vnc
and spice-gtk paint the non VM owned areas as black. AFAICT that's not
configurable in any way.
So after this change we have differing behavior for scaled and
non-scaled cases, which is confusing and visually kinda comes off as
a bug.
So this reverts back to the old behavior and explains all this in
a comment.
1008 lines
35 KiB
Python
1008 lines
35 KiB
Python
# Copyright (C) 2006-2008, 2015 Red Hat, Inc.
|
|
# Copyright (C) 2006 Daniel P. Berrange <berrange@redhat.com>
|
|
# Copyright (C) 2010 Marc-Andre Lureau <marcandre.lureau@redhat.com>
|
|
#
|
|
# This work is licensed under the GNU GPLv2 or later.
|
|
# See the COPYING file in the top-level directory.
|
|
|
|
from gi.repository import Gtk
|
|
from gi.repository import Gdk
|
|
|
|
from virtinst import log
|
|
|
|
from .serialcon import vmmSerialConsole
|
|
from .sshtunnels import ConnectionInfo
|
|
from .viewers import SpiceViewer, VNCViewer, have_spice_gtk
|
|
from ..baseclass import vmmGObject, vmmGObjectUI
|
|
from ..lib.keyring import vmmKeyring
|
|
|
|
|
|
# console-pages IDs
|
|
(_CONSOLE_PAGE_UNAVAILABLE,
|
|
_CONSOLE_PAGE_SERIAL,
|
|
_CONSOLE_PAGE_GRAPHICS) = range(3)
|
|
|
|
# console-gfx-pages IDs
|
|
(_GFX_PAGE_VIEWER,
|
|
_GFX_PAGE_AUTH,
|
|
_GFX_PAGE_UNAVAILABLE,
|
|
_GFX_PAGE_CONNECT) = range(4)
|
|
|
|
|
|
class _TimedRevealer(vmmGObject):
|
|
"""
|
|
Revealer for the fullscreen toolbar, with a bit of extra logic to
|
|
hide/show based on mouse over
|
|
"""
|
|
def __init__(self, toolbar):
|
|
vmmGObject.__init__(self)
|
|
|
|
self._in_fullscreen = False
|
|
self._timeout_id = None
|
|
|
|
self._revealer = Gtk.Revealer()
|
|
self._revealer.add(toolbar)
|
|
|
|
# Adding the revealer to the eventbox seems to ensure the
|
|
# eventbox always has 1 invisible pixel showing at the top of the
|
|
# screen, which we can use to grab the pointer event to show
|
|
# the hidden toolbar.
|
|
|
|
self._ebox = Gtk.EventBox()
|
|
self._ebox.add(self._revealer)
|
|
self._ebox.set_halign(Gtk.Align.CENTER)
|
|
self._ebox.set_valign(Gtk.Align.START)
|
|
self._ebox.show_all()
|
|
|
|
self._ebox.connect("enter-notify-event", self._enter_notify)
|
|
self._ebox.connect("leave-notify-event", self._enter_notify)
|
|
|
|
def _cleanup(self):
|
|
self._ebox.destroy()
|
|
self._ebox = None
|
|
self._revealer.destroy()
|
|
self._revealer = None
|
|
self._timeout_id = None
|
|
|
|
def _enter_notify(self, ignore1, ignore2):
|
|
x, y = self._ebox.get_pointer()
|
|
alloc = self._ebox.get_allocation()
|
|
entered = bool(x >= 0 and y >= 0 and
|
|
x < alloc.width and y < alloc.height)
|
|
|
|
if not self._in_fullscreen:
|
|
return
|
|
|
|
# Pointer exited the toolbar, and toolbar is revealed. Schedule
|
|
# a timeout to close it, if one isn't already scheduled
|
|
if not entered and self._revealer.get_reveal_child():
|
|
self._schedule_unreveal_timeout(1000)
|
|
return
|
|
|
|
self._unregister_timeout()
|
|
if entered and not self._revealer.get_reveal_child():
|
|
self._revealer.set_reveal_child(True)
|
|
|
|
def _schedule_unreveal_timeout(self, timeout):
|
|
if self._timeout_id:
|
|
return # pragma: no cover
|
|
|
|
def cb():
|
|
self._revealer.set_reveal_child(False)
|
|
self._timeout_id = None
|
|
self._timeout_id = self.timeout_add(timeout, cb)
|
|
|
|
def _unregister_timeout(self):
|
|
if self._timeout_id: # pragma: no cover
|
|
self.remove_gobject_timeout(self._timeout_id)
|
|
self._timeout_id = None
|
|
|
|
def force_reveal(self, val):
|
|
self._unregister_timeout()
|
|
self._in_fullscreen = val
|
|
self._revealer.set_reveal_child(val)
|
|
self._schedule_unreveal_timeout(2000)
|
|
|
|
def get_overlay_widget(self):
|
|
return self._ebox
|
|
|
|
|
|
def build_keycombo_menu(on_send_key_fn):
|
|
menu = Gtk.Menu()
|
|
|
|
def make_item(accel, combo):
|
|
name = Gtk.accelerator_get_label(*Gtk.accelerator_parse(accel))
|
|
item = Gtk.MenuItem(name)
|
|
item.connect("activate", on_send_key_fn, combo)
|
|
|
|
menu.add(item)
|
|
|
|
make_item("<Control><Alt>BackSpace", ["Control_L", "Alt_L", "BackSpace"])
|
|
make_item("<Control><Alt>Delete", ["Control_L", "Alt_L", "Delete"])
|
|
menu.add(Gtk.SeparatorMenuItem())
|
|
|
|
for i in range(1, 13):
|
|
make_item("<Control><Alt>F%d" % i, ["Control_L", "Alt_L", "F%d" % i])
|
|
menu.add(Gtk.SeparatorMenuItem())
|
|
|
|
make_item("Print", ["Print"])
|
|
|
|
menu.show_all()
|
|
return menu
|
|
|
|
|
|
class vmmOverlayToolbar:
|
|
def __init__(self, on_leave_fn, on_send_key_fn):
|
|
self._send_key_button = None
|
|
self._keycombo_menu = None
|
|
self._toolbar = None
|
|
|
|
self.timed_revealer = None
|
|
self._init_ui(on_leave_fn, on_send_key_fn)
|
|
|
|
def _init_ui(self, on_leave_fn, on_send_key_fn):
|
|
self._keycombo_menu = build_keycombo_menu(on_send_key_fn)
|
|
|
|
self._toolbar = Gtk.Toolbar()
|
|
self._toolbar.set_show_arrow(False)
|
|
self._toolbar.set_style(Gtk.ToolbarStyle.BOTH_HORIZ)
|
|
self._toolbar.get_accessible().set_name("Fullscreen Toolbar")
|
|
|
|
# Exit button
|
|
button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_LEAVE_FULLSCREEN)
|
|
button.set_tooltip_text(_("Leave fullscreen"))
|
|
button.show()
|
|
button.get_accessible().set_name("Fullscreen Exit")
|
|
self._toolbar.add(button)
|
|
button.connect("clicked", on_leave_fn)
|
|
|
|
self._send_key_button = Gtk.ToolButton()
|
|
self._send_key_button.set_icon_name(
|
|
"preferences-desktop-keyboard-shortcuts")
|
|
self._send_key_button.set_tooltip_text(_("Send key combination"))
|
|
self._send_key_button.show_all()
|
|
self._send_key_button.connect("clicked",
|
|
self._on_send_key_button_clicked_cb)
|
|
self._send_key_button.get_accessible().set_name("Fullscreen Send Key")
|
|
self._toolbar.add(self._send_key_button)
|
|
|
|
self.timed_revealer = _TimedRevealer(self._toolbar)
|
|
|
|
def _on_send_key_button_clicked_cb(self, src):
|
|
event = Gtk.get_current_event()
|
|
win = self._toolbar.get_window()
|
|
rect = Gdk.Rectangle()
|
|
|
|
rect.y = win.get_height()
|
|
self._keycombo_menu.popup_at_rect(win, rect,
|
|
Gdk.Gravity.NORTH_WEST, Gdk.Gravity.NORTH_WEST, event)
|
|
|
|
def cleanup(self):
|
|
self._keycombo_menu.destroy()
|
|
self._keycombo_menu = None
|
|
self._toolbar.destroy()
|
|
self._toolbar = None
|
|
self.timed_revealer.cleanup()
|
|
self.timed_revealer = None
|
|
|
|
|
|
class _ConsoleMenu:
|
|
"""
|
|
Helper class for building the text/graphical console menu list
|
|
"""
|
|
|
|
################
|
|
# Internal API #
|
|
################
|
|
|
|
def _build_serial_menu_items(self, vm):
|
|
devs = vmmSerialConsole.get_serialcon_devices(vm)
|
|
if len(devs) == 0:
|
|
return [[_("No text console available"), None, None]]
|
|
|
|
ret = []
|
|
for dev in devs:
|
|
if dev.DEVICE_TYPE == "console":
|
|
label = _("Text Console %d") % (dev.get_xml_idx() + 1)
|
|
else:
|
|
label = _("Serial %d") % (dev.get_xml_idx() + 1)
|
|
|
|
tooltip = vmmSerialConsole.can_connect(vm, dev)
|
|
ret.append([label, dev, tooltip])
|
|
return ret
|
|
|
|
def _build_graphical_menu_items(self, vm):
|
|
devs = vm.xmlobj.devices.graphics
|
|
if len(devs) == 0:
|
|
return [[_("No graphical console available"), None, None]]
|
|
|
|
from ..device.gfxdetails import vmmGraphicsDetails
|
|
|
|
ret = []
|
|
for idx, dev in enumerate(devs):
|
|
label = (_("Graphical Console") + " " +
|
|
vmmGraphicsDetails.graphics_pretty_type_simple(dev.type))
|
|
|
|
tooltip = None
|
|
if idx > 0:
|
|
label += " %s" % (idx + 1)
|
|
tooltip = _("virt-manager does not support more "
|
|
"than one graphical console")
|
|
|
|
ret.append([label, dev, tooltip])
|
|
return ret
|
|
|
|
|
|
##############
|
|
# Public API #
|
|
##############
|
|
|
|
def rebuild_menu(self, vm, submenu, toggled_cb):
|
|
oldlabel = None
|
|
for child in submenu.get_children():
|
|
if hasattr(child, 'get_active') and child.get_active():
|
|
oldlabel = child.get_label()
|
|
submenu.remove(child)
|
|
|
|
graphics = self._build_graphical_menu_items(vm)
|
|
serials = self._build_serial_menu_items(vm)
|
|
|
|
# Use label == None to tell the loop to add a separator
|
|
items = graphics + [[None, None, None]] + serials
|
|
|
|
last_item = None
|
|
for (label, dev, tooltip) in items:
|
|
if label is None:
|
|
submenu.add(Gtk.SeparatorMenuItem())
|
|
continue
|
|
|
|
cb = toggled_cb
|
|
cbdata = dev
|
|
sensitive = bool(dev and not tooltip)
|
|
|
|
active = False
|
|
if oldlabel is None and sensitive:
|
|
# Select the first selectable option
|
|
oldlabel = label
|
|
if label == oldlabel:
|
|
active = True
|
|
|
|
item = Gtk.RadioMenuItem()
|
|
if last_item is None:
|
|
last_item = item
|
|
else:
|
|
item.join_group(last_item)
|
|
|
|
item.set_label(label)
|
|
item.set_active(active and sensitive)
|
|
if cbdata and sensitive:
|
|
item.connect("toggled", cb, cbdata)
|
|
|
|
item.set_sensitive(sensitive)
|
|
item.set_tooltip_text(tooltip or None)
|
|
submenu.add(item)
|
|
|
|
submenu.show_all()
|
|
|
|
def activate_default(self, menu):
|
|
for child in menu.get_children():
|
|
if child.get_sensitive() and hasattr(child, "toggled"):
|
|
child.toggled()
|
|
return True
|
|
return False
|
|
|
|
|
|
class vmmConsolePages(vmmGObjectUI):
|
|
"""
|
|
Handles all the complex UI handling dictated by the spice/vnc widgets
|
|
"""
|
|
__gsignals__ = {
|
|
"page-changed": (vmmGObjectUI.RUN_FIRST, None, []),
|
|
"leave-fullscreen": (vmmGObjectUI.RUN_FIRST, None, []),
|
|
"change-title": (vmmGObjectUI.RUN_FIRST, None, []),
|
|
}
|
|
|
|
def __init__(self, vm, builder, topwin):
|
|
vmmGObjectUI.__init__(self, "console.ui",
|
|
None, builder=builder, topwin=topwin)
|
|
|
|
self.vm = vm
|
|
self.top_box = self.widget("console-pages")
|
|
self._pointer_is_grabbed = False
|
|
|
|
# State for disabling modifiers when keyboard is grabbed
|
|
self._accel_groups = Gtk.accel_groups_from_object(self.topwin)
|
|
self._gtk_settings_accel = None
|
|
self._gtk_settings_mnemonic = None
|
|
|
|
# Initialize display widget
|
|
self._viewer = None
|
|
self._viewer_connect_clicked = False
|
|
self._in_fullscreen = False
|
|
|
|
# Fullscreen toolbar
|
|
self._keycombo_menu = build_keycombo_menu(self._do_send_key)
|
|
self._console_list_menu = Gtk.Menu()
|
|
self._console_list_menu.connect("show",
|
|
self._populate_console_list_menu)
|
|
|
|
self._overlay_toolbar_fullscreen = vmmOverlayToolbar(
|
|
on_leave_fn=self._leave_fullscreen,
|
|
on_send_key_fn=self._do_send_key)
|
|
self.widget("console-overlay").add_overlay(
|
|
self._overlay_toolbar_fullscreen.timed_revealer.get_overlay_widget())
|
|
|
|
# When the gtk-vnc and spice-gtk widgets are in non-scaling mode, we
|
|
# make them fill the whole window, and they paint the non-VM areas of
|
|
# the viewer black. But when scaling is enabled, the viewer widget is
|
|
# constrained. This change makes sure the non-VM portions in that case
|
|
# are also colored black, rather than the default theme window color.
|
|
self.widget("console-gfx-viewport").modify_bg(
|
|
Gtk.StateType.NORMAL, Gdk.Color(0, 0, 0))
|
|
|
|
self.widget("console-pages").set_show_tabs(False)
|
|
self.widget("serial-pages").set_show_tabs(False)
|
|
self.widget("console-gfx-pages").set_show_tabs(False)
|
|
|
|
self._consolemenu = _ConsoleMenu()
|
|
self._serial_consoles = []
|
|
|
|
# Signals are added by vmmVMWindow. Don't use connect_signals here
|
|
# or it changes will be overwritten
|
|
|
|
self.builder.connect_signals({
|
|
"on_console_pages_switch_page": self._page_changed_cb,
|
|
"on_console_auth_password_activate": self._auth_login_cb,
|
|
"on_console_auth_login_clicked": self._auth_login_cb,
|
|
"on_console_connect_button_clicked": self._connect_button_clicked_cb,
|
|
})
|
|
|
|
self.widget("console-gfx-scroll").connect("size-allocate",
|
|
self._scroll_size_allocate)
|
|
self.widget("console-gfx-pages").connect("switch-page",
|
|
self._page_changed_cb)
|
|
|
|
|
|
def _cleanup(self):
|
|
self.vm = None
|
|
|
|
if self._viewer:
|
|
self._viewer.cleanup() # pragma: no cover
|
|
self._viewer = None
|
|
|
|
self._overlay_toolbar_fullscreen.cleanup()
|
|
|
|
for serial in self._serial_consoles:
|
|
serial.cleanup()
|
|
self._serial_consoles = []
|
|
|
|
|
|
#################
|
|
# Internal APIs #
|
|
#################
|
|
|
|
def _disable_modifiers(self):
|
|
if self._gtk_settings_accel is not None:
|
|
return # pragma: no cover
|
|
|
|
for g in self._accel_groups:
|
|
self.topwin.remove_accel_group(g)
|
|
|
|
settings = Gtk.Settings.get_default()
|
|
self._gtk_settings_accel = settings.get_property('gtk-menu-bar-accel')
|
|
settings.set_property('gtk-menu-bar-accel', None)
|
|
|
|
self._gtk_settings_mnemonic = settings.get_property(
|
|
"gtk-enable-mnemonics")
|
|
settings.set_property("gtk-enable-mnemonics", False)
|
|
|
|
def _enable_modifiers(self):
|
|
if self._gtk_settings_accel is None:
|
|
return
|
|
|
|
settings = Gtk.Settings.get_default()
|
|
settings.set_property('gtk-menu-bar-accel', self._gtk_settings_accel)
|
|
self._gtk_settings_accel = None
|
|
|
|
if self._gtk_settings_mnemonic is not None:
|
|
settings.set_property("gtk-enable-mnemonics",
|
|
self._gtk_settings_mnemonic)
|
|
|
|
for g in self._accel_groups:
|
|
self.topwin.add_accel_group(g)
|
|
|
|
def _do_send_key(self, src, keys):
|
|
ignore = src
|
|
|
|
if keys is not None:
|
|
self._viewer.console_send_keys(keys)
|
|
|
|
|
|
###########################
|
|
# Resize and scaling APIs #
|
|
###########################
|
|
|
|
def _scroll_size_allocate(self, src_ignore, req):
|
|
if not self._viewer:
|
|
return
|
|
|
|
res = self._viewer.console_get_desktop_resolution()
|
|
if res is None:
|
|
if not self.config.CLITestOptions.fake_console_resolution:
|
|
return
|
|
res = (800, 600)
|
|
|
|
scroll = self.widget("console-gfx-scroll")
|
|
is_scale = self._viewer.console_get_scaling()
|
|
is_resizeguest = self._viewer.console_get_resizeguest()
|
|
|
|
dx = 0
|
|
dy = 0
|
|
align_ratio = float(req.width) / float(req.height)
|
|
|
|
# pylint: disable=unpacking-non-sequence
|
|
desktop_w, desktop_h = res
|
|
desktop_ratio = float(desktop_w) / float(desktop_h)
|
|
|
|
if is_scale:
|
|
# Make sure we never show scrollbars when scaling
|
|
scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER)
|
|
else:
|
|
scroll.set_policy(Gtk.PolicyType.AUTOMATIC,
|
|
Gtk.PolicyType.AUTOMATIC)
|
|
|
|
if is_resizeguest:
|
|
# With resize guest, we don't want to maintain aspect ratio,
|
|
# since the guest can resize to arbitrary resolutions.
|
|
viewer_alloc = Gdk.Rectangle()
|
|
viewer_alloc.width = req.width
|
|
viewer_alloc.height = req.height
|
|
self._viewer.console_size_allocate(viewer_alloc)
|
|
return
|
|
|
|
if not is_scale:
|
|
# Scaling disabled is easy, just force the VNC widget size. Since
|
|
# we are inside a scrollwindow, it shouldn't cause issues.
|
|
self._viewer.console_set_size_request(desktop_w, desktop_h)
|
|
return
|
|
|
|
# Make sure there is no hard size requirement so we can scale down
|
|
self._viewer.console_set_size_request(-1, -1)
|
|
|
|
# Make sure desktop aspect ratio is maintained
|
|
if align_ratio > desktop_ratio:
|
|
desktop_w = int(req.height * desktop_ratio)
|
|
desktop_h = req.height
|
|
dx = (req.width - desktop_w) // 2
|
|
|
|
else:
|
|
desktop_w = req.width
|
|
desktop_h = int(req.width // desktop_ratio)
|
|
dy = (req.height - desktop_h) // 2
|
|
|
|
viewer_alloc = Gdk.Rectangle()
|
|
viewer_alloc.x = dx
|
|
viewer_alloc.y = dy
|
|
viewer_alloc.width = desktop_w
|
|
viewer_alloc.height = desktop_h
|
|
self._viewer.console_size_allocate(viewer_alloc)
|
|
|
|
def _viewer_get_resizeguest_tooltip(self):
|
|
tooltip = ""
|
|
if self._viewer:
|
|
tooltip = self._viewer.console_get_resizeguest_warning()
|
|
return tooltip or ""
|
|
|
|
def _sync_resizeguest_with_display(self):
|
|
if not self._viewer:
|
|
return
|
|
|
|
val = bool(self.vm.get_console_resizeguest())
|
|
self._viewer.console_set_resizeguest(val)
|
|
self.widget("console-gfx-scroll").queue_resize()
|
|
|
|
def _set_size_to_vm(self):
|
|
# Resize the console to best fit the VM resolution
|
|
if not self._viewer:
|
|
return # pragma: no cover
|
|
if not self._viewer.console_get_desktop_resolution():
|
|
return # pragma: no cover
|
|
|
|
top_w, top_h = self.topwin.get_size()
|
|
viewer_alloc = self.widget("console-gfx-scroll").get_allocation()
|
|
desktop_w, desktop_h = self._viewer.console_get_desktop_resolution()
|
|
|
|
self.topwin.unmaximize()
|
|
self.topwin.resize(
|
|
desktop_w + (top_w - viewer_alloc.width),
|
|
desktop_h + (top_h - viewer_alloc.height))
|
|
|
|
|
|
################
|
|
# Scaling APIs #
|
|
################
|
|
|
|
def _sync_scaling_with_display(self):
|
|
if not self._viewer:
|
|
return
|
|
|
|
fs = self._in_fullscreen
|
|
curscale = self._viewer.console_get_scaling()
|
|
scale_type = self.vm.get_console_scaling()
|
|
|
|
if (scale_type == self.config.CONSOLE_SCALE_NEVER and
|
|
curscale is True):
|
|
self._viewer.console_set_scaling(False)
|
|
elif (scale_type == self.config.CONSOLE_SCALE_ALWAYS and
|
|
curscale is False):
|
|
self._viewer.console_set_scaling(True)
|
|
elif (scale_type == self.config.CONSOLE_SCALE_FULLSCREEN and
|
|
curscale != fs):
|
|
self._viewer.console_set_scaling(fs)
|
|
|
|
# Refresh viewer size
|
|
self.widget("console-gfx-scroll").queue_resize()
|
|
|
|
|
|
###################
|
|
# Fullscreen APIs #
|
|
###################
|
|
|
|
def _leave_fullscreen(self, ignore=None):
|
|
self.emit("leave-fullscreen")
|
|
|
|
def _change_fullscreen(self, do_fullscreen):
|
|
if do_fullscreen:
|
|
self._in_fullscreen = True
|
|
self.topwin.fullscreen()
|
|
self._overlay_toolbar_fullscreen.timed_revealer.force_reveal(True)
|
|
else:
|
|
self._in_fullscreen = False
|
|
self._overlay_toolbar_fullscreen.timed_revealer.force_reveal(False)
|
|
self.topwin.unfullscreen()
|
|
|
|
self._sync_scaling_with_display()
|
|
|
|
|
|
##########################
|
|
# State tracking methods #
|
|
##########################
|
|
|
|
def _show_vm_status_unavailable(self):
|
|
if self.vm.is_crashed(): # pragma: no cover
|
|
self._activate_vm_unavailable_page(_("Guest has crashed."))
|
|
else:
|
|
self._activate_vm_unavailable_page(_("Guest is not running."))
|
|
|
|
def _close_viewer(self):
|
|
self._leave_fullscreen()
|
|
self._viewer_connect_clicked = False
|
|
|
|
for serial in self._serial_consoles:
|
|
serial.close()
|
|
|
|
if self._viewer is None:
|
|
return
|
|
self._viewer.console_remove_display_from_widget(
|
|
self.widget("console-gfx-viewport"))
|
|
self._viewer.cleanup()
|
|
self._viewer = None
|
|
log.debug("Viewer object cleaned up")
|
|
|
|
def _refresh_vm_state(self):
|
|
self._activate_default_console_page()
|
|
|
|
|
|
###########################
|
|
# console page navigation #
|
|
###########################
|
|
|
|
def _activate_gfx_unavailable_page(self, msg):
|
|
self._close_viewer()
|
|
self.widget("console-gfx-pages").set_current_page(
|
|
_GFX_PAGE_UNAVAILABLE)
|
|
if msg:
|
|
self.widget("console-gfx-unavailable").set_label(
|
|
"<b>" + msg + "</b>")
|
|
|
|
def _activate_vm_unavailable_page(self, msg):
|
|
"""
|
|
This is the top level error page. We should only set it for very
|
|
specific error cases, because when it is set and the VM is running
|
|
we take that to mean we should attempt to connect to the default
|
|
console.
|
|
"""
|
|
self._close_viewer()
|
|
self.widget("console-pages").set_current_page(
|
|
_CONSOLE_PAGE_UNAVAILABLE)
|
|
if msg:
|
|
self.widget("console-unavailable").set_label(
|
|
"<b>" + msg + "</b>")
|
|
self._activate_gfx_unavailable_page(msg)
|
|
|
|
def _activate_auth_page(self, withPassword, withUsername):
|
|
(pw, username) = vmmKeyring.get_instance().get_console_password(self.vm)
|
|
|
|
self.widget("console-auth-password").set_visible(withPassword)
|
|
self.widget("label-auth-password").set_visible(withPassword)
|
|
|
|
self.widget("console-auth-username").set_visible(withUsername)
|
|
self.widget("label-auth-username").set_visible(withUsername)
|
|
|
|
self.widget("console-auth-username").set_text(username)
|
|
self.widget("console-auth-password").set_text(pw)
|
|
|
|
has_keyring = vmmKeyring.get_instance().is_available()
|
|
remember = bool(withPassword and pw) or (withUsername and username)
|
|
remember = has_keyring and remember
|
|
self.widget("console-auth-remember").set_sensitive(has_keyring)
|
|
self.widget("console-auth-remember").set_active(remember)
|
|
|
|
self.widget("console-gfx-pages").set_current_page(_GFX_PAGE_AUTH)
|
|
|
|
if withUsername:
|
|
self.widget("console-auth-username").grab_focus()
|
|
else:
|
|
self.widget("console-auth-password").grab_focus()
|
|
|
|
def _activate_gfx_viewer_page(self):
|
|
self.widget("console-pages").set_current_page(_CONSOLE_PAGE_GRAPHICS)
|
|
self.widget("console-gfx-pages").set_current_page(_GFX_PAGE_VIEWER)
|
|
if self._viewer:
|
|
self._viewer.console_grab_focus()
|
|
|
|
def _activate_gfx_connect_page(self):
|
|
self.widget("console-gfx-pages").set_current_page(_GFX_PAGE_CONNECT)
|
|
|
|
def _viewer_is_visible(self):
|
|
is_visible = self.widget("console-pages").is_visible()
|
|
cpage = self.widget("console-pages").get_current_page()
|
|
gpage = self.widget("console-gfx-pages").get_current_page()
|
|
|
|
return bool(
|
|
is_visible and
|
|
cpage == _CONSOLE_PAGE_GRAPHICS and
|
|
gpage == _GFX_PAGE_VIEWER and
|
|
self._viewer and self._viewer.console_is_open())
|
|
|
|
def _viewer_can_usb_redirect(self):
|
|
return (self._viewer_is_visible() and
|
|
self._viewer.console_has_usb_redirection() and
|
|
self.vm.has_spicevmc_type_redirdev())
|
|
|
|
|
|
#########################
|
|
# Viewer login attempts #
|
|
#########################
|
|
|
|
def _init_viewer(self):
|
|
if self._viewer or not self.is_visible():
|
|
# Don't try and login for these cases
|
|
return
|
|
|
|
ginfo = None
|
|
try:
|
|
gdevs = self.vm.xmlobj.devices.graphics
|
|
gdev = gdevs and gdevs[0] or None
|
|
if gdev:
|
|
ginfo = ConnectionInfo(self.vm.conn, gdev)
|
|
except Exception as e: # pragma: no cover
|
|
# We can fail here if VM is destroyed: xen is a bit racy
|
|
# and can't handle domain lookups that soon after
|
|
log.exception("Getting graphics console failed: %s", str(e))
|
|
return
|
|
|
|
if ginfo is None:
|
|
log.debug("No graphics configured for guest")
|
|
self._activate_gfx_unavailable_page(
|
|
_("Graphical console not configured for guest"))
|
|
return
|
|
|
|
if ginfo.gtype not in self.config.embeddable_graphics():
|
|
log.debug("Don't know how to show graphics type '%s' "
|
|
"disabling console page", ginfo.gtype)
|
|
|
|
msg = (_("Cannot display graphical console type '%s'")
|
|
% ginfo.gtype)
|
|
|
|
self._activate_gfx_unavailable_page(msg)
|
|
return
|
|
|
|
if (not self.vm.get_console_autoconnect() and
|
|
not self._viewer_connect_clicked):
|
|
self._activate_gfx_connect_page()
|
|
return
|
|
|
|
self._activate_gfx_unavailable_page(
|
|
_("Connecting to graphical console for guest"))
|
|
|
|
log.debug("Starting connect process for %s", ginfo.logstring())
|
|
try:
|
|
if ginfo.gtype == "vnc":
|
|
viewer_class = VNCViewer
|
|
elif ginfo.gtype == "spice":
|
|
if not have_spice_gtk: # pragma: no cover
|
|
raise RuntimeError("Error opening Spice console, "
|
|
"SpiceClientGtk missing")
|
|
viewer_class = SpiceViewer
|
|
|
|
self._viewer = viewer_class(self.vm, ginfo)
|
|
self._connect_viewer_signals()
|
|
|
|
self._viewer.console_open()
|
|
except Exception as e:
|
|
log.exception("Error connecting to graphical console")
|
|
self._activate_gfx_unavailable_page(
|
|
_("Error connecting to graphical console:\n%s") % e)
|
|
|
|
def _set_credentials(self, src_ignore=None):
|
|
passwd = self.widget("console-auth-password")
|
|
username = self.widget("console-auth-username")
|
|
|
|
if passwd.get_visible():
|
|
self._viewer.console_set_password(passwd.get_text())
|
|
if username.get_visible():
|
|
self._viewer.console_set_username(username.get_text())
|
|
|
|
if self.widget("console-auth-remember").get_active():
|
|
vmmKeyring.get_instance().set_console_password(
|
|
self.vm, passwd.get_text(), username.get_text())
|
|
else:
|
|
vmmKeyring.get_instance().del_console_password(self.vm)
|
|
|
|
|
|
##########################
|
|
# Viewer signal handling #
|
|
##########################
|
|
|
|
def _viewer_add_display_cb(self, _src, display):
|
|
self.widget("console-gfx-viewport").add(display)
|
|
|
|
# Sync initial settings
|
|
self._sync_scaling_with_display()
|
|
self._sync_resizeguest_with_display()
|
|
|
|
def _pointer_grabbed_cb(self, _src):
|
|
self._pointer_is_grabbed = True
|
|
self.emit("change-title")
|
|
|
|
def _pointer_ungrabbed_cb(self, _src):
|
|
self._pointer_is_grabbed = False
|
|
self.emit("change-title")
|
|
|
|
def _viewer_allocate_cb(self, src, ignore):
|
|
self.widget("console-gfx-scroll").queue_resize()
|
|
|
|
def _viewer_keyboard_grab_cb(self, src):
|
|
self._viewer_sync_modifiers()
|
|
|
|
def _serial_focus_changed_cb(self, src, event):
|
|
self._viewer_sync_modifiers()
|
|
|
|
def _viewer_sync_modifiers(self):
|
|
serial_has_focus = any([s.has_focus() for s in self._serial_consoles])
|
|
viewer_keyboard_grab = (self._viewer and
|
|
self._viewer.console_has_keyboard_grab())
|
|
|
|
if serial_has_focus or viewer_keyboard_grab:
|
|
self._disable_modifiers()
|
|
else:
|
|
self._enable_modifiers()
|
|
|
|
def _viewer_auth_error_cb(self, _src, errmsg, viewer_will_disconnect):
|
|
errmsg = _("Viewer authentication error: %s") % errmsg
|
|
self.err.val_err(errmsg)
|
|
|
|
if viewer_will_disconnect:
|
|
# GtkVNC will disconnect after an auth error, so lets do it for
|
|
# them and re-init the viewer (which will be triggered by
|
|
# _refresh_vm_state if needed)
|
|
self._activate_vm_unavailable_page(errmsg)
|
|
|
|
self._refresh_vm_state()
|
|
|
|
def _viewer_need_auth_cb(self, _src, withPassword, withUsername):
|
|
self._activate_auth_page(withPassword, withUsername)
|
|
|
|
def _viewer_agent_connected_cb(self, _src):
|
|
# Tell the vmwindow to trigger a state refresh, since
|
|
# resizeguest setting depends on the agent value
|
|
if self.widget("console-pages").is_visible(): # pragma: no cover
|
|
self.emit("page-changed")
|
|
|
|
def _viewer_usb_redirect_error_cb(self, _src, errstr):
|
|
self.err.show_err(
|
|
_("USB redirection error"),
|
|
text2=str(errstr), modal=True) # pragma: no cover
|
|
|
|
def _viewer_disconnected_set_page(self, errdetails, ssherr):
|
|
if self.vm.is_runable(): # pragma: no cover
|
|
# Exit was probably for legitimate reasons
|
|
self._show_vm_status_unavailable()
|
|
return
|
|
|
|
msg = _("Viewer was disconnected.")
|
|
errmsg = ""
|
|
if errdetails:
|
|
errmsg += "\n" + errdetails
|
|
if ssherr:
|
|
log.debug("SSH tunnel error output: %s", ssherr)
|
|
errmsg += "\n\n"
|
|
errmsg += _("SSH tunnel error output: %s") % ssherr
|
|
|
|
if errmsg:
|
|
self._activate_gfx_unavailable_page(msg + errmsg)
|
|
return
|
|
|
|
# If no error message was reported, this isn't a clear graphics
|
|
# error that should block reconnecting. So use the top level
|
|
# 'VM unavailable' page which makes it easier for the user to
|
|
# reconnect.
|
|
self._activate_vm_unavailable_page(msg)
|
|
|
|
def _viewer_disconnected_cb(self, _src, errdetails, ssherr):
|
|
self._activate_gfx_unavailable_page(_("Viewer is disconnecting."))
|
|
log.debug("Viewer disconnected cb")
|
|
|
|
# Make sure modifiers are set correctly
|
|
self._viewer_sync_modifiers()
|
|
|
|
self._viewer_disconnected_set_page(errdetails, ssherr)
|
|
|
|
def _viewer_connected_cb(self, _src):
|
|
log.debug("Viewer connected cb")
|
|
self._activate_gfx_viewer_page()
|
|
|
|
# Make sure modifiers are set correctly
|
|
self._viewer_sync_modifiers()
|
|
|
|
def _connect_viewer_signals(self):
|
|
self._viewer.connect("add-display-widget", self._viewer_add_display_cb)
|
|
self._viewer.connect("pointer-grab", self._pointer_grabbed_cb)
|
|
self._viewer.connect("pointer-ungrab", self._pointer_ungrabbed_cb)
|
|
self._viewer.connect("size-allocate", self._viewer_allocate_cb)
|
|
self._viewer.connect("keyboard-grab", self._viewer_keyboard_grab_cb)
|
|
self._viewer.connect("keyboard-ungrab", self._viewer_keyboard_grab_cb)
|
|
self._viewer.connect("connected", self._viewer_connected_cb)
|
|
self._viewer.connect("disconnected", self._viewer_disconnected_cb)
|
|
self._viewer.connect("auth-error", self._viewer_auth_error_cb)
|
|
self._viewer.connect("need-auth", self._viewer_need_auth_cb)
|
|
self._viewer.connect("agent-connected",
|
|
self._viewer_agent_connected_cb)
|
|
self._viewer.connect("usb-redirect-error",
|
|
self._viewer_usb_redirect_error_cb)
|
|
|
|
|
|
##############################
|
|
# Console list menu handling #
|
|
##############################
|
|
|
|
def _console_list_menu_toggled(self, src, dev):
|
|
if not dev or dev.DEVICE_TYPE == "graphics":
|
|
self.widget("console-pages").set_current_page(
|
|
_CONSOLE_PAGE_GRAPHICS)
|
|
self.idle_add(self._init_viewer)
|
|
return
|
|
|
|
target_port = dev.get_xml_idx()
|
|
serial = None
|
|
name = src.get_label()
|
|
for s in self._serial_consoles:
|
|
if s.name == name:
|
|
serial = s
|
|
break
|
|
|
|
if not serial:
|
|
serial = vmmSerialConsole(self.vm, target_port, name)
|
|
serial.set_focus_callbacks(self._serial_focus_changed_cb,
|
|
self._serial_focus_changed_cb)
|
|
|
|
title = Gtk.Label(label=name)
|
|
self.widget("serial-pages").append_page(serial.get_box(), title)
|
|
self._serial_consoles.append(serial)
|
|
|
|
serial.open_console()
|
|
page_idx = self._serial_consoles.index(serial)
|
|
self.widget("console-pages").set_current_page(_CONSOLE_PAGE_SERIAL)
|
|
self.widget("serial-pages").set_current_page(page_idx)
|
|
|
|
def _populate_console_list_menu(self, ignore=None):
|
|
self._consolemenu.rebuild_menu(
|
|
self.vm, self._console_list_menu,
|
|
self._console_list_menu_toggled)
|
|
|
|
def _toggle_first_console_menu_item(self):
|
|
# We iterate through the 'console' menu and activate the first
|
|
# valid entry... hacky but it works
|
|
self._populate_console_list_menu()
|
|
found = self._consolemenu.activate_default(self._console_list_menu)
|
|
if not found:
|
|
# Calling this with dev=None will trigger _init_viewer
|
|
# which shows some meaningful errors
|
|
self._console_list_menu_toggled(None, None)
|
|
|
|
def _activate_default_console_page(self):
|
|
if self.vm.is_runable():
|
|
self._show_vm_status_unavailable()
|
|
return
|
|
|
|
viewer_initialized = (self._viewer and self._viewer.console_is_open())
|
|
if viewer_initialized:
|
|
return
|
|
|
|
cpage = self.widget("console-pages").get_current_page()
|
|
if cpage != _CONSOLE_PAGE_UNAVAILABLE:
|
|
return
|
|
|
|
# If we are in this condition it should mean the VM was
|
|
# just started, so connect to the default page
|
|
self._toggle_first_console_menu_item()
|
|
|
|
|
|
################
|
|
# UI listeners #
|
|
################
|
|
|
|
def _auth_login_cb(self, src):
|
|
self._set_credentials()
|
|
|
|
def _connect_button_clicked_cb(self, src):
|
|
self._viewer_connect_clicked = True
|
|
self._init_viewer()
|
|
|
|
def _page_changed_cb(self, src, origpage, newpage):
|
|
# Hide the contents of all other pages, so they don't screw
|
|
# up window sizing
|
|
for i in range(src.get_n_pages()):
|
|
src.get_nth_page(i).set_visible(i == newpage)
|
|
|
|
# Dispatch the next bit in idle_add, so the UI size can change
|
|
self.idle_emit("page-changed")
|
|
|
|
|
|
###########################
|
|
# API used by vmmVMWindow #
|
|
###########################
|
|
|
|
def vmwindow_viewer_has_usb_redirection(self):
|
|
return bool(self._viewer and
|
|
self._viewer.console_has_usb_redirection())
|
|
def vmwindow_viewer_get_usb_widget(self):
|
|
return self._viewer.console_get_usb_widget()
|
|
def vmwindow_viewer_get_pixbuf(self):
|
|
return self._viewer.console_get_pixbuf()
|
|
|
|
def vmwindow_close(self):
|
|
return self._activate_vm_unavailable_page(
|
|
_("Viewer window closed."))
|
|
def vmwindow_get_title_message(self):
|
|
if self._pointer_is_grabbed and self._viewer:
|
|
keystr = self._viewer.console_get_grab_keys()
|
|
return _("Press %s to release pointer.") % keystr
|
|
|
|
def vmwindow_activate_default_console_page(self):
|
|
return self._activate_default_console_page()
|
|
def vmwindow_refresh_vm_state(self):
|
|
return self._refresh_vm_state()
|
|
|
|
def vmwindow_set_size_to_vm(self):
|
|
return self._set_size_to_vm()
|
|
def vmwindow_set_fullscreen(self, do_fullscreen):
|
|
self._change_fullscreen(do_fullscreen)
|
|
|
|
def vmwindow_get_keycombo_menu(self):
|
|
return self._keycombo_menu
|
|
def vmwindow_get_console_list_menu(self):
|
|
return self._console_list_menu
|
|
def vmwindow_get_viewer_is_visible(self):
|
|
return self._viewer_is_visible()
|
|
def vmwindow_get_can_usb_redirect(self):
|
|
return self._viewer_can_usb_redirect()
|
|
def vmwindow_get_resizeguest_tooltip(self):
|
|
return self._viewer_get_resizeguest_tooltip()
|
|
|
|
def vmwindow_sync_scaling_with_display(self):
|
|
return self._sync_scaling_with_display()
|
|
def vmwindow_sync_resizeguest_with_display(self):
|
|
return self._sync_resizeguest_with_display()
|