#!/usr/bin/python3 # # The Qubes OS Project, http://www.qubes-os.org # # Copyright (C) 2012 Agnieszka Kostrzewa # Copyright (C) 2012 Marek Marczykowski-Górecki # # Copyright (C) 2017 Wojtek Porczyk # # 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 Lesser General Public License along # with this program; if not, see . # # # TODO: cleanup imports import sys import os import os.path import signal import subprocess import time from datetime import datetime, timedelta import traceback from qubesadmin import Qubes from qubesadmin import exc from PyQt4 import QtGui from PyQt4 import QtCore from PyQt4 import Qt from PyQt4.QtDBus import QDBusVariant, QDBusMessage from PyQt4.QtDBus import QDBusConnection from PyQt4.QtDBus import QDBusInterface, QDBusAbstractAdaptor from pyinotify import WatchManager, ThreadedNotifier, EventsCodes, \ ProcessEvent from . import ui_vtmanager from . import thread_monitor from . import table_widgets import threading # from qubes.qubes import QubesVmCollection # from qubes.qubes import QubesException # from qubes.qubes import system_path # from qubes.qubes import QubesDaemonPidfile # from qubes.qubes import QubesHost from qubesmanager.about import AboutDialog # import table_widgets # from block import QubesBlockDevicesManager # from table_widgets import VmTypeWidget, VmLabelWidget, VmNameItem, \ # VmInfoWidget, VmTemplateItem, VmNetvmItem, VmUsageBarWidget, ChartWidget, \ # VmSizeOnDiskItem, VmInternalItem, VmIPItem, VmIncludeInBackupsItem, \ # VmLastBackupItem # from qubes.qubes import QubesHVm # from qubes import qubesutils # from ui_mainwindow import * # from create_new_vm import NewVmDlg # from settings import VMSettingsWindow # from restore import RestoreVMsWindow # from backup import BackupVMsWindow # from global_settings import GlobalSettingsWindow # from networknotes import NetworkNotesDialog # from log_dialog import LogDialog # TODO: probably unneeded update_suggestion_interval = 14 # 14 days # TODO: probably unneeded dbus_object_path = '/org/qubesos/QubesManager' dbus_interface = 'org.qubesos.QubesManager' system_bus = None session_bus = None # TODO: probably unneeded class QMVmState: ErrorMsg = 1 AudioRecAvailable = 2 AudioRecAllowed = 3 #TODO: this is actually needed O_O class SearchBox(QtGui.QLineEdit): def __init__(self, parent=None): super(SearchBox, self).__init__(parent) self.focusing = False def focusInEvent(self, e): super(SearchBox, self).focusInEvent(e) self.selectAll() self.focusing = True def mousePressEvent(self, e): super(SearchBox, self).mousePressEvent(e) if self.focusing: self.selectAll() self.focusing = False class VmRowInTable(object): cpu_graph_hue = 210 mem_graph_hue = 120 def __init__(self, vm, row_no, table): self.vm = vm self.row_no = row_no table_widgets.row_height = VmManagerWindow.row_height table.setRowHeight(row_no, VmManagerWindow.row_height) self.type_widget = table_widgets.VmTypeWidget(vm) table.setCellWidget(row_no, VmManagerWindow.columns_indices['Type'], self.type_widget) table.setItem(row_no, VmManagerWindow.columns_indices['Type'], self.type_widget.tableItem) self.label_widget = table_widgets.VmLabelWidget(vm) table.setCellWidget(row_no, VmManagerWindow.columns_indices['Label'], self.label_widget) table.setItem(row_no, VmManagerWindow.columns_indices['Label'], self.label_widget.tableItem) self.name_widget = table_widgets.VmNameItem(vm) table.setItem(row_no, VmManagerWindow.columns_indices['Name'], self.name_widget) self.info_widget = table_widgets.VmInfoWidget(vm) table.setCellWidget(row_no, VmManagerWindow.columns_indices['State'], self.info_widget) table.setItem(row_no, VmManagerWindow.columns_indices['State'], self.info_widget.tableItem) self.template_widget = table_widgets.VmTemplateItem(vm) table.setItem(row_no, VmManagerWindow.columns_indices['Template'], self.template_widget) self.netvm_widget = table_widgets.VmNetvmItem(vm) table.setItem(row_no, VmManagerWindow.columns_indices['NetVM'], self.netvm_widget) # self.cpu_usage_widget = table_widgets.VmUsageBarWidget( # 0, 100, "%v %", # # lambda v, val: val if v.last_running else 0, # lambda v, val: val, # vm, 0, self.cpu_graph_hue) # table.setCellWidget(row_no, VmManagerWindow.columns_indices['CPU'], # self.cpu_usage_widget) # table.setItem(row_no, VmManagerWindow.columns_indices['CPU'], # self.cpu_usage_widget.tableItem) # self.load_widget = table_widgets.ChartWidget( # vm, # lambda v, val: val if v.last_running else 0, # self.cpu_graph_hue, 0) # table.setCellWidget(row_no, # VmManagerWindow.columns_indices['CPU Graph'], # self.load_widget) # table.setItem(row_no, VmManagerWindow.columns_indices['CPU Graph'], # self.load_widget.tableItem) # self.mem_usage_widget = table_widgets.VmUsageBarWidget( # 0, qubes_host.memory_total / 1024, "%v MB", # lambda v, val: v.get_mem() / 1024, # vm, 0, self.mem_graph_hue) # table.setCellWidget(row_no, VmManagerWindow.columns_indices['MEM'], # self.mem_usage_widget) # table.setItem(row_no, VmManagerWindow.columns_indices['MEM'], # self.mem_usage_widget.tableItem) # # # self.mem_widget = table_widgets.ChartWidget( # # vm, lambda v, val: v.get_mem() * 100 / qubes_host.memory_total, # # self.mem_graph_hue, 0) # table.setCellWidget(row_no, # VmManagerWindow.columns_indices['MEM Graph'], # self.mem_widget) # table.setItem(row_no, VmManagerWindow.columns_indices['MEM Graph'], # self.mem_widget.tableItem) self.size_widget = table_widgets.VmSizeOnDiskItem(vm) table.setItem(row_no, VmManagerWindow.columns_indices['Size'], self.size_widget) self.internal_widget = table_widgets.VmInternalItem(vm) table.setItem(row_no, VmManagerWindow.columns_indices['Internal'], self.internal_widget) self.ip_widget = table_widgets.VmIPItem(vm) table.setItem(row_no, VmManagerWindow.columns_indices['IP'], self.ip_widget) self.include_in_backups_widget = table_widgets.VmIncludeInBackupsItem(vm) table.setItem(row_no, VmManagerWindow.columns_indices[ 'Backups'], self.include_in_backups_widget) self.last_backup_widget = table_widgets.VmLastBackupItem(vm) table.setItem(row_no, VmManagerWindow.columns_indices[ 'Last backup'], self.last_backup_widget) def update(self, blk_visible=None, cpu_load=None, update_size_on_disk=False, rec_visible=None): """ Update info in a single VM row :param blk_visible: if not None, show/hide block icon, otherwise don't change its visibility :param cpu_load: current CPU load (if applicable), in percents :param update_size_on_disk: should disk utilization be updated? the widget will extract the data from VM object :param rec_visible: if not None, show/hide mic icon, otherwise don't change its visibility :return: None """ self.info_widget.update_vm_state(self.vm, blk_visible, rec_visible) if cpu_load is not None: self.cpu_usage_widget.update_load(self.vm, cpu_load) self.mem_usage_widget.update_load(self.vm, None) self.load_widget.update_load(self.vm, cpu_load) self.mem_widget.update_load(self.vm, None) if update_size_on_disk: self.size_widget.update() vm_shutdown_timeout = 20000 # in msec vm_restart_check_timeout= 1000 # in msec class VmShutdownMonitor(QtCore.QObject): def __init__(self, vm, shutdown_time=vm_shutdown_timeout, check_time=vm_restart_check_timeout, and_restart=False, caller=None): QtCore.QObject.__init__(self) self.vm = vm self.shutdown_time = shutdown_time self.check_time = check_time self.and_restart = and_restart self.shutdown_started = datetime.now() self.caller = caller def restart_vm_if_needed(self): if self.and_restart and self.caller: self.caller.start_vm(self.vm) def check_again_later(self): # noinspection PyTypeChecker,PyCallByClass QtCore.QTimer.singleShot(self.check_time, self.check_if_vm_has_shutdown) def timeout_reached(self): actual = datetime.now() - self.shutdown_started allowed = timedelta(milliseconds=self.shutdown_time) return actual > allowed def check_if_vm_has_shutdown(self): vm = self.vm vm_is_running = vm.is_running() vm_start_time = vm.get_start_time() if vm_is_running and vm_start_time and vm_start_time < self.shutdown_started: if self.timeout_reached(): reply = QtGui.QMessageBox.question( None, self.tr("VM Shutdown"), self.tr("The VM '{0}' hasn't shutdown within the last " "{1} seconds, do you want to kill it?
").format( vm.name, self.shutdown_time / 1000), self.tr("Kill it!"), self.tr("Wait another {0} seconds...").format( self.shutdown_time / 1000)) if reply == 0: vm.force_shutdown() self.restart_vm_if_needed() else: self.shutdown_started = datetime.now() self.check_again_later() else: self.check_again_later() else: if vm_is_running: # Due to unknown reasons, Xen sometimes reports that a domain # is running even though its start-up timestamp is not valid. # Make sure that "restart_vm_if_needed" is not called until # the domain has been completely shut down according to Xen. self.check_again_later() return self.restart_vm_if_needed() class VmManagerWindow(ui_vtmanager.Ui_VmManagerWindow, QtGui.QMainWindow): row_height = 30 column_width = 200 min_visible_rows = 10 show_inactive_vms = True show_internal_vms = False search = "" # suppress saving settings while initializing widgets settings_loaded = False # TODO: does this work columns_indices = {"Type": 0, "Label": 1, "Name": 2, "State": 3, "Template": 4, "NetVM": 5, # "CPU": 6, # delete # "CPU Graph": 7, # delete # "MEM": 8, # delete # "MEM Graph": 9, # delete "Size": 6, "Internal": 7, "IP": 8, "Backups": 9, "Last backup": 10, } def __init__(self, qvm_collection, parent=None): super(VmManagerWindow, self).__init__() self.setupUi(self) self.toolbar = self.toolBar self.manager_settings = QtCore.QSettings() #TODO use Qt settings mechanism # self.qubes_watch = qubesutils.QubesWatch() self.qvm_collection = qvm_collection # self.qubes_watch.setup_domain_watch(self.domain_state_changed_callback) # self.qubes_watch.setup_block_watch(self.blk_manager.block_devs_event) # self.blk_watch_thread = threading.Thread( # target=self.qubes_watch.watch_loop) # self.blk_watch_thread.daemon = True # self.blk_watch_thread.start() self.searchbox = SearchBox() #TODO check if this works self.searchbox.setValidator(QtGui.QRegExpValidator( QtCore.QRegExp("[a-zA-Z0-9-]*", QtCore.Qt.CaseInsensitive), None)) self.searchContainer.addWidget(self.searchbox) self.connect(self.table, QtCore.SIGNAL("itemSelectionChanged()"), self.table_selection_changed) self.table.setColumnWidth(0, self.column_width) self.sort_by_column = "Type" self.sort_order = QtCore.Qt.AscendingOrder self.screen_number = -1 self.screen_changed = False self.vms_list = [] self.vms_in_table = {} self.reload_table = False self.running_vms_count = 0 self.internal_vms_count = 0 self.vm_errors = {} self.vm_rec = {} self.frame_width = 0 self.frame_height = 0 self.move(self.x(), 0) self.columns_actions = { self.columns_indices["Type"]: self.action_vm_type, self.columns_indices["Label"]: self.action_label, self.columns_indices["Name"]: self.action_name, self.columns_indices["State"]: self.action_state, self.columns_indices["Template"]: self.action_template, self.columns_indices["NetVM"]: self.action_netvm, # self.columns_indices["CPU"]: self.action_cpu, # self.columns_indices["CPU Graph"]: self.action_cpu_graph, # self.columns_indices["MEM"]: self.action_mem, # self.columns_indices["MEM Graph"]: self.action_mem_graph, self.columns_indices["Size"]: self.action_size_on_disk, self.columns_indices["Internal"]: self.action_internal, self.columns_indices["IP"]: self .action_ip, self.columns_indices["Backups"]: self .action_backups, self.columns_indices["Last backup"]: self .action_last_backup } # TODO: make refresh button self.visible_columns_count = len(self.columns_indices) # self.table.setColumnHidden(self.columns_indices["CPU"], True) # self.action_cpu.setChecked(False) # self.table.setColumnHidden(self.columns_indices["CPU Graph"], True) # self.action_cpu_graph.setChecked(False) # self.table.setColumnHidden(self.columns_indices["MEM Graph"], True) # self.action_mem_graph.setChecked(False) self.table.setColumnHidden(self.columns_indices["Size"], True) self.action_size_on_disk.setChecked(False) self.table.setColumnHidden(self.columns_indices["Internal"], True) self.action_internal.setChecked(False) self.table.setColumnHidden(self.columns_indices["IP"], True) self.action_ip.setChecked(False) self.table.setColumnHidden(self.columns_indices["Backups"], True) self.action_backups.setChecked(False) self.table.setColumnHidden(self.columns_indices["Last backup"], True) self.action_last_backup.setChecked(False) self.table.setColumnWidth(self.columns_indices["State"], 80) self.table.setColumnWidth(self.columns_indices["Name"], 150) self.table.setColumnWidth(self.columns_indices["Label"], 40) self.table.setColumnWidth(self.columns_indices["Type"], 40) self.table.setColumnWidth(self.columns_indices["Size"], 100) self.table.setColumnWidth(self.columns_indices["Internal"], 60) self.table.setColumnWidth(self.columns_indices["IP"], 100) self.table.setColumnWidth(self.columns_indices["Backups"], 60) self.table.setColumnWidth(self.columns_indices["Last backup"], 90) self.table.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed) self.table.sortItems(self.columns_indices[self.sort_by_column], self.sort_order) self.context_menu = QtGui.QMenu(self) self.context_menu.addAction(self.action_settings) self.context_menu.addAction(self.action_editfwrules) self.context_menu.addAction(self.action_appmenus) self.context_menu.addAction(self.action_set_keyboard_layout) self.context_menu.addMenu(self.blk_menu) self.context_menu.addAction(self.action_toggle_audio_input) self.context_menu.addSeparator() self.context_menu.addAction(self.action_updatevm) self.context_menu.addAction(self.action_run_command_in_vm) self.context_menu.addAction(self.action_resumevm) self.context_menu.addAction(self.action_startvm_tools_install) self.context_menu.addAction(self.action_pausevm) self.context_menu.addAction(self.action_shutdownvm) self.context_menu.addAction(self.action_restartvm) self.context_menu.addAction(self.action_killvm) self.context_menu.addSeparator() self.context_menu.addAction(self.action_clonevm) self.context_menu.addAction(self.action_removevm) self.context_menu.addSeparator() self.context_menu.addMenu(self.logs_menu) self.context_menu.addSeparator() self.tools_context_menu = QtGui.QMenu(self) self.tools_context_menu.addAction(self.action_toolbar) self.tools_context_menu.addAction(self.action_menubar) self.table_selection_changed() self.connect( self.table.horizontalHeader(), QtCore.SIGNAL("sortIndicatorChanged(int, Qt::SortOrder)"), self.sortIndicatorChanged) self.connect(self.table, QtCore.SIGNAL("customContextMenuRequested(const QPoint&)"), self.open_context_menu) self.connect(self.menubar, QtCore.SIGNAL("customContextMenuRequested(const QPoint&)"), lambda pos: self.open_tools_context_menu(self.menubar, pos)) self.connect(self.toolBar, QtCore.SIGNAL("customContextMenuRequested(const QPoint&)"), lambda pos: self.open_tools_context_menu(self.toolBar, pos)) self.connect(self.blk_menu, QtCore.SIGNAL("triggered(QAction *)"), self.attach_dettach_device_triggered) self.connect(self.logs_menu, QtCore.SIGNAL("triggered(QAction *)"), self.show_log) self.connect(self.searchbox, QtCore.SIGNAL("textChanged(const QString&)"), self.do_search) self.table.setContentsMargins(0, 0, 0, 0) self.centralwidget.layout().setContentsMargins(0, 0, 0, 0) self.layout().setContentsMargins(0, 0, 0, 0) self.connect(self.action_menubar, QtCore.SIGNAL("toggled(bool)"), self.showhide_menubar) self.connect(self.action_toolbar, QtCore.SIGNAL("toggled(bool)"), self.showhide_toolbar) self.register_dbus_watches() self.load_manager_settings() self.action_showallvms.setChecked(self.show_inactive_vms) self.action_showinternalvms.setChecked(self.show_internal_vms) self.fill_table() self.counter = 0 self.update_size_on_disk = False self.shutdown_monitor = {} self.last_measure_results = {} self.last_measure_time = time.time() # noinspection PyCallByClass,PyTypeChecker # QtCore.QTimer.singleShot(self.update_interval, self.update_table) QubesDbusNotifyServerAdaptor(self) def load_manager_settings(self): #TODO: replace with a Qt-based settings gizmo also make it work # visible columns # self.manager_settings.beginGroup("columns") # for col in self.columns_indices.keys(): # col_no = self.columns_indices[col] # visible = self.manager_settings.value( # col, # defaultValue=not self.table.isColumnHidden(col_no)) # self.columns_actions[col_no].setChecked(visible) # self.manager_settings.endGroup() # self.show_inactive_vms = self.manager_settings.value( # "view/show_inactive_vms", defaultValue=False) # self.show_internal_vms = self.manager_settings.value( # "view/show_internal_vms", defaultValue=False) # self.sort_by_column = str( # self.manager_settings.value("view/sort_column", # defaultValue=self.sort_by_column)) # # self.sort_order = QtCore.Qt.SortOrder( #TODO does not seem to work # # self.manager_settings.value("view/sort_order", # # defaultValue=self.sort_order)[ # # 0]) # self.table.sortItems(self.columns_indices[self.sort_by_column], # self.sort_order) # if not self.manager_settings.value("view/menubar_visible", # defaultValue=True): # self.action_menubar.setChecked(False) # if not self.manager_settings.value("view/toolbar_visible", # defaultValue=True): # self.action_toolbar.setChecked(False) # x = self.manager_settings.value('position/x', defaultValue=-1)[ # 0] # y = self.manager_settings.value('position/y', defaultValue=-1)[ # 0] # if x != -1 or y != -1: # self.move(x, y) self.settings_loaded = True def show(self): super(VmManagerWindow, self).show() self.screen_number = app.desktop().screenNumber(self) # def set_table_geom_size(self): # # desktop_width = app.desktop().availableGeometry( # self).width() - self.frame_width # might be wrong... # desktop_height = app.desktop().availableGeometry( # self).height() - self.frame_height # might be wrong... # desktop_height -= self.row_height # UGLY! to somehow ommit taskbar... # # w = self.table.horizontalHeader().length() + \ # self.table.verticalScrollBar().width() + \ # 2 * self.table.frameWidth() + 1 # # h = self.table.horizontalHeader().height() + \ # 2 * self.table.frameWidth() # # mainwindow_to_add = 0 # # available_space = desktop_height # if self.menubar.isVisible(): # menubar_height = (self.menubar.sizeHint().height() + # self.menubar.contentsMargins().top() + # self.menubar.contentsMargins().bottom()) # available_space -= menubar_height # mainwindow_to_add += menubar_height # if self.toolbar.isVisible(): # toolbar_height = (self.toolbar.sizeHint().height() + # self.toolbar.contentsMargins().top() + # self.toolbar.contentsMargins().bottom()) # available_space -= toolbar_height # mainwindow_to_add += toolbar_height # if w >= desktop_width: # available_space -= self.table.horizontalScrollBar().height() # h += self.table.horizontalScrollBar().height() # # # account for search box height # available_space -= self.searchbox.height() # h += self.searchbox.height() # # default_rows = int(available_space / self.row_height) # # n = sum(not self.table.isRowHidden(row) for row in # range(self.table.rowCount())) # # if n > default_rows: # h += default_rows * self.row_height # self.table.verticalScrollBar().show() # else: # h += n * self.row_height # self.table.verticalScrollBar().hide() # w -= self.table.verticalScrollBar().width() # # w = min(desktop_width, w) # # self.centralwidget.setFixedHeight(h) # # h += mainwindow_to_add # # self.setMaximumHeight(h) # self.setMinimumHeight(h) # # self.table.setFixedWidth(w) # self.centralwidget.setFixedWidth(w) # # don't change the following two lines to setFixedWidth! # self.setMaximumWidth(w) # self.setMinimumWidth(w) def moveEvent(self, event): super(VmManagerWindow, self).moveEvent(event) screen_number = app.desktop().screenNumber(self) if self.screen_number != screen_number: self.screen_changed = True self.screen_number = screen_number if self.settings_loaded: self.manager_settings.setValue('position/x', self.x()) self.manager_settings.setValue('position/y', self.y()) # do not sync for performance reasons def domain_state_changed_callback(self, name=None, uuid=None): if name is not None: vm = self.qvm_collection.domains[name] if vm: vm.refresh() def get_vms_list(self): # self.qvm_collection.lock_db_for_reading() # self.qvm_collection.load() # self.qvm_collection.unlock_db() running_count = 0 internal_count = 0 vms_list = [vm for vm in self.qvm_collection.domains] for vm in vms_list: # vm.last_power_state = vm.get_power_state() # vm.last_running = vm.is_running() # if vm.last_running: # running_count += 1 # if vm.internal: # internal_count += 1 # vm.qubes_manager_state = {} # self.update_audio_rec_info(vm) # vm.qubes_manager_state[QMVmState.ErrorMsg] = self.vm_errors[ # vm.qid] if vm.qid in self.vm_errors else None running_count +=1 self.running_vms_count = running_count self.internal_vms_count = internal_count return vms_list def fill_table(self): # save current selection row_index = self.table.currentRow() selected_qid = -1 if row_index != -1: vm_item = self.table.item(row_index, self.columns_indices["Name"]) if vm_item: selected_qid = vm_item.qid self.table.setSortingEnabled(False) self.table.clearContents() vms_list = self.get_vms_list() self.table.setRowCount(len(vms_list)) vms_in_table = {} row_no = 0 for vm in vms_list: # if vm.internal: # continue vm_row = VmRowInTable(vm, row_no, self.table) vms_in_table[vm.qid] = vm_row row_no += 1 self.table.setRowCount(row_no) self.vms_list = vms_list self.vms_in_table = vms_in_table self.reload_table = False if selected_qid in vms_in_table.keys(): self.table.setCurrentItem( self.vms_in_table[selected_qid].name_widget) self.table.setSortingEnabled(True) self.showhide_vms() # self.set_table_geom_size() def showhide_vms(self): if self.show_inactive_vms and self.show_internal_vms and not self.search: for row_no in range(self.table.rowCount()): self.table.setRowHidden(row_no, False) else: for row_no in range(self.table.rowCount()): widget = self.table.cellWidget(row_no, self.columns_indices["State"]) running = False internal = False # running = widget.vm.last_running # internal = widget.vm.internal name = widget.vm.name show = (running or self.show_inactive_vms) and \ (not internal or self.show_internal_vms) and \ (self.search in widget.vm.name or not self.search) self.table.setRowHidden(row_no, not show) @QtCore.pyqtSlot(str) def do_search(self, search): self.search = str(search) self.showhide_vms() # self.set_table_geom_size() @QtCore.pyqtSlot(name='on_action_search_triggered') def action_search_triggered(self): self.searchbox.setFocus() def mark_table_for_update(self): self.reload_table = True # When calling update_table() directly, always use out_of_schedule=True! def update_table(self, out_of_schedule=False): update_devs = self.update_block_devices() or out_of_schedule reload_table = self.reload_table if manager_window.isVisible(): # some_vms_have_changed_power_state = False # for vm in self.vms_list: # state = vm.get_power_state() # if vm.last_power_state != state: # if state == "Running" and \ # self.vm_errors.get(vm.qid, "") \ # .startswith("Error starting VM:"): # self.clear_error(vm.qid) # prev_running = vm.last_running # vm.last_power_state = state # vm.last_running = vm.is_running() # self.update_audio_rec_info(vm) # if not prev_running and vm.last_running: # self.running_vms_count += 1 # some_vms_have_changed_power_state = True # # Clear error state when VM just started # self.clear_error(vm.qid) # elif prev_running and not vm.last_running: # # FIXME: remove when recAllowed state will be preserved # if self.vm_rec.has_key(vm.name): # self.vm_rec.pop(vm.name) # self.running_vms_count -= 1 # some_vms_have_changed_power_state = True # else: # # pulseaudio agent register itself some time after VM # # startup # if state == "Running" and not vm.qubes_manager_state[ # QMVmState.AudioRecAvailable]: # self.update_audio_rec_info(vm) # if self.vm_errors.get(vm.qid, "") == \ # "Error starting VM: Cannot execute qrexec-daemon!" \ # and vm.is_qrexec_running(): # self.clear_error(vm.qid) pass if self.screen_changed: reload_table = True self.screen_changed = False if reload_table: self.fill_table() update_devs = True # if not self.show_inactive_vms and \ # some_vms_have_changed_power_state: # self.showhide_vms() # self.set_table_geom_size() # if self.sort_by_column == \ # "State" and some_vms_have_changed_power_state: # self.table.sortItems(self.columns_indices[self.sort_by_column], # self.sort_order) blk_visible = None rows_with_blk = None # if update_devs: # rows_with_blk = [] # self.blk_manager.blk_lock.acquire() # for d in self.blk_manager.attached_devs: # rows_with_blk.append( # self.blk_manager.attached_devs[d]['attached_to'][ # 'vm'].qid) # self.blk_manager.blk_lock.release() if (not self.table.isColumnHidden(self.columns_indices['Size'])) and \ self.counter % 60 == 0 or out_of_schedule: self.update_size_on_disk = True if self.counter % 3 == 0 or out_of_schedule: # (self.last_measure_time, self.last_measure_results) = \ # qubes_host.measure_cpu_usage(self.qvm_collection, # self.last_measure_results, # self.last_measure_time) for vm_row in self.vms_in_table.values(): cur_cpu_load = None # if vm_row.vm.get_xid() in self.last_measure_results: # cur_cpu_load = self.last_measure_results[vm_row.vm.xid][ # 'cpu_usage'] # else: # cur_cpu_load = 0 if rows_with_blk is not None: if vm_row.vm.qid in rows_with_blk: blk_visible = True else: blk_visible = False vm_row.update(blk_visible=blk_visible, cpu_load=cur_cpu_load, update_size_on_disk=self.update_size_on_disk, rec_visible=self.vm_rec.get(vm_row.vm.name, False)) else: for vm_row in self.vms_in_table.values(): if rows_with_blk is not None: if vm_row.vm.qid in rows_with_blk: blk_visible = True else: blk_visible = False vm_row.update(blk_visible=blk_visible, update_size_on_disk=self.update_size_on_disk, rec_visible=self.vm_rec.get(vm_row.vm.name, False)) if self.sort_by_column in ["CPU", "CPU Graph", "MEM", "MEM Graph", "State", "Size", "Internal"]: # "State": needed to sort after reload (fill_table sorts items # with setSortingEnabled, but by that time the widgets values # are not correct yet). self.table.sortItems(self.columns_indices[self.sort_by_column], self.sort_order) self.table_selection_changed() self.update_size_on_disk = False if not out_of_schedule: self.counter += 1 # noinspection PyCallByClass,PyTypeChecker # QtCore.QTimer.singleShot(self.update_interval, self.update_table) def update_block_devices(self): pass # res, msg = self.blk_manager.check_for_updates() # if msg is not None and len(msg) > 0: # trayIcon.showMessage('\n'.join(msg), msecs=5000) # return res # noinspection PyPep8Naming @QtCore.pyqtSlot(bool, str) def recAllowedChanged(self, state, vmname): self.vm_rec[str(vmname)] = bool(state) def register_dbus_watches(self): global session_bus if not session_bus: session_bus = QDBusConnection.sessionBus() if not session_bus.connect("", # service "", # path "org.QubesOS.Audio", # interface "RecAllowedChanged", # name self.recAllowedChanged): # slot print(session_bus.lastError().message()) # noinspection PyPep8Naming def sortIndicatorChanged(self, column, order): self.sort_by_column = [name for name in self.columns_indices.keys() if self.columns_indices[name] == column][0] self.sort_order = order if self.settings_loaded: self.manager_settings.setValue('view/sort_column', self.sort_by_column) self.manager_settings.setValue('view/sort_order', self.sort_order) self.manager_settings.sync() def table_selection_changed(self): vm = self.get_selected_vm() if vm is not None: # Update available actions: self.action_settings.setEnabled(vm.qid != 0) self.action_removevm.setEnabled( not vm.installed_by_rpm and not vm.last_running) self.action_clonevm.setEnabled( not vm.last_running and not vm.is_netvm()) # self.action_resumevm.setEnabled(not vm.last_running or # vm.last_power_state == "Paused") try: pass # self.action_startvm_tools_install.setVisible( # isinstance(vm, QubesHVm)) except NameError: # ignore non existing QubesHVm pass self.action_startvm_tools_install.setEnabled(not vm.last_running) # self.action_pausevm.setEnabled( # vm.last_running and # vm.last_power_state != "Paused" and # vm.qid != 0) # self.action_shutdownvm.setEnabled( # vm.last_running and # vm.last_power_state != "Paused" and # vm.qid != 0) # self.action_restartvm.setEnabled( # vm.last_running and # vm.last_power_state != "Paused" and # vm.qid != 0 and # not vm.is_disposablevm()) # self.action_killvm.setEnabled((vm.last_running or # vm.last_power_state == "Paused") and # vm.qid != 0) # self.action_appmenus.setEnabled(vm.qid != 0 and # not vm.internal and # not vm.is_disposablevm()) # self.action_editfwrules.setEnabled(vm.is_networked() and not ( # vm.is_netvm() and not vm.is_proxyvm())) # self.action_updatevm.setEnabled(vm.is_updateable() or vm.qid == 0) # self.action_toggle_audio_input.setEnabled( # vm.qubes_manager_state[QMVmState.AudioRecAvailable]) # self.action_run_command_in_vm.setEnabled( # not vm.last_power_state == "Paused" and vm.qid != 0) # self.action_set_keyboard_layout.setEnabled( # vm.qid != 0 and # vm.last_running and # vm.last_power_state != "Paused") else: self.action_settings.setEnabled(False) self.action_removevm.setEnabled(False) self.action_startvm_tools_install.setVisible(False) self.action_startvm_tools_install.setEnabled(False) self.action_clonevm.setEnabled(False) self.action_resumevm.setEnabled(False) self.action_pausevm.setEnabled(False) self.action_shutdownvm.setEnabled(False) self.action_restartvm.setEnabled(False) self.action_killvm.setEnabled(False) self.action_appmenus.setEnabled(False) self.action_editfwrules.setEnabled(False) self.action_updatevm.setEnabled(False) self.action_toggle_audio_input.setEnabled(False) self.action_run_command_in_vm.setEnabled(False) self.action_set_keyboard_layout.setEnabled(False) def closeEvent(self, event): # There is something borked in Qt, # as the logic here is inverted on X11 if event.spontaneous(): self.hide() event.ignore() def set_error(self, qid, message): for vm in self.vms_list: if vm.qid == qid: vm.qubes_manager_state[QMVmState.ErrorMsg] = message # Store error in separate dict to make it immune to VM list reload self.vm_errors[qid] = str(message) def clear_error(self, qid): self.vm_errors.pop(qid, None) for vm in self.vms_list: if vm.qid == qid: vm.qubes_manager_state[QMVmState.ErrorMsg] = None def clear_error_exact(self, qid, message): for vm in self.vms_list: if vm.qid == qid: if vm.qubes_manager_state[QMVmState.ErrorMsg] == message: vm.qubes_manager_state[QMVmState.ErrorMsg] = None self.vm_errors.pop(qid, None) @QtCore.pyqtSlot(name='on_action_createvm_triggered') def action_createvm_triggered(self): pass # dialog = NewVmDlg(app, self.qvm_collection, trayIcon) # dialog.exec_() def get_selected_vm(self): # vm selection relies on the VmInfo widget's value used # for sorting by VM name row_index = self.table.currentRow() if row_index != -1: vm_item = self.table.item(row_index, self.columns_indices["Name"]) # here is possible race with update_table timer so check # if really got the item if vm_item is None: return None qid = vm_item.qid assert self.vms_in_table[qid] is not None vm = self.vms_in_table[qid].vm return vm else: return None @QtCore.pyqtSlot(name='on_action_removevm_triggered') def action_removevm_triggered(self): vm = self.get_selected_vm() assert not vm.is_running() assert not vm.installed_by_rpm vm = self.qvm_collection[vm.qid] if vm.is_template(): dependent_vms = self.qvm_collection.domains[vm.qid] if len(dependent_vms) > 0: QtGui.QMessageBox.warning( None, self.tr("Warning!"), self.tr("This Template VM cannot be removed, because there is at " "least one AppVM that is based on it.
" "If you want to remove this Template VM and all " "the AppVMs based on it," "you should first remove each individual AppVM that uses " "this template.")) return (requested_name, ok) = QtGui.QInputDialog.getText( None, self.tr("VM Removal Confirmation"), self.tr("Are you sure you want to remove the VM '{0}'?
" "All data on this VM's private storage will be lost!

" "Type the name of the VM ({1}) below to confirm:") .format(vm.name, vm.name)) if not ok: # user clicked cancel return elif requested_name != vm.name: # name did not match QtGui.QMessageBox.warning(None, self.tr("VM removal confirmation failed"), self.tr("Entered name did not match! Not removing {0}.").format(vm.name)) return else: # remove the VM t_monitor = thread_monitor.ThreadMonitor() thread = threading.Thread(target=self.do_remove_vm, args=(vm, t_monitor)) thread.daemon = True thread.start() progress = QtGui.QProgressDialog( self.tr("Removing VM: {0}...").format(vm.name), "", 0, 0) progress.setCancelButton(None) progress.setModal(True) progress.show() while not thread_monitor.is_finished(): app.processEvents() time.sleep(0.1) progress.hide() if thread_monitor.success: trayIcon.showMessage( self.tr("VM '{0}' has been removed.").format(vm.name), msecs=3000) else: QtGui.QMessageBox.warning(None, self.tr("Error removing VM!"), self.tr("ERROR: {0}").format( thread_monitor.error_msg)) @staticmethod def do_remove_vm(vm, thread_monitor): qc = Qubes() try: vm = qc.domains[vm.qid] # TODO: the following two conditions should really be checked # by qvm_collection.pop() overload... if vm.is_template() and \ qc.default_template_qid == vm.qid: qc.default_template_qid = None if vm.is_netvm() and \ qc.default_netvm_qid == vm.qid: qc.default_netvm_qid = None # qc.pop(vm.qid) # qc.save() vm.remove_from_disk() except Exception as ex: thread_monitor.set_error_msg(str(ex)) thread_monitor.set_finished() @QtCore.pyqtSlot(name='on_action_clonevm_triggered') def action_clonevm_triggered(self): vm = self.get_selected_vm() name_number = 1 name_format = vm.name + '-clone-%d' while self.qvm_collection.domains[name_format % name_number]: name_number += 1 (clone_name, ok) = QtGui.QInputDialog.getText( self, self.tr('Qubes clone VM'), self.tr('Enter name for VM {} clone:').format(vm.name), text=(name_format % name_number)) if not ok or clone_name == "": return t_monitor = thread_monitor.ThreadMonitor() thread = threading.Thread(target=self.do_clone_vm, args=(vm, str(clone_name), t_monitor)) thread.daemon = True thread.start() progress = QtGui.QProgressDialog( self.tr("Cloning VM {0} to {1}...").format(vm.name, clone_name), "", 0, 0) progress.setCancelButton(None) progress.setModal(True) progress.show() while not t_monitor.is_finished(): app.processEvents() time.sleep(0.2) progress.hide() if not t_monitor.success: QtGui.QMessageBox.warning(None, self.tr("Error while cloning VM"), self.tr("Exception while cloning:
{0}").format( t_monitor.error_msg)) @staticmethod def do_clone_vm(vm, dst_name, thread_monitor): dst_vm = None qc = Qubes() try: src_vm = qc[vm.qid] dst_vm = qc.add_new_vm(src_vm.__class__.__name__, name=dst_name, template=src_vm.template, installed_by_rpm=False) dst_vm.clone_attrs(src_vm) dst_vm.clone_disk_files(src_vm=src_vm, verbose=False) qc.save() except Exception as ex: if dst_vm: qc.pop(dst_vm.qid) dst_vm.remove_from_disk() thread_monitor.set_error_msg(str(ex)) thread_monitor.set_finished() @QtCore.pyqtSlot(name='on_action_resumevm_triggered') def action_resumevm_triggered(self): vm = self.get_selected_vm() # if vm.get_power_state() in ["Paused", "Suspended"]: # try: # vm.resume() # except Exception as ex: # QtGui.QMessageBox.warning(None, self.tr("Error unpausing VM!"), # self.tr("ERROR: {0}").format(ex)) # return self.start_vm(vm) def start_vm(self, vm): assert not vm.is_running() t_monitor = thread_monitor.ThreadMonitor() thread = threading.Thread(target=self.do_start_vm, args=(vm, t_monitor)) thread.daemon = True thread.start() trayIcon.showMessage(self.tr("Starting '{0}'...").format(vm.name), msecs=3000) while not t_monitor.is_finished(): app.processEvents() time.sleep(0.1) if t_monitor.success: trayIcon.showMessage(self.tr("VM '{0}' has been started.").format(vm.name), msecs=3000) else: trayIcon.showMessage( self.tr("Error starting VM '{0}': {1}").format( vm.name, t_monitor.error_msg), msecs=3000) self.set_error(vm.qid, self.tr("Error starting VM: %s") % t_monitor.error_msg) @staticmethod def do_start_vm(vm, t_monitor): try: vm.start() except Exception as ex: t_monitor.set_error_msg(str(ex)) t_monitor.set_finished() return t_monitor.set_finished() @QtCore.pyqtSlot(name='on_action_startvm_tools_install_triggered') def action_startvm_tools_install_triggered(self): vm = self.get_selected_vm() assert not vm.is_running() windows_tools_installed = \ os.path.exists('/usr/lib/qubes/qubes-windows-tools.iso') if not windows_tools_installed: msg = QtGui.QMessageBox() msg.warning(self, self.tr("Error starting VM!"), self.tr("You need to install 'qubes-windows-tools' " "package to use this option")) return t_monitor = thread_monitor.ThreadMonitor() thread = threading.Thread(target=self.do_start_vm_tools_install, args=(vm, t_monitor)) thread.daemon = True thread.start() trayIcon.showMessage(self.tr("Starting '{0}'...").format(vm.name), msecs=3000) while not t_monitor.is_finished(): app.processEvents() time.sleep(0.1) if t_monitor.success: trayIcon.showMessage(self.tr("VM '{0}' has been started. Start Qubes " "Tools installation from attached CD") .format(vm.name), msecs=3000) else: trayIcon.showMessage( self.tr("Error starting VM '{0}': {1}") .format(vm.name, t_monitor.error_msg), msecs=3000) self.set_error(vm.qid, self.tr("Error starting VM: %s") % t_monitor.error_msg) # noinspection PyMethodMayBeStatic def do_start_vm_tools_install(self, vm, thread_monitor): prev_drive = vm.drive try: vm.drive = 'cdrom:dom0:/usr/lib/qubes/qubes-windows-tools.iso' vm.start() except Exception as ex: thread_monitor.set_error_msg(str(ex)) thread_monitor.set_finished() return finally: vm.drive = prev_drive thread_monitor.set_finished() @QtCore.pyqtSlot(name='on_action_pausevm_triggered') def action_pausevm_triggered(self): vm = self.get_selected_vm() assert vm.is_running() try: vm.pause() except Exception as ex: QtGui.QMessageBox.warning(None, self.tr("Error pausing VM!"), self.tr("ERROR: {0}").format(ex)) return @QtCore.pyqtSlot(name='on_action_shutdownvm_triggered') def action_shutdownvm_triggered(self): vm = self.get_selected_vm() assert vm.is_running() # self.blk_manager.check_if_serves_as_backend(vm) reply = QtGui.QMessageBox.question( None, self.tr("VM Shutdown Confirmation"), self.tr("Are you sure you want to power down the VM '{0}'?
" "This will shutdown all the running applications " "within this VM.").format(vm.name), QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel) app.processEvents() if reply == QtGui.QMessageBox.Yes: self.shutdown_vm(vm) def shutdown_vm(self, vm, shutdown_time=vm_shutdown_timeout, check_time=vm_restart_check_timeout, and_restart=False): try: vm.shutdown() except Exception as ex: QtGui.QMessageBox.warning(None, self.tr("Error shutting down VM!"), self.tr("ERROR: {0}").format(ex)) return trayIcon.showMessage(self.tr("VM '{0}' is shutting down...").format(vm.name), msecs=3000) self.shutdown_monitor[vm.qid] = VmShutdownMonitor(vm, shutdown_time, check_time, and_restart, self) # noinspection PyCallByClass,PyTypeChecker QtCore.QTimer.singleShot(check_time, self.shutdown_monitor[ vm.qid].check_if_vm_has_shutdown) @QtCore.pyqtSlot(name='on_action_restartvm_triggered') def action_restartvm_triggered(self): vm = self.get_selected_vm() assert vm.is_running() # self.blk_manager.check_if_serves_as_backend(vm) reply = QtGui.QMessageBox.question( None, self.tr("VM Restart Confirmation"), self.tr("Are you sure you want to restart the VM '{0}'?
" "This will shutdown all the running applications " "within this VM.").format(vm.name), QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel) app.processEvents() if reply == QtGui.QMessageBox.Yes: self.shutdown_vm(vm, and_restart=True) @QtCore.pyqtSlot(name='on_action_killvm_triggered') def action_killvm_triggered(self): vm = self.get_selected_vm() assert vm.is_running() or vm.is_paused() reply = QtGui.QMessageBox.question( None, self.tr("VM Kill Confirmation"), self.tr("Are you sure you want to kill the VM '{0}'?
" "This will end (not shutdown!) all the running " "applications within this VM.").format(vm.name), QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel, QtGui.QMessageBox.Cancel) app.processEvents() if reply == QtGui.QMessageBox.Yes: try: vm.force_shutdown() except Exception as ex: QtGui.QMessageBox.critical( None, self.tr("Error while killing VM!"), self.tr("An exception ocurred while killing {0}.
" "ERROR: {1}").format(vm.name, ex)) return trayIcon.showMessage(self.tr("VM '{0}' killed!") .format(vm.name), msecs=3000) @QtCore.pyqtSlot(name='on_action_settings_triggered') def action_settings_triggered(self): pass #TODO this should work, actually, but please not now # vm = self.get_selected_vm() # settings_window = VMSettingsWindow(vm, app, self.qvm_collection, # "basic") # settings_window.exec_() @QtCore.pyqtSlot(name='on_action_appmenus_triggered') def action_appmenus_triggered(self): pass #TODO this should work, actually, but please not now # vm = self.get_selected_vm() # settings_window = VMSettingsWindow(vm, app, self.qvm_collection, # "applications") # settings_window.exec_() def update_audio_rec_info(self, vm): vm.qubes_manager_state[QMVmState.AudioRecAvailable] = ( session_bus.interface().isServiceRegistered( 'org.QubesOS.Audio.%s' % vm.name).value()) if vm.qubes_manager_state[QMVmState.AudioRecAvailable]: vm.qubes_manager_state[ QMVmState.AudioRecAllowed] = self.get_audio_rec_allowed(vm.name) else: vm.qubes_manager_state[QMVmState.AudioRecAllowed] = False # noinspection PyMethodMayBeStatic def get_audio_rec_allowed(self, vmname): properties = QDBusInterface('org.QubesOS.Audio.%s' % vmname, '/org/qubesos/audio', 'org.freedesktop.DBus.Properties', session_bus) current_audio = properties.call('Get', 'org.QubesOS.Audio', 'RecAllowed') if current_audio.type() == current_audio.ReplyMessage: value = current_audio.arguments()[0].toPyObject() return bool(value) return False @QtCore.pyqtSlot(name='on_action_toggle_audio_input_triggered') def action_toggle_audio_input_triggered(self): vm = self.get_selected_vm() properties = QDBusInterface('org.QubesOS.Audio.%s' % vm.name, '/org/qubesos/audio', 'org.freedesktop.DBus.Properties', session_bus) properties.call('Set', 'org.QubesOS.Audio', 'RecAllowed', QDBusVariant(not self.get_audio_rec_allowed(vm.name))) # icon will be updated based on dbus signal @QtCore.pyqtSlot(name='on_action_updatevm_triggered') def action_updatevm_triggered(self): vm = self.get_selected_vm() if not vm.is_running(): reply = QtGui.QMessageBox.question( None, self.tr("VM Update Confirmation"), self.tr("{0}
The VM has to be running to be updated.
" "Do you want to start it?
").format(vm.name), QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel) if reply != QtGui.QMessageBox.Yes: return trayIcon.showMessage(self.tr("Starting '{0}'...").format(vm.name), msecs=3000) app.processEvents() t_monitor = thread_monitor.ThreadMonitor() thread = threading.Thread(target=self.do_update_vm, args=(vm, t_monitor)) thread.daemon = True thread.start() progress = QtGui.QProgressDialog( self.tr("{0}
Please wait for the updater to " "launch...").format(vm.name), "", 0, 0) progress.setCancelButton(None) progress.setModal(True) progress.show() while not t_monitor.is_finished(): app.processEvents() time.sleep(0.2) progress.hide() if vm.qid != 0: if not t_monitor.success: QtGui.QMessageBox.warning(None, self.tr("Error VM update!"), self.tr("ERROR: {0}").format( t_monitor.error_msg)) @staticmethod def do_update_vm(vm, thread_monitor): try: if vm.qid == 0: subprocess.check_call( ["/usr/bin/qubes-dom0-update", "--clean", "--gui"]) else: if not vm.is_running(): trayIcon.showMessage( "Starting the '{0}' VM...".format(vm.name), msecs=3000) vm.start() vm.run_service("qubes.InstallUpdatesGUI", gui=True, user="root", wait=False) except Exception as ex: thread_monitor.set_error_msg(str(ex)) thread_monitor.set_finished() return thread_monitor.set_finished() @QtCore.pyqtSlot(name='on_action_run_command_in_vm_triggered') def action_run_command_in_vm_triggered(self): vm = self.get_selected_vm() (command_to_run, ok) = QtGui.QInputDialog.getText( self, self.tr('Qubes command entry'), self.tr('Run command in {}:').format(vm.name)) if not ok or command_to_run == "": return t_monitor = thread_monitor.ThreadMonitor() thread = threading.Thread(target=self.do_run_command_in_vm, args=( vm, command_to_run, t_monitor)) thread.daemon = True thread.start() while not t_monitor.is_finished(): app.processEvents() time.sleep(0.2) if not t_monitor.success: QtGui.QMessageBox.warning(None, self.tr("Error while running command"), self.tr("Exception while running command:
{0}").format( t_monitor.error_msg)) @staticmethod def do_run_command_in_vm(vm, command_to_run, thread_monitor): try: vm.run(command_to_run, verbose=False, autostart=True, notify_function=lambda lvl, msg: trayIcon.showMessage( msg, msecs=3000)) except Exception as ex: thread_monitor.set_error_msg(str(ex)) thread_monitor.set_finished() @QtCore.pyqtSlot(name='on_action_set_keyboard_layout_triggered') def action_set_keyboard_layout_triggered(self): vm = self.get_selected_vm() vm.run('qubes-change-keyboard-layout', verbose=False) @QtCore.pyqtSlot(name='on_action_showallvms_triggered') def action_showallvms_triggered(self): self.show_inactive_vms = self.action_showallvms.isChecked() self.showhide_vms() # self.set_table_geom_size() if self.settings_loaded: self.manager_settings.setValue('view/show_inactive_vms', self.show_inactive_vms) self.manager_settings.sync() @QtCore.pyqtSlot(name='on_action_showinternalvms_triggered') def action_showinternalvms_triggered(self): self.show_internal_vms = self.action_showinternalvms.isChecked() self.showhide_vms() # self.set_table_geom_size() if self.settings_loaded: self.manager_settings.setValue('view/show_internal_vms', self.show_internal_vms) self.manager_settings.sync() @QtCore.pyqtSlot(name='on_action_editfwrules_triggered') def action_editfwrules_triggered(self): pass #TODO: revive # vm = self.get_selected_vm() # settings_window = VMSettingsWindow(vm, app, self.qvm_collection, # "firewall") # settings_window.exec_() @QtCore.pyqtSlot(name='on_action_global_settings_triggered') def action_global_settings_triggered(self): pass #TODO: revive # global_settings_window = GlobalSettingsWindow(app, self.qvm_collection) # global_settings_window.exec_() @QtCore.pyqtSlot(name='on_action_show_network_triggered') def action_show_network_triggered(self): pass #TODO: revive # network_notes_dialog = NetworkNotesDialog() # network_notes_dialog.exec_() @QtCore.pyqtSlot(name='on_action_restore_triggered') def action_restore_triggered(self): pass #TODO: revive # restore_window = RestoreVMsWindow(app, self.qvm_collection, # self.blk_manager) # restore_window.exec_() @QtCore.pyqtSlot(name='on_action_backup_triggered') def action_backup_triggered(self): pass #TODO: revive # backup_window = BackupVMsWindow(app, self.qvm_collection, # self.blk_manager, self.shutdown_vm) # backup_window.exec_() def showhide_menubar(self, checked): self.menubar.setVisible(checked) # self.set_table_geom_size() if not checked: self.context_menu.addAction(self.action_menubar) else: self.context_menu.removeAction(self.action_menubar) if self.settings_loaded: self.manager_settings.setValue('view/menubar_visible', checked) self.manager_settings.sync() def showhide_toolbar(self, checked): self.toolbar.setVisible(checked) # self.set_table_geom_size() if not checked: self.context_menu.addAction(self.action_toolbar) else: self.context_menu.removeAction(self.action_toolbar) if self.settings_loaded: self.manager_settings.setValue('view/toolbar_visible', checked) self.manager_settings.sync() def showhide_column(self, col_num, show): self.table.setColumnHidden(col_num, not show) # self.set_table_geom_size() val = 1 if show else -1 self.visible_columns_count += val if self.visible_columns_count == 1: # disable hiding the last one for c in self.columns_actions: if self.columns_actions[c].isChecked(): self.columns_actions[c].setEnabled(False) break elif self.visible_columns_count == 2 and val == 1: # enable hiding previously disabled column for c in self.columns_actions: if not self.columns_actions[c].isEnabled(): self.columns_actions[c].setEnabled(True) break if self.settings_loaded: col_name = [name for name in self.columns_indices.keys() if self.columns_indices[name] == col_num][0] self.manager_settings.setValue('columns/%s' % col_name, show) self.manager_settings.sync() def on_action_vm_type_toggled(self, checked): self.showhide_column(self.columns_indices['Type'], checked) def on_action_label_toggled(self, checked): self.showhide_column(self.columns_indices['Label'], checked) def on_action_name_toggled(self, checked): self.showhide_column(self.columns_indices['Name'], checked) def on_action_state_toggled(self, checked): self.showhide_column(self.columns_indices['State'], checked) def on_action_internal_toggled(self, checked): self.showhide_column(self.columns_indices['Internal'], checked) def on_action_ip_toggled(self, checked): self.showhide_column(self.columns_indices['IP'], checked) def on_action_backups_toggled(self, checked): self.showhide_column(self.columns_indices['Backups'], checked) def on_action_last_backup_toggled(self, checked): self.showhide_column(self.columns_indices['Last backup'], checked) def on_action_template_toggled(self, checked): self.showhide_column(self.columns_indices['Template'], checked) def on_action_netvm_toggled(self, checked): self.showhide_column(self.columns_indices['NetVM'], checked) def on_action_cpu_toggled(self, checked): self.showhide_column(self.columns_indices['CPU'], checked) def on_action_cpu_graph_toggled(self, checked): self.showhide_column(self.columns_indices['CPU Graph'], checked) def on_action_mem_toggled(self, checked): self.showhide_column(self.columns_indices['MEM'], checked) def on_action_mem_graph_toggled(self, checked): self.showhide_column(self.columns_indices['MEM Graph'], checked) def on_action_size_on_disk_toggled(self, checked): self.showhide_column(self.columns_indices['Size'], checked) @QtCore.pyqtSlot(name='on_action_about_qubes_triggered') def action_about_qubes_triggered(self): about = AboutDialog() about.exec_() def createPopupMenu(self): menu = QtGui.QMenu() menu.addAction(self.action_toolbar) menu.addAction(self.action_menubar) return menu def open_tools_context_menu(self, widget, point): self.tools_context_menu.exec_(widget.mapToGlobal(point)) @QtCore.pyqtSlot('const QPoint&') def open_context_menu(self, point): vm = self.get_selected_vm() running = vm.is_running() # logs menu self.logs_menu.clear() if vm.qid == 0: logfiles = ["/var/log/xen/console/hypervisor.log"] else: logfiles = [ "/var/log/xen/console/guest-" + vm.name + ".log", "/var/log/xen/console/guest-" + vm.name + "-dm.log", "/var/log/qubes/guid." + vm.name + ".log", "/var/log/qubes/qrexec." + vm.name + ".log", ] menu_empty = True for logfile in logfiles: if os.path.exists(logfile): action = self.logs_menu.addAction(QtGui.QIcon(":/log.png"), logfile) action.setData(QtCore.QVariant(logfile)) menu_empty = False self.logs_menu.setEnabled(not menu_empty) # blk menu if not running: self.blk_menu.setEnabled(False) else: self.blk_menu.clear() self.blk_menu.setEnabled(True) # self.blk_manager.blk_lock.acquire() # if len(self.blk_manager.attached_devs) > 0: # for d in self.blk_manager.attached_devs: # if (self.blk_manager.attached_devs[d] # ['attached_to']['vm'].qid == vm.qid): # text = self.tr("Detach {dev} {size} {desc}").format( # dev=d, # size= # self.blk_manager.attached_devs[d]['size'], # desc=self.blk_manager.attached_devs[d]['desc']) # action = self.blk_menu.addAction(QtGui.QIcon(":/remove.png"), # text) # action.setData(QtCore.QVariant(d)) # # if len(self.blk_manager.free_devs) > 0: # for d in self.blk_manager.free_devs: # if d.startswith(vm.name): # continue # # skip partitions heuristic # if d[-1].isdigit() and \ # d[0:-1] in self.blk_manager.current_blk: # continue # text = self.tr("Attach {dev} {size} {desc}").format( # dev=d, # size= # self.blk_manager.free_devs[d]['size'], # desc=self.blk_manager.free_devs[d]['desc']) # action = self.blk_menu.addAction(QtGui.QIcon(":/add.png"), text) # action.setData(QtCore.QVariant(d)) # # self.blk_manager.blk_lock.release() if self.blk_menu.isEmpty(): self.blk_menu.setEnabled(False) self.context_menu.exec_(self.table.mapToGlobal(point)) @QtCore.pyqtSlot('QAction *') def show_log(self, action): pass #TODO fixme # log = str(action.data()) # log_dialog = LogDialog(app, log) # log_dialog.exec_() @QtCore.pyqtSlot('QAction *') def attach_dettach_device_triggered(self, action): pass # dev = str(action.data()) # vm = self.get_selected_vm() # # self.blk_manager.blk_lock.acquire() # try: # if dev in self.blk_manager.attached_devs: # self.blk_manager.detach_device(vm, dev) # else: # self.blk_manager.attach_device(vm, dev) # self.blk_manager.blk_lock.release() # except exc.QubesException as e: # self.blk_manager.blk_lock.release() # QtGui.QMessageBox.critical(None, # self.tr("Block attach/detach error!"), str(e)) class QubesTrayIcon(QtGui.QSystemTrayIcon): def __init__(self, icon): QtGui.QSystemTrayIcon.__init__(self, icon) self.menu = QtGui.QMenu() action_showmanager = self.create_action( self.tr("Open VM Manager"), slot=show_manager, icon="qubes") # action_copy = self.create_action( # self.tr("Copy Dom0 clipboard"), icon="copy", # slot=do_dom0_copy) action_backup = self.create_action(self.tr("Make backup")) action_preferences = self.create_action(self.tr("Preferences")) action_set_netvm = self.create_action(self.tr("Set default NetVM"), icon="networking") action_sys_info = self.create_action(self.tr("System Info"), icon="dom0") action_exit = self.create_action(self.tr("Exit"), slot=exit_app) action_backup.setDisabled(True) action_preferences.setDisabled(True) action_set_netvm.setDisabled(True) action_sys_info.setDisabled(True) # self.blk_manager = blk_manager self.blk_menu = QtGui.QMenu(self.menu) self.blk_menu.setTitle(self.tr("Block devices")) action_blk_menu = self.create_action(self.tr("Block devices")) action_blk_menu.setMenu(self.blk_menu) self.add_actions(self.menu, (action_showmanager, # action_copy, action_blk_menu, action_backup, action_sys_info, None, action_preferences, action_set_netvm, None, action_exit)) self.setContextMenu(self.menu) # self.connect(self, # QtCore.SIGNAL("activated (QtGui.QSystemTrayIcon::ActivationReason)"), # self.icon_clicked) self.tray_notifier_type = None self.tray_notifier = QDBusInterface("org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications", session_bus) srv_info = self.tray_notifier.call("GetServerInformation") if srv_info.type() == QDBusMessage.ReplyMessage and \ len(srv_info.arguments()) > 1: self.tray_notifier_type = srv_info.arguments()[1] if os.path.exists(table_widgets.qubes_dom0_updates_stat_file): self.showMessage(self.tr("Qubes dom0 updates available."), msecs=0) def update_blk_menu(self): global manager_window def create_vm_submenu(dev): blk_vm_menu = QtGui.QMenu(self.blk_menu) blk_vm_menu.triggered.connect( lambda a, trig_dev=dev: self.attach_device_triggered(a, trig_dev)) for this_vm in sorted(manager_window.qvm_collection.domains, key=lambda x: x.name): if not this_vm.is_running(): continue if this_vm.qid == 0: # skip dom0 to prevent (fatal) mistakes continue this_action = blk_vm_menu.addAction(QtGui.QIcon(":/add.png"), this_vm.name) this_action.setData(QtCore.QVariant(this_vm)) return blk_vm_menu self.blk_menu.clear() self.blk_menu.setEnabled(True) # self.blk_manager.blk_lock.acquire() # if len(self.blk_manager.attached_devs) > 0: # for d in self.blk_manager.attached_devs: # vm = self.blk_manager.attached_devs[d]['attached_to']['vm'] # text = self.tr("Detach {dev} {desc} ({size}) from {vm}").format( # dev=d, # desc=self.blk_manager.attached_devs[d]['desc'], # size=self.blk_manager.attached_devs[d]['size'], # vm=vm.name) # action = self.blk_menu.addAction(QtGui.QIcon(":/remove.png"), text) # action.setData(QtCore.QVariant(d)) # action.triggered.connect( # lambda b, a=action: self.dettach_device_triggered(a)) # # if len(self.blk_manager.free_devs) > 0: # for d in self.blk_manager.free_devs: # # skip partitions heuristic # if d[-1].isdigit() and d[0:-1] in self.blk_manager.current_blk: # continue # text = self.tr("Attach {dev} {size} {desc}").format( # dev=d, # size=self.blk_manager.free_devs[d]['size'], # desc=self.blk_manager.free_devs[d]['desc'] # ) # action = self.blk_menu.addAction(QtGui.QIcon(":/add.png"), text) # action.setMenu(create_vm_submenu(d)) # # self.blk_manager.blk_lock.release() if self.blk_menu.isEmpty(): self.blk_menu.setEnabled(False) @QtCore.pyqtSlot('QAction *') def attach_device_triggered(self, action, dev): pass # vm = action.data().toPyObject() # # self.blk_manager.blk_lock.acquire() # try: # self.blk_manager.attach_device(vm, dev) # self.blk_manager.blk_lock.release() # except exc.QubesException as e: # self.blk_manager.blk_lock.release() # QtGui.QMessageBox.critical(None, # self.tr("Block attach/detach error!"), str(e)) @QtCore.pyqtSlot('QAction *') def dettach_device_triggered(self, action): pass # dev = str(action.data()) # vm = self.blk_manager.attached_devs[dev]['attached_to']['vm'] # # self.blk_manager.blk_lock.acquire() # try: # self.blk_manager.detach_device(vm, dev) # self.blk_manager.blk_lock.release() # except exc.QubesException as e: # self.blk_manager.blk_lock.release() # QtGui.QMessageBox.critical(None, # self.tr("Block attach/detach error!"), str(e)) def icon_clicked(self, reason): if reason == QtGui.QSystemTrayIcon.Context: self.update_blk_menu() # Handle the right click normally, i.e. display the context menu return else: bring_manager_to_front() # noinspection PyMethodMayBeStatic def add_actions(self, target, actions): for action in actions: if action is None: target.addSeparator() else: target.addAction(action) def showMessage(self, message, msecs, **kwargs): # QtDBus bindings doesn't use introspection to get proper method # parameters types, so must cast explicitly # v_replace_id = QtCore.QVariant(0) # v_replace_id.convert(QtCore.QVariant.UInt) # v_actions = QtCore.QVariant([]) # v_actions.convert(QtCore.QVariant.StringList) # if self.tray_notifier_type == "KDE": # message = message.replace('\n', '
\n') # self.tray_notifier.call("Notify", "Qubes", v_replace_id, # "qubes-manager", "Qubes VM Manager", # message, v_actions, QtCore.QVariant.fromMap({}), msecs) pass def create_action(self, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False, signal="triggered()"): action = QtGui.QAction(text, self) if icon is not None: action.setIcon(QtGui.QIcon(":/%s.png" % icon)) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if slot is not None: self.connect(action, QtCore.SIGNAL(signal), slot) if checkable: action.setCheckable(True) return action class QubesDbusNotifyServerAdaptor(QDBusAbstractAdaptor): """ This provides the DBus adaptor to the outside world""" # Q_CLASSINFO("D-Bus Interface", dbus_interface) @QtCore.pyqtSlot(str, str) def notify_error(self, vmname, message): vm = self.parent().qvm_collection.domains[vmname] if vm: self.parent().set_error(vm.qid, message) else: # ignore VM-not-found error pass @QtCore.pyqtSlot(str, str) def clear_error_exact(self, vmname, message): vm = self.parent().qvm_collection.domains[vmname] if vm: self.parent().clear_error_exact(vm.qid, message) else: # ignore VM-not-found error pass @QtCore.pyqtSlot(str) def clear_error(self, vmname): vm = self.parent().qvm_collection.domains[vmname] if vm: self.parent().clear_error(vm.qid) else: # ignore VM-not-found error pass @QtCore.pyqtSlot() def show_manager(self): bring_manager_to_front() # def get_frame_size(): # w = 0 # h = 0 # cmd = ['/usr/bin/xprop', '-name', 'Qubes VM Manager', '|', 'grep', # '_NET_FRAME_EXTENTS'] # xprop = subprocess.Popen(cmd, stdout=subprocess.PIPE) # for l in xprop.stdout: # line = l.split('=') # if len(line) == 2: # line = line[1].strip().split(',') # if len(line) == 4: # w = int(line[0].strip()) + int(line[1].strip()) # h = int(line[2].strip()) + int(line[3].strip()) # break # # in case of some weird window managers we have to assume sth... # if w <= 0: # w = 10 # if h <= 0: # h = 30 # # manager_window.frame_width = w # manager_window.frame_height = h # return def show_manager(): manager_window.show() # manager_window.set_table_geom_size() manager_window.repaint() manager_window.update_table(out_of_schedule=True) app.processEvents() # get_frame_size() # print manager_window.frame_width, " x ", manager_window.frame_height # manager_window.set_table_geom_size() def bring_manager_to_front(): if manager_window.isVisible(): subprocess.check_call( ['/usr/bin/wmctrl', '-R', str(manager_window.windowTitle())]) else: show_manager() def show_running_manager_via_dbus(): global system_bus if system_bus is None: system_bus = QDBusConnection.systemBus() qubes_manager = QDBusInterface('org.qubesos.QubesManager', '/org/qubesos/QubesManager', 'org.qubesos.QubesManager', system_bus) qubes_manager.call('show_manager') def exit_app(): # notifier.stop() app.exit() # Bases on the original code by: # Copyright (c) 2002-2007 Pascal Varet def handle_exception(exc_type, exc_value, exc_traceback): for f in traceback.extract_stack(exc_traceback): print(f[0], f[1]) filename, line, dummy, dummy = traceback.extract_tb(exc_traceback).pop() filename = os.path.basename(filename) error = "%s: %s" % (exc_type.__name__, exc_value) QtGui.QMessageBox.critical( None, "Houston, we have a problem...", "Whoops. A critical error has occured. This is most likely a bug " "in Volume and Template Manager application.

%s" % error + "at line %d of file %s.

" % (line, filename)) def sighup_handler(signum, frame): os.execl("/usr/bin/qubes-manager", "qubes-manager") def main(): signal.signal(signal.SIGHUP, sighup_handler) global system_bus system_bus = QDBusConnection.systemBus() # Avoid starting more than one instance of the app # if not system_bus.registerService('org.qubesos.QubesManager'): # show_running_manager_via_dbus() # return # global qubes_host # qubes_host = QubesHost() global app app = QtGui.QApplication(sys.argv) app.setOrganizationName("The Qubes Project") app.setOrganizationDomain("http://qubes-os.org") app.setApplicationName("Qubes VM Manager") app.setWindowIcon(QtGui.QIcon.fromTheme("qubes-manager")) # app.setAttribute(Qt.AA_DontShowIconsInMenus, False) # qt_translator = QTranslator() # locale = QLocale.system().name() # i18n_dir = os.path.join( # os.path.dirname(os.path.realpath(__file__)), # 'i18n') # qt_translator.load("qubesmanager_{!s}.qm".format(locale), i18n_dir) # app.installTranslator(qt_translator) sys.excepthook = handle_exception global session_bus session_bus = QDBusConnection.sessionBus() qvm_collection = Qubes() global trayIcon trayIcon = QubesTrayIcon(QtGui.QIcon.fromTheme("qubes-manager")) global manager_window manager_window = VmManagerWindow(qvm_collection) # global wm # wm = WatchManager() # global notifier # # notifier = ThreadedNotifier(wm, QubesManagerFileWatcher( # # manager_window.mark_table_for_update)) # notifier.start() # wm.add_watch(system_path["qubes_store_filename"], # EventsCodes.OP_FLAGS.get('IN_MODIFY')) # wm.add_watch(os.path.dirname(system_path["qubes_store_filename"]), # EventsCodes.OP_FLAGS.get('IN_MOVED_TO')) # if os.path.exists(qubes_clipboard_info_file): # wm.add_watch(qubes_clipboard_info_file, # EventsCodes.OP_FLAGS.get('IN_CLOSE_WRITE')) # wm.add_watch(os.path.dirname(qubes_clipboard_info_file), # EventsCodes.OP_FLAGS.get('IN_CREATE')) # wm.add_watch(os.path.dirname(table_widgets.qubes_dom0_updates_stat_file), # EventsCodes.OP_FLAGS.get('IN_CREATE')) system_bus.registerObject(dbus_object_path, manager_window) threading.currentThread().setName("QtMainThread") trayIcon.show() show_manager() app.exec_() trayIcon = None if __name__ == "__main__": main()