manager/qubesmanager/qube_manager.py

#!/usr/bin/python3
#
# The Qubes OS Project, http://www.qubes-os.org
#
# Copyright (C) 2012  Agnieszka Kostrzewa <agnieszka.kostrzewa@gmail.com>
# Copyright (C) 2012  Marek Marczykowski-Górecki
#                       <marmarek@invisiblethingslab.com>
# Copyright (C) 2017  Wojtek Porczyk <woju@invisiblethingslab.com>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License along
# with this program; if not, see <http://www.gnu.org/licenses/>.
#
#

import sys
import os
import os.path
import subprocess
import time
from datetime import datetime, timedelta
import traceback
import threading

from pydbus import SessionBus

from qubesadmin import Qubes
from qubesadmin import exc

from PyQt4 import QtGui  # pylint: disable=import-error
from PyQt4 import QtCore  # pylint: disable=import-error

from qubesmanager.about import AboutDialog

from . import ui_qubemanager  # pylint: disable=no-name-in-module
from . import thread_monitor
from . import table_widgets
from . import settings
from . import global_settings
from . import restore
from . import backup
from . import log_dialog


class SearchBox(QtGui.QLineEdit):
    def __init__(self, parent=None):
        super(SearchBox, self).__init__(parent)
        self.focusing = False

    def focusInEvent(self, e):  # pylint: disable=invalid-name
        super(SearchBox, self).focusInEvent(e)
        self.selectAll()
        self.focusing = True

    def mousePressEvent(self, e):  # pylint: disable=invalid-name
        super(SearchBox, self).mousePressEvent(e)
        if self.focusing:
            self.selectAll()
            self.focusing = False


class VmRowInTable:
    # pylint: disable=too-few-public-methods
    def __init__(self, vm, row_no, table):
        self.vm = vm
        # TODO: replace a various different widgets with a more generic
        # VmFeatureWidget or VMPropertyWidget


        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.table_item)

        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.table_item)

        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.table_item)

        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.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)

        self.table = table

    def update(self, update_size_on_disk=False):
        """
        Update info in a single VM row
        :param update_size_on_disk: should disk utilization be updated? the
        widget will extract the data from VM object
        :return: None
        """
        try:
            self.info_widget.update_vm_state()
            self.template_widget.update()
            self.netvm_widget.update()
            self.internal_widget.update()
            self.ip_widget.update()
            self.include_in_backups_widget.update()
            self.last_backup_widget.update()
            if update_size_on_disk:
                self.size_widget.update()
        except exc.QubesPropertyAccessError:
            pass

        #force re-sorting
        self.table.setSortingEnabled(True)


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()
        try:
            vm_start_time = datetime.fromtimestamp(float(vm.start_time))
        except (AttributeError, TypeError, ValueError):
            vm_start_time = None

        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("Qube Shutdown"),
                    self.tr(
                        "The Qube <b>'{0}'</b> hasn't shutdown within the last "
                        "{1} seconds, do you want to kill it?<br>").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:
                    try:
                        vm.kill()
                    except exc.QubesVMNotStartedError:
                        # the VM shut down while the user was thinking about
                        # shutting it down
                        pass
                    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_qubemanager.Ui_VmManagerWindow, QtGui.QMainWindow):
    # pylint: disable=too-many-instance-attributes
    row_height = 30
    column_width = 200
    search = ""
    # suppress saving settings while initializing widgets
    settings_loaded = False
    columns_indices = {"Type": 0,
                       "Label": 1,
                       "Name": 2,
                       "State": 3,
                       "Template": 4,
                       "NetVM": 5,
                       "Size": 6,
                       "Internal": 7,
                       "IP": 8,
                       "Backups": 9,
                       "Last backup": 10,
                       }

    def __init__(self, qt_app, qubes_app, parent=None):
        # pylint: disable=unused-argument
        super(VmManagerWindow, self).__init__()
        self.setupUi(self)

        self.manager_settings = QtCore.QSettings(self)

        self.qubes_app = qubes_app
        self.qt_app = qt_app

        self.searchbox = SearchBox()
        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.vms_list = []
        self.vms_in_table = {}

        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["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
        }

        self.visible_columns_count = len(self.columns_indices)

        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.Interactive)
        self.table.horizontalHeader().setStretchLastSection(True)

        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.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.dom0_context_menu = QtGui.QMenu(self)
        self.dom0_context_menu.addAction(self.action_global_settings)
        self.dom0_context_menu.addAction(self.action_updatevm)
        self.dom0_context_menu.addSeparator()

        self.dom0_context_menu.addMenu(self.logs_menu)
        self.dom0_context_menu.addSeparator()

        self.connect(
            self.table.horizontalHeader(),
            QtCore.SIGNAL("sortIndicatorChanged(int, Qt::SortOrder)"),
            self.sort_indicator_changed)
        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.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.load_manager_settings()

        self.fill_table()

        self.update_size_on_disk = False
        self.shutdown_monitor = {}

        # Connect dbus events
        self.bus = SessionBus()
        manager = self.bus.get("org.qubes.DomainManager1")
        manager.DomainAdded.connect(self.on_domain_added)
        manager.DomainRemoved.connect(self.on_domain_removed)
        manager.Failed.connect(self.on_failed)
        manager.Halted.connect(self.on_halted)
        manager.Halting.connect(self.on_halting)
        manager.Starting.connect(self.on_starting)
        manager.Started.connect(self.on_started)

        # Check Updates Timer
        timer = QtCore.QTimer(self)
        timer.timeout.connect(self.check_updates)
        timer.start(1000 * 30) # 30s
        self.check_updates()

    def check_updates(self):
        for vm in self.qubes_app.domains:
            if vm.klass in {'TemplateVM', 'StandaloneVM'}:
                self.vms_in_table[vm.qid].update()

    def on_domain_added(self, _, domain):
        #needs to clear cache
        self.qubes_app.domains.clear_cache()
        qid = int(domain.split('/')[-1])

        self.table.setSortingEnabled(False)

        row_no = self.table.rowCount()
        self.table.setRowCount(row_no + 1)


        for vm in self.qubes_app.domains:
            if vm.qid == qid:
                vm_row = VmRowInTable(vm, row_no, self.table)
                self.vms_in_table[vm.qid] = vm_row
                self.table.setSortingEnabled(True)
                self.showhide_vms()
                return

        # Never should reach here
        raise RuntimeError('Added domain not found')

    def on_domain_removed(self, _, domain):
        #needs to clear cache
        self.qubes_app.domains.clear_cache()
        qid = int(domain.split('/')[-1])

        # Find row and remove
        try:
            row_index = 0
            vm_item = self.table.item(row_index, self.columns_indices["Name"])
            while vm_item.qid != qid:
                row_index += 1
                vm_item = self.table.item(row_index,\
                        self.columns_indices["Name"])
        except:
            raise RuntimeError('Deleted domain not found')

        self.table.removeRow(row_index)
        del self.vms_in_table[qid]

    def on_failed(self, _, domain):
        qid = int(domain.split('/')[-1])
        self.vms_in_table[qid].update()

        if self.vms_in_table[qid].vm == self.get_selected_vm():
            self.table_selection_changed()

    def on_halted(self, _, domain):
        qid = int(domain.split('/')[-1])
        self.vms_in_table[qid].update()

        if self.vms_in_table[qid].vm == self.get_selected_vm():
            self.table_selection_changed()

        # Check if is TemplatVM and update related AppVMs
        starting_vm = self.vms_in_table[qid]
        if starting_vm.vm.klass == 'TemplateVM':
            for vm in starting_vm.vm.appvms:
                if vm.klass == 'AppVM':
                    self.vms_in_table[vm.qid].update()

    def on_halting(self, _, domain):
        qid = int(domain.split('/')[-1])
        self.vms_in_table[qid].update()

        if self.vms_in_table[qid].vm == self.get_selected_vm():
            self.table_selection_changed()

    def on_started(self, _, domain):
        qid = int(domain.split('/')[-1])
        self.vms_in_table[qid].update()

        if self.vms_in_table[qid].vm == self.get_selected_vm():
            self.table_selection_changed()

    def on_starting(self, _, domain):
        qid = int(domain.split('/')[-1])
        self.vms_in_table[qid].update()

        if self.vms_in_table[qid].vm == self.get_selected_vm():
            self.table_selection_changed()

        # Check if is TemplatVM and update related AppVMs
        starting_vm = self.vms_in_table[qid]
        if starting_vm.vm.klass == 'TemplateVM':
            for vm in starting_vm.vm.appvms:
                if vm.klass == 'AppVM':
                    self.vms_in_table[vm.qid].update()

    def load_manager_settings(self):
        # visible columns
        self.visible_columns_count = 0
        for col in self.columns_indices:
            col_no = self.columns_indices[col]
            visible = self.manager_settings.value(
                'columns/%s' % col,
                defaultValue="true")
            self.columns_actions[col_no].setChecked(visible == "true")
            self.visible_columns_count += 1

        self.sort_by_column = str(
            self.manager_settings.value("view/sort_column",
                                        defaultValue=self.sort_by_column))
        self.sort_order = QtCore.Qt.SortOrder(
            self.manager_settings.value("view/sort_order",
                                        defaultValue=self.sort_order))
        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)
        self.settings_loaded = True

    def get_vms_list(self):
        return [vm for vm in self.qubes_app.domains]

    def fill_table(self):
        progress = QtGui.QProgressDialog(
            self.tr(
                "Loading Qube Manager..."), "", 0, 0)
        progress.setWindowTitle(self.tr("Qube Manager"))
        progress.setWindowFlags(QtCore.Qt.Window |
                                QtCore.Qt.WindowTitleHint |
                                QtCore.Qt.CustomizeWindowHint)
        progress.setCancelButton(None)
        progress.setModal(True)
        progress.show()

        self.table.setSortingEnabled(False)
        vms_list = self.get_vms_list()

        vms_in_table = {}

        self.table.setRowCount(len(vms_list))

        row_no = 0
        for vm in vms_list:
            vm_row = VmRowInTable(vm, row_no, self.table)
            vms_in_table[vm.qid] = vm_row
            row_no += 1
            self.qt_app.processEvents()

        self.vms_list = vms_list
        self.vms_in_table = vms_in_table
        self.table.setSortingEnabled(True)

        progress.hide()

    def showhide_vms(self):
        if 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"])
                show = (self.search in widget.vm.name)
                self.table.setRowHidden(row_no, not show)

    @QtCore.pyqtSlot(str)
    def do_search(self, search):
        self.search = str(search)
        self.showhide_vms()

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_search_triggered')
    def action_search_triggered(self):
        self.searchbox.setFocus()

    # noinspection PyPep8Naming
    def sort_indicator_changed(self, column, order):
        self.sort_by_column = [name for name in self.columns_indices 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 and vm in self.qubes_app.domains:

            #  TODO: add boot from device to menu and add windows tools there
            # Update available actions:
            self.action_settings.setEnabled(vm.klass != 'AdminVM')
            self.action_removevm.setEnabled(
                vm.klass != 'AdminVM' and not vm.is_running())
            self.action_clonevm.setEnabled(vm.klass != 'AdminVM')
            self.action_resumevm.setEnabled(
                not vm.is_running() or vm.get_power_state() == "Paused")
            self.action_pausevm.setEnabled(
                vm.is_running() and vm.get_power_state() != "Paused"
                and vm.klass != 'AdminVM')
            self.action_shutdownvm.setEnabled(
                vm.is_running() and vm.get_power_state() != "Paused"
                and vm.klass != 'AdminVM')
            self.action_restartvm.setEnabled(
                vm.is_running() and vm.get_power_state() != "Paused"
                and vm.klass != 'AdminVM'
                and (vm.klass != 'DispVM' or not vm.auto_cleanup))
            self.action_killvm.setEnabled(
                (vm.get_power_state() == "Paused" or vm.is_running())
                and vm.klass != 'AdminVM')

            self.action_appmenus.setEnabled(
                vm.klass != 'AdminVM' and vm.klass != 'DispVM'
                and not vm.features.get('internal', False))
            self.action_editfwrules.setEnabled(vm.klass != 'AdminVM')
            self.action_updatevm.setEnabled(getattr(vm, 'updateable', False)
                                            or vm.qid == 0)
            self.action_run_command_in_vm.setEnabled(
                not vm.get_power_state() == "Paused" and vm.qid != 0)
            self.action_set_keyboard_layout.setEnabled(
                vm.qid != 0 and
                vm.get_power_state() != "Paused" and vm.is_running())
        else:
            self.action_settings.setEnabled(False)
            self.action_removevm.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_run_command_in_vm.setEnabled(False)
            self.action_set_keyboard_layout.setEnabled(False)

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_createvm_triggered')
    def action_createvm_triggered(self):  # pylint: disable=no-self-use
        subprocess.check_call('qubes-vm-create')

    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
        return None

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_removevm_triggered')
    def action_removevm_triggered(self):
        # pylint: disable=no-else-return

        vm = self.get_selected_vm()

        if vm.klass == 'TemplateVM':
            dependent_vms = 0
            for single_vm in self.qubes_app.domains:
                if getattr(single_vm, 'template', None) == vm:
                    dependent_vms += 1
            if dependent_vms > 0:
                QtGui.QMessageBox.warning(
                    None, self.tr("Warning!"),
                    self.tr("This Template Qube cannot be removed, "
                            "because there is at least one Qube that is based "
                            "on it.<br><small>If you want to remove this "
                            "Template Qube and all the Qubes based on it, you "
                            "should first remove each individual Qube that "
                            "uses this template.</small>"))
                return

        (requested_name, ok) = QtGui.QInputDialog.getText(
            None, self.tr("Qube Removal Confirmation"),
            self.tr("Are you sure you want to remove the Qube <b>'{0}'</b>"
                    "?<br> All data on this Qube's private storage will be "
                    "lost!<br><br>Type the name of the Qube (<b>{1}</b>) below "
                    "to confirm:").format(vm.name, vm.name))

        if not ok:
            # user clicked cancel
            return

        if requested_name != vm.name:
            # name did not match
            QtGui.QMessageBox.warning(
                None,
                self.tr("Qube 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, self.qubes_app, t_monitor))
            thread.daemon = True
            thread.start()

            progress = QtGui.QProgressDialog(
                self.tr(
                    "Removing Qube: <b>{0}</b>...").format(vm.name), "", 0, 0)
            progress.setWindowFlags(QtCore.Qt.Window |
                                    QtCore.Qt.WindowTitleHint |
                                    QtCore.Qt.CustomizeWindowHint)
            progress.setCancelButton(None)
            progress.setModal(True)
            progress.show()

            while not t_monitor.is_finished():
                self.qt_app.processEvents()
                time.sleep(0.1)

            progress.hide()

            if t_monitor.success:
                pass
            else:
                QtGui.QMessageBox.warning(None, self.tr("Error removing Qube!"),
                                          self.tr("ERROR: {0}").format(
                                              t_monitor.error_msg))

    @staticmethod
    def do_remove_vm(vm, qubes_app, t_monitor):
        try:
            del qubes_app.domains[vm.name]
        except exc.QubesException as ex:
            t_monitor.set_error_msg(str(ex))

        t_monitor.set_finished()

    # noinspection PyArgumentList
    @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 name_format % name_number in self.qubes_app.domains.keys():
            name_number += 1

        (clone_name, ok) = QtGui.QInputDialog.getText(
            self, self.tr('Qubes clone Qube'),
            self.tr('Enter name for Qube <b>{}</b> 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, self.qubes_app,
                                        clone_name, t_monitor))
        thread.daemon = True
        thread.start()

        progress = QtGui.QProgressDialog(
            self.tr("Cloning Qube <b>{0}</b> to <b>{1}</b>...").format(
                vm.name, clone_name), "", 0, 0)
        progress.setWindowFlags(QtCore.Qt.Window |
                                QtCore.Qt.WindowTitleHint |
                                QtCore.Qt.CustomizeWindowHint)
        progress.setCancelButton(None)
        progress.setModal(True)
        progress.show()

        while not t_monitor.is_finished():
            self.qt_app.processEvents()
            time.sleep(0.2)

        progress.hide()

        if not t_monitor.success:
            QtGui.QMessageBox.warning(
                None,
                self.tr("Error while cloning Qube"),
                self.tr("Exception while cloning:<br>{0}").format(
                    t_monitor.error_msg))


    @staticmethod
    def do_clone_vm(src_vm, qubes_app, dst_name, t_monitor):
        dst_vm = None
        try:
            dst_vm = qubes_app.clone_vm(src_vm, dst_name)
        except exc.QubesException as ex:
            t_monitor.set_error_msg(str(ex))
            if dst_vm:
                pass
        t_monitor.set_finished()

    # noinspection PyArgumentList
    @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.unpause()
                self.vms_in_table[vm.qid].update()
                self.table_selection_changed()
            except exc.QubesException as ex:
                QtGui.QMessageBox.warning(
                    None, self.tr("Error unpausing Qube!"),
                    self.tr("ERROR: {0}").format(ex))
            return

        self.start_vm(vm)

    def start_vm(self, vm):
        if vm.is_running():
            return
        t_monitor = thread_monitor.ThreadMonitor()
        thread = threading.Thread(target=self.do_start_vm,
                                  args=(vm, t_monitor))
        thread.daemon = True
        thread.start()

        while not t_monitor.is_finished():
            self.qt_app.processEvents()
            time.sleep(0.1)

        if not t_monitor.success:
            QtGui.QMessageBox.warning(
                None,
                self.tr("Error starting Qube!"),
                self.tr("ERROR: {0}").format(t_monitor.error_msg))


    @staticmethod
    def do_start_vm(vm, t_monitor):
        try:
            vm.start()
        except exc.QubesException as ex:
            t_monitor.set_error_msg(str(ex))
            t_monitor.set_finished()
            return

        t_monitor.set_finished()

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_startvm_tools_install_triggered')
    # TODO: replace with boot from device
    def action_startvm_tools_install_triggered(self):
        # pylint: disable=invalid-name
        pass

    @QtCore.pyqtSlot(name='on_action_pausevm_triggered')
    def action_pausevm_triggered(self):
        vm = self.get_selected_vm()
        try:
            vm.pause()
            self.vms_in_table[vm.qid].update()
            self.table_selection_changed()
        except exc.QubesException as ex:
            QtGui.QMessageBox.warning(
                None,
                self.tr("Error pausing Qube!"),
                self.tr("ERROR: {0}").format(ex))
            return

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_shutdownvm_triggered')
    def action_shutdownvm_triggered(self):
        vm = self.get_selected_vm()

        reply = QtGui.QMessageBox.question(
            None, self.tr("Qube Shutdown Confirmation"),
            self.tr("Are you sure you want to power down the Qube"
                    " <b>'{0}'</b>?<br><small>This will shutdown all the "
                    "running applications within this Qube.</small>").format(
                vm.name), QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel)

        self.qt_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 exc.QubesException as ex:
            QtGui.QMessageBox.warning(
                None,
                self.tr("Error shutting down Qube!"),
                self.tr("ERROR: {0}").format(ex))
            return

        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)

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_restartvm_triggered')
    def action_restartvm_triggered(self):
        vm = self.get_selected_vm()

        reply = QtGui.QMessageBox.question(
            None, self.tr("Qube Restart Confirmation"),
            self.tr("Are you sure you want to restart the Qube <b>'{0}'</b>?"
                    "<br><small>This will shutdown all the running "
                    "applications within this Qube.</small>").format(vm.name),
            QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel)

        self.qt_app.processEvents()

        if reply == QtGui.QMessageBox.Yes:
            # in case the user shut down the VM in the meantime
            if vm.is_running():
                self.shutdown_vm(vm, and_restart=True)
            else:
                self.start_vm(vm)

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_killvm_triggered')
    def action_killvm_triggered(self):
        vm = self.get_selected_vm()
        if not (vm.is_running() or vm.is_paused()):
            info = self.tr("Qube <b>'{0}'</b> is not running. Are you "
                           "absolutely sure you want to try to kill it?<br>"
                            "<small>This will end <b>(not shutdown!)</b> all "
                           "the running applications within this "
                           "Qube.</small>").format(vm.name)
        else:
            info = self.tr("Are you sure you want to kill the Qube "
                           "<b>'{0}'</b>?<br><small>This will end <b>(not "
                           "shutdown!)</b> all the running applications within "
                           "this Qube.</small>").format(vm.name)

        reply = QtGui.QMessageBox.question(
            None, self.tr("Qube Kill Confirmation"), info,
            QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel,
            QtGui.QMessageBox.Cancel)

        self.qt_app.processEvents()

        if reply == QtGui.QMessageBox.Yes:
            try:
                vm.kill()
            except exc.QubesException as ex:
                QtGui.QMessageBox.critical(
                    None, self.tr("Error while killing Qube!"),
                    self.tr(
                        "<b>An exception ocurred while killing {0}.</b><br>"
                        "ERROR: {1}").format(vm.name, ex))
                return

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_settings_triggered')
    def action_settings_triggered(self):
        vm = self.get_selected_vm()
        if vm:
            settings_window = settings.VMSettingsWindow(
                vm, self.qt_app, "basic")
            settings_window.exec_()
            self.vms_in_table[vm.qid].update()


    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_appmenus_triggered')
    def action_appmenus_triggered(self):
        vm = self.get_selected_vm()
        if vm:
            settings_window = settings.VMSettingsWindow(
                vm, self.qt_app, "applications")
            settings_window.exec_()


    # noinspection PyArgumentList
    @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("Qube Update Confirmation"),
                self.tr(
                    "<b>{0}</b><br>The Qube has to be running to be updated."
                    "<br>Do you want to start it?<br>").format(vm.name),
                QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel)
            if reply != QtGui.QMessageBox.Yes:
                return

        self.qt_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(
                    "<b>{0}</b><br>Please wait for the updater to "
                    "launch...").format(vm.name), "", 0, 0)
        progress.setWindowFlags(QtCore.Qt.Window |
                                QtCore.Qt.WindowTitleHint |
                                QtCore.Qt.CustomizeWindowHint)
        progress.setCancelButton(None)
        progress.setModal(True)
        progress.show()

        while not t_monitor.is_finished():
            self.qt_app.processEvents()
            time.sleep(0.2)

        progress.hide()

        if vm.qid != 0:
            if not t_monitor.success:
                QtGui.QMessageBox.warning(
                    None,
                    self.tr("Error on Qube update!"),
                    self.tr("ERROR: {0}").format(t_monitor.error_msg))


    @staticmethod
    def do_update_vm(vm, t_monitor):
        try:
            if vm.qid == 0:
                subprocess.check_call(
                    ["/usr/bin/qubes-dom0-update", "--clean", "--gui"])
            else:
                if not vm.is_running():
                    vm.start()
                vm.run_service("qubes.InstallUpdatesGUI",
                               user="root", wait=False)
        except (ChildProcessError, exc.QubesException) as ex:
            t_monitor.set_error_msg(str(ex))
            t_monitor.set_finished()
            return
        t_monitor.set_finished()

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_run_command_in_vm_triggered')
    def action_run_command_in_vm_triggered(self):
        # pylint: disable=invalid-name
        vm = self.get_selected_vm()

        (command_to_run, ok) = QtGui.QInputDialog.getText(
            self, self.tr('Qubes command entry'),
            self.tr('Run command in <b>{}</b>:').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():
            self.qt_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:<br>{0}").format(
                    t_monitor.error_msg))

    @staticmethod
    def do_run_command_in_vm(vm, command_to_run, t_monitor):
        try:
            vm.run(command_to_run)
        except (ChildProcessError, exc.QubesException) as ex:
            t_monitor.set_error_msg(str(ex))
        t_monitor.set_finished()

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_set_keyboard_layout_triggered')
    def action_set_keyboard_layout_triggered(self):
        # pylint: disable=invalid-name
        vm = self.get_selected_vm()
        vm.run('qubes-change-keyboard-layout')

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_editfwrules_triggered')
    def action_editfwrules_triggered(self):
        vm = self.get_selected_vm()
        settings_window = settings.VMSettingsWindow(vm, self.qt_app, "firewall")
        settings_window.exec_()

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_global_settings_triggered')
    def action_global_settings_triggered(self):  # pylint: disable=invalid-name
        global_settings_window = global_settings.GlobalSettingsWindow(
            self.qt_app,
            self.qubes_app)
        global_settings_window.exec_()

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_show_network_triggered')
    def action_show_network_triggered(self):
        pass
        # TODO: revive for 4.1
        # network_notes_dialog = NetworkNotesDialog()
        # network_notes_dialog.exec_()

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_restore_triggered')
    def action_restore_triggered(self):
        restore_window = restore.RestoreVMsWindow(self.qt_app, self.qubes_app)
        restore_window.exec_()

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_backup_triggered')
    def action_backup_triggered(self):
        backup_window = backup.BackupVMsWindow(self.qt_app, self.qubes_app)
        backup_window.exec_()

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_exit_triggered')
    def action_exit_triggered(self):
        self.close()

    def showhide_menubar(self, checked):
        self.menubar.setVisible(checked)
        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)
        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)

        val = 1 if show else -1
        self.visible_columns_count += val

        if self.visible_columns_count == 1:
            # disable hiding the last one
            for col in self.columns_actions:
                if self.columns_actions[col].isChecked():
                    self.columns_actions[col].setEnabled(False)
                    break
        elif self.visible_columns_count == 2 and val == 1:
            # enable hiding previously disabled column
            for col in self.columns_actions:
                if not self.columns_actions[col].isEnabled():
                    self.columns_actions[col].setEnabled(True)
                    break

        if self.settings_loaded:
            col_name = [name for name in self.columns_indices 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_size_on_disk_toggled(self, checked):
        self.showhide_column(self.columns_indices['Size'], checked)

    # noinspection PyArgumentList
    @QtCore.pyqtSlot(name='on_action_about_qubes_triggered')
    def action_about_qubes_triggered(self):  # pylint: disable=no-self-use
        about = AboutDialog()
        about.exec_()

    def createPopupMenu(self):  # pylint: disable=invalid-name
        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):
        try:
            vm = self.get_selected_vm()

            # 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(logfile)
                    menu_empty = False

            self.logs_menu.setEnabled(not menu_empty)
            if vm.qid == 0:
                self.dom0_context_menu.exec_(self.table.mapToGlobal(
                    point + QtCore.QPoint(10, 0)))
            else:
                self.context_menu.exec_(self.table.mapToGlobal(
                    point + QtCore.QPoint(10, 0)))
        except exc.QubesPropertyAccessError:
            pass

    @QtCore.pyqtSlot('QAction *')
    def show_log(self, action):
        log = str(action.data())
        log_dlg = log_dialog.LogDialog(self.qt_app, log)
        log_dlg.exec_()


# Bases on the original code by:
# Copyright (c) 2002-2007 Pascal Varet <p.varet@gmail.com>

def handle_exception(exc_type, exc_value, exc_traceback):

    filename, line, dummy, dummy = traceback.extract_tb(exc_traceback).pop()
    filename = os.path.basename(filename)
    error = "%s: %s" % (exc_type.__name__, exc_value)

    strace = ""
    stacktrace = traceback.extract_tb(exc_traceback)
    while stacktrace:
        (filename, line, func, txt) = stacktrace.pop()
        strace += "----\n"
        strace += "line: %s\n" % txt
        strace += "func: %s\n" % func
        strace += "line no.: %d\n" % line
        strace += "file: %s\n" % filename

    msg_box = QtGui.QMessageBox()
    msg_box.setDetailedText(strace)
    msg_box.setIcon(QtGui.QMessageBox.Critical)
    msg_box.setWindowTitle("Houston, we have a problem...")
    msg_box.setText("Whoops. A critical error has occured. "
                    "This is most likely a bug in Qubes Manager.<br><br>"
                    "<b><i>%s</i></b>" % error +
                    "<br/>at line <b>%d</b><br/>of file %s.<br/><br/>"
                    % (line, filename))

    msg_box.exec_()


def main():
    qt_app = QtGui.QApplication(sys.argv)
    qt_app.setOrganizationName("The Qubes Project")
    qt_app.setOrganizationDomain("http://qubes-os.org")
    qt_app.setApplicationName("Qube Manager")
    qt_app.setWindowIcon(QtGui.QIcon.fromTheme("qubes-manager"))

    sys.excepthook = handle_exception

    qubes_app = Qubes()

    manager_window = VmManagerWindow(qt_app, qubes_app)
    manager_window.show()
    qt_app.exec_()


if __name__ == "__main__":
    main()