|
@@ -3,7 +3,9 @@
|
|
|
# The Qubes OS Project, http://www.qubes-os.org
|
|
|
#
|
|
|
# Copyright (C) 2012 Agnieszka Kostrzewa <agnieszka.kostrzewa@gmail.com>
|
|
|
-# Copyright (C) 2012 Marek Marczykowski <marmarek@mimuw.edu.pl>
|
|
|
+# 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
|
|
@@ -21,13 +23,14 @@
|
|
|
#
|
|
|
#
|
|
|
|
|
|
-from qubes.qubes import QubesVmCollection
|
|
|
-from qubes.qubes import QubesVmLabels
|
|
|
-from qubes.qubes import QubesHost
|
|
|
-from qubes.qubes import system_path
|
|
|
|
|
|
+import collections
|
|
|
+import copy
|
|
|
import subprocess
|
|
|
-from copy import copy
|
|
|
+
|
|
|
+import qubesadmin
|
|
|
+import qubesadmin.tools
|
|
|
+
|
|
|
|
|
|
from .ui_settingsdlg import *
|
|
|
from .appmenu_select import *
|
|
@@ -35,19 +38,20 @@ from .firewall import *
|
|
|
from .backup_utils import get_path_for_vm
|
|
|
|
|
|
class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
- tabs_indices = {"basic": 0,
|
|
|
- "advanced": 1,
|
|
|
- "firewall": 2,
|
|
|
- "devices": 3,
|
|
|
- "applications": 4,
|
|
|
- "services": 5,}
|
|
|
-
|
|
|
- def __init__(self, vm, app, qvm_collection, init_page="basic", parent=None):
|
|
|
+ tabs_indices = collections.OrderedDict((
|
|
|
+ ('basic', 0),
|
|
|
+ ('advanced', 1),
|
|
|
+ ('firewall', 2),
|
|
|
+ ('devices', 3),
|
|
|
+ ('applications', 4),
|
|
|
+ ('services', 5),
|
|
|
+ ))
|
|
|
+
|
|
|
+ def __init__(self, vm, qapp, init_page="basic", parent=None):
|
|
|
super(VMSettingsWindow, self).__init__(parent)
|
|
|
|
|
|
- self.app = app
|
|
|
- self.qvm_collection = qvm_collection
|
|
|
self.vm = vm
|
|
|
+ self.qapp = qapp
|
|
|
if self.vm.template:
|
|
|
self.source_vm = self.vm.template
|
|
|
else:
|
|
@@ -125,7 +129,7 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
progress.show()
|
|
|
|
|
|
while not thread_monitor.is_finished():
|
|
|
- self.app.processEvents()
|
|
|
+ self.qapp.processEvents()
|
|
|
time.sleep (0.1)
|
|
|
|
|
|
progress.hide()
|
|
@@ -139,7 +143,6 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
|
|
|
def __save_changes__(self, thread_monitor):
|
|
|
|
|
|
- self.qvm_collection.lock_db_for_writing()
|
|
|
self.anything_changed = False
|
|
|
|
|
|
ret = []
|
|
@@ -179,10 +182,6 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
except Exception as ex:
|
|
|
ret += [self.tr("Applications tab:"), str(ex)]
|
|
|
|
|
|
- if self.anything_changed == True:
|
|
|
- self.qvm_collection.save()
|
|
|
- self.qvm_collection.unlock_db()
|
|
|
-
|
|
|
if len(ret) > 0 :
|
|
|
thread_monitor.set_error_msg('\n'.join(ret))
|
|
|
|
|
@@ -204,112 +203,112 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
|
|
|
######### basic tab
|
|
|
|
|
|
+ # TODO LISTENERS
|
|
|
+ # - vm start/shutdown -> setEnabled on fields: template
|
|
|
+ # - vm create/delete -> choices lists, whole window deactiv (if self.vm)
|
|
|
+ # - property-set -> individual fields
|
|
|
+
|
|
|
+ # TODO INTERACTIONS
|
|
|
+ # netvm -> networking_groupbox
|
|
|
+ # hvm -> include_in_balancing
|
|
|
+
|
|
|
+ def setup_vm_choice(self, widget, propname, default, filter_function,
|
|
|
+ allow_internal=False, allow_none=False):
|
|
|
+ # some basic information
|
|
|
+ oldvalue = getattr(self.vm, propname)
|
|
|
+ is_default = self.vm.property_is_default(propname)
|
|
|
+ idx = -1
|
|
|
+
|
|
|
+ vmlist = filter(filter_function, self.app.domains)
|
|
|
+ if not allow_internal:
|
|
|
+ vmlist = filter((lambda vm: not vm.features.get('internal', False)),
|
|
|
+ vmlist)
|
|
|
+ vmlist = list(vmlist)
|
|
|
+ vmlist.insert(0, qubesadmin.DEFAULT)
|
|
|
+ if allow_none:
|
|
|
+ vmlist.append(None)
|
|
|
+
|
|
|
+ for i, vm in enumerate(vmlist):
|
|
|
+ # 0: default (unset)
|
|
|
+ if vm is qubesadmin.DEFAULT:
|
|
|
+ text = 'default ({})'.format(
|
|
|
+ default.name if default else 'none')
|
|
|
+ # N+1: explicit None
|
|
|
+ elif vm is None:
|
|
|
+ text = 'none'
|
|
|
+ # 1..N: choices
|
|
|
+ else:
|
|
|
+ text = vm.name
|
|
|
+
|
|
|
+ if vm is qubesadmin.DEFAULT and is_default \
|
|
|
+ or vm is oldvalue:
|
|
|
+ text += self.tr(' (current)')
|
|
|
+ idx = i
|
|
|
+
|
|
|
+ widget.insertItem(i, text)
|
|
|
+
|
|
|
+ setattr(self, propname + '_idx', idx)
|
|
|
+ setattr(self, propname + '_list', list)
|
|
|
+ widget.setCurrentIndex(idx)
|
|
|
+
|
|
|
+
|
|
|
def __init_basic_tab__(self):
|
|
|
self.vmname.setText(self.vm.name)
|
|
|
self.vmname.setValidator(QRegExpValidator(QRegExp("[a-zA-Z0-9-]*", Qt.CaseInsensitive), None))
|
|
|
- self.vmname.setEnabled(not self.vm.is_running())
|
|
|
-
|
|
|
- #self.qvm_collection.lock_db_for_reading()
|
|
|
- #self.qvm_collection.load()
|
|
|
- #self.qvm_collection.unlock_db()
|
|
|
+ self.vmname.setEnabled(False)
|
|
|
|
|
|
if self.vm.qid == 0:
|
|
|
self.vmlabel.setVisible(False)
|
|
|
else:
|
|
|
self.vmlabel.setVisible(True)
|
|
|
- self.label_list = QubesVmLabels.values()
|
|
|
+ self.label_list = list(self.vm.app.labels)
|
|
|
self.label_list.sort(key=lambda l: l.index)
|
|
|
self.label_idx = 0
|
|
|
- for (i, label) in enumerate(self.label_list):
|
|
|
+ for i, label in enumerate(self.label_list):
|
|
|
if label == self.vm.label:
|
|
|
self.label_idx = i
|
|
|
self.vmlabel.insertItem(i, label.name)
|
|
|
- self.vmlabel.setItemIcon (i, QIcon(label.icon_path))
|
|
|
+ self.vmlabel.setItemIcon(i, QIcon.fromTheme(label.icon))
|
|
|
self.vmlabel.setCurrentIndex(self.label_idx)
|
|
|
self.vmlabel.setEnabled(not self.vm.is_running())
|
|
|
|
|
|
- if not self.vm.is_template() and self.vm.template is not None:
|
|
|
- template_vm_list = [vm for vm in self.qvm_collection.values() if not vm.internal and vm.is_template()]
|
|
|
- self.template_idx = -1
|
|
|
-
|
|
|
- i = 0
|
|
|
- for vm in template_vm_list:
|
|
|
- if not self.vm.is_template_compatible(vm):
|
|
|
- continue
|
|
|
- text = vm.name
|
|
|
- if vm is self.qvm_collection.get_default_template():
|
|
|
- text += self.tr(" (default)")
|
|
|
- if vm.qid == self.vm.template.qid:
|
|
|
- self.template_idx = i
|
|
|
- text += self.tr(" (current)")
|
|
|
- self.template_name.insertItem(i, text)
|
|
|
- i += 1
|
|
|
- self.template_name.setCurrentIndex(self.template_idx)
|
|
|
- self.template_name.setEnabled(not self.vm.is_running())
|
|
|
+ if isinstance(self.vm, qubesadmin.vm.AppVM):
|
|
|
+ self.setup_vm_choice(self.template_name, 'template',
|
|
|
+ (lambda vm: isinstance(vm, qubesadmin.vm.TemplateVM)))
|
|
|
else:
|
|
|
self.template_name.setEnabled(False)
|
|
|
self.template_idx = -1
|
|
|
|
|
|
-
|
|
|
- if (not self.vm.is_netvm() or self.vm.is_proxyvm()):
|
|
|
- netvm_list = [vm for vm in self.qvm_collection.values() if not vm.internal and vm.is_netvm() and vm.qid != 0]
|
|
|
- self.netvm_idx = -1
|
|
|
-
|
|
|
- default_netvm = self.qvm_collection.get_default_netvm()
|
|
|
- if default_netvm is not None:
|
|
|
- text = "default (%s)" % default_netvm.name
|
|
|
- if self.vm.uses_default_netvm:
|
|
|
- text += self.tr(" (current)")
|
|
|
- self.netvm_idx = 0
|
|
|
- self.netVM.insertItem(0, text)
|
|
|
-
|
|
|
- for (i, vm) in enumerate(netvm_list):
|
|
|
- text = vm.name
|
|
|
- if self.vm.netvm is not None and vm.qid == self.vm.netvm.qid and not self.vm.uses_default_netvm:
|
|
|
- self.netvm_idx = i+1
|
|
|
- text += self.tr(" (current)")
|
|
|
- self.netVM.insertItem(i+1, text)
|
|
|
-
|
|
|
- none_text = "none"
|
|
|
- if self.vm.netvm is None:
|
|
|
- none_text += self.tr(" (current)")
|
|
|
- self.netvm_idx = len(netvm_list)+1
|
|
|
- self.netVM.insertItem(len(netvm_list)+1, none_text)
|
|
|
-
|
|
|
- self.netVM.setCurrentIndex(self.netvm_idx)
|
|
|
- else:
|
|
|
- self.netVM.setEnabled(False)
|
|
|
- self.netvm_idx = -1
|
|
|
+ self.setup_vm_choice(self.netVM, 'netvm',
|
|
|
+ (lambda vm: vm.provides_network))
|
|
|
|
|
|
self.include_in_backups.setChecked(self.vm.include_in_backups)
|
|
|
|
|
|
- if hasattr(self.vm, 'debug'):
|
|
|
- self.run_in_debug_mode.setVisible(True)
|
|
|
+ try:
|
|
|
self.run_in_debug_mode.setChecked(self.vm.debug)
|
|
|
- else:
|
|
|
+ self.run_in_debug_mode.setVisible(True)
|
|
|
+ except AttributeError:
|
|
|
self.run_in_debug_mode.setVisible(False)
|
|
|
|
|
|
- if hasattr(self.vm, 'autostart'):
|
|
|
- self.autostart_vm.setVisible(True)
|
|
|
+ try:
|
|
|
self.autostart_vm.setChecked(self.vm.autostart)
|
|
|
- else:
|
|
|
+ self.autostart_vm.setVisible(True)
|
|
|
+ except AttributeError:
|
|
|
self.autostart_vm.setVisible(False)
|
|
|
|
|
|
- if hasattr(self.vm, 'seamless_gui_mode'):
|
|
|
- self.seamless_gui.setVisible(True)
|
|
|
- self.seamless_gui.setChecked(self.vm.seamless_gui_mode)
|
|
|
- else:
|
|
|
- self.seamless_gui.setVisible(False)
|
|
|
+ # XXX - False?
|
|
|
+ self.seamless_gui.setVisible(True)
|
|
|
+ self.seamless_gui.setChecked(
|
|
|
+ self.vm.features.get('seamless-gui', False))
|
|
|
|
|
|
#type
|
|
|
- self.type_label.setText(self.vm.type)
|
|
|
+ self.type_label.setText(type(self.vm).__name__)
|
|
|
|
|
|
#installed by rpm
|
|
|
- text = "Yes" if self.vm.installed_by_rpm == True else "No"
|
|
|
- self.rpm_label.setText(text)
|
|
|
+ self.rpm_label.setText('Yes' if self.vm.installed_by_rpm else 'No')
|
|
|
|
|
|
#networking info
|
|
|
- if self.vm.is_networked():
|
|
|
+ if self.vm.netvm:
|
|
|
self.networking_groupbox.setEnabled(True)
|
|
|
self.ip_label.setText(self.vm.ip if self.vm.ip is not None else "none")
|
|
|
self.netmask_label.setText(self.vm.netmask if self.vm.netmask is not None else "none")
|
|
@@ -318,37 +317,20 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
self.networking_groupbox.setEnabled(False)
|
|
|
|
|
|
#max priv storage
|
|
|
- self.priv_img_size = self.vm.get_private_img_sz()/1024/1024
|
|
|
- self.max_priv_storage.setMinimum(self.priv_img_size)
|
|
|
- self.max_priv_storage.setValue(self.priv_img_size)
|
|
|
+# self.priv_img_size = self.vm.get_private_img_sz()/1024/1024
|
|
|
+# self.max_priv_storage.setMinimum(self.priv_img_size)
|
|
|
+# self.max_priv_storage.setValue(self.priv_img_size)
|
|
|
|
|
|
- self.root_img_size = self.vm.get_root_img_sz()/1024/1024
|
|
|
- self.root_resize.setValue(self.root_img_size)
|
|
|
- self.root_resize.setMinimum(self.root_img_size)
|
|
|
- self.root_resize.setEnabled(hasattr(self.vm, 'resize_root_img') and
|
|
|
- not self.vm.template)
|
|
|
- self.root_resize_label.setEnabled(self.root_resize.isEnabled())
|
|
|
+# self.root_img_size = self.vm.get_root_img_sz()/1024/1024
|
|
|
+# self.root_resize.setValue(self.root_img_size)
|
|
|
+# self.root_resize.setMinimum(self.root_img_size)
|
|
|
+# self.root_resize.setEnabled(hasattr(self.vm, 'resize_root_img') and
|
|
|
+# not self.vm.template)
|
|
|
+# self.root_resize_label.setEnabled(self.root_resize.isEnabled())
|
|
|
|
|
|
def __apply_basic_tab__(self):
|
|
|
msg = []
|
|
|
|
|
|
- # vmname changed
|
|
|
- vmname = str(self.vmname.text())
|
|
|
- if self.vm.name != vmname:
|
|
|
- if self.vm.is_running():
|
|
|
- msg.append(self.tr("Can't change name of a running VM."))
|
|
|
- elif self.qvm_collection.get_vm_by_name(vmname) is not None:
|
|
|
- msg.append(
|
|
|
- unicode(self.tr("Can't change VM name - a VM named <b>{0}</b>"
|
|
|
- "already exists in the system!")).format(vmname))
|
|
|
- else:
|
|
|
- oldname = self.vm.name
|
|
|
- try:
|
|
|
- self.vm.set_name(vmname)
|
|
|
- self.anything_changed = True
|
|
|
- except Exception as ex:
|
|
|
- msg.append(str(ex))
|
|
|
-
|
|
|
#vm label changed
|
|
|
try:
|
|
|
if self.vmlabel.isVisible():
|
|
@@ -362,12 +344,8 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
#vm template changed
|
|
|
try:
|
|
|
if self.template_name.currentIndex() != self.template_idx:
|
|
|
- new_template_name = str(self.template_name.currentText())
|
|
|
- new_template_name = new_template_name.split(' ')[0]
|
|
|
- template_vm = self.qvm_collection.get_vm_by_name(new_template_name)
|
|
|
- assert (template_vm is not None and template_vm.qid in self.qvm_collection)
|
|
|
- assert template_vm.is_template()
|
|
|
- self.vm.template = template_vm
|
|
|
+ self.vm.template = \
|
|
|
+ self.template_list[self.template_name.currentIndex()]
|
|
|
self.anything_changed = True
|
|
|
except Exception as ex:
|
|
|
msg.append(str(ex))
|
|
@@ -375,23 +353,7 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
#vm netvm changed
|
|
|
try:
|
|
|
if self.netVM.currentIndex() != self.netvm_idx:
|
|
|
- new_netvm_name = str(self.netVM.currentText())
|
|
|
- new_netvm_name = new_netvm_name.split(' ')[0]
|
|
|
-
|
|
|
- uses_default_netvm = False
|
|
|
-
|
|
|
- if new_netvm_name == "default":
|
|
|
- new_netvm_name = self.qvm_collection.get_default_netvm().name
|
|
|
- uses_default_netvm = True
|
|
|
-
|
|
|
- if new_netvm_name == "none":
|
|
|
- netvm = None
|
|
|
- else:
|
|
|
- netvm = self.qvm_collection.get_vm_by_name(new_netvm_name)
|
|
|
- assert (netvm is None or (netvm is not None and netvm.qid in self.qvm_collection and netvm.is_netvm()))
|
|
|
-
|
|
|
- self.vm.netvm = netvm
|
|
|
- self.vm.uses_default_netvm = uses_default_netvm
|
|
|
+ self.vm.netvm = self.netvm_list[self.netVM.currentIndex()]
|
|
|
self.anything_changed = True
|
|
|
except Exception as ex:
|
|
|
msg.append(str(ex))
|
|
@@ -475,39 +437,39 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
def __init_advanced_tab__(self):
|
|
|
|
|
|
#mem/cpu
|
|
|
- qubes_memory = QubesHost().memory_total/1024
|
|
|
+# qubes_memory = QubesHost().memory_total/1024
|
|
|
|
|
|
self.init_mem.setValue(int(self.vm.memory))
|
|
|
- self.init_mem.setMaximum(qubes_memory)
|
|
|
+# self.init_mem.setMaximum(qubes_memory)
|
|
|
|
|
|
self.max_mem_size.setValue(int(self.vm.maxmem))
|
|
|
- self.max_mem_size.setMaximum(qubes_memory)
|
|
|
+# self.max_mem_size.setMaximum(qubes_memory)
|
|
|
|
|
|
self.vcpus.setMinimum(1)
|
|
|
- self.vcpus.setMaximum(QubesHost().no_cpus)
|
|
|
+# self.vcpus.setMaximum(QubesHost().no_cpus)
|
|
|
self.vcpus.setValue(int(self.vm.vcpus))
|
|
|
|
|
|
- self.include_in_balancing.setEnabled(True)
|
|
|
- self.include_in_balancing.setChecked(self.vm.services['meminfo-writer']==True)
|
|
|
- if self.vm.type == "HVM":
|
|
|
- self.include_in_balancing.setChecked(False)
|
|
|
- self.include_in_balancing.setEnabled(False)
|
|
|
+ self.include_in_balancing.setEnabled(not self.vm.hvm)
|
|
|
+ self.include_in_balancing.setChecked(not self.vm.hvm
|
|
|
+ and self.vm.features.get('services/meminfo-writer', True))
|
|
|
self.max_mem_size.setEnabled(self.include_in_balancing.isChecked())
|
|
|
|
|
|
#paths
|
|
|
self.dir_path.setText(self.vm.dir_path)
|
|
|
self.config_path.setText(self.vm.conf_file)
|
|
|
- if self.vm.template is not None:
|
|
|
+ try:
|
|
|
self.root_img_path.setText(self.vm.template.root_img)
|
|
|
- elif self.vm.root_img is not None:
|
|
|
- self.root_img_path.setText(self.vm.root_img)
|
|
|
- else:
|
|
|
+ except AttributeError:
|
|
|
+ pass
|
|
|
+ try:
|
|
|
+ self.root_img_path.setText(self.vm.storage.root_img)
|
|
|
+ except AttributeError:
|
|
|
self.root_img_path.setText("n/a")
|
|
|
- if self.vm.volatile_img is not None:
|
|
|
- self.volatile_img_path.setText(self.vm.volatile_img)
|
|
|
- else:
|
|
|
+ try:
|
|
|
+ self.volatile_img_path.setText(self.vm.storage.volatile_img)
|
|
|
+ except AttributeError:
|
|
|
self.volatile_img_path.setText('n/a')
|
|
|
- self.private_img_path.setText(self.vm.private_img)
|
|
|
+ self.private_img_path.setText(self.vm.storage.private_img)
|
|
|
|
|
|
|
|
|
#kernel
|
|
@@ -518,7 +480,7 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
else:
|
|
|
self.kernel_groupbox.setVisible(True)
|
|
|
# construct available kernels list
|
|
|
- text = "default (" + self.qvm_collection.get_default_kernel() +")"
|
|
|
+ text = "default (" + self.app.get_default_kernel() +")"
|
|
|
kernel_list = [text]
|
|
|
for k in os.listdir(system_path["qubes_kernels_base_dir"]):
|
|
|
kernel_list.append(k)
|
|
@@ -550,7 +512,7 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
self.drive_running_warning.setVisible(self.vm.is_running())
|
|
|
self.drive_type.addItems(["hd", "cdrom"])
|
|
|
self.drive_type.setCurrentIndex(0)
|
|
|
- vm_list = [vm for vm in self.qvm_collection.values() if not vm
|
|
|
+ vm_list = [vm for vm in self.app.values() if not vm
|
|
|
.internal and vm.qid != self.vm.qid]
|
|
|
# default to dom0 (in case of nonexisting vm already set...)
|
|
|
self.drive_domain_idx = 0
|
|
@@ -577,7 +539,7 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
self.other_groupbox.setVisible(False)
|
|
|
else:
|
|
|
self.other_groupbox.setVisible(True)
|
|
|
- netvm_list = [vm for vm in self.qvm_collection.values() if not vm.internal and vm.is_netvm() and vm.qid != 0]
|
|
|
+ netvm_list = [vm for vm in self.app.values() if not vm.internal and vm.is_netvm() and vm.qid != 0]
|
|
|
self.dispvm_netvm_idx = -1
|
|
|
|
|
|
text = "default (same as VM own NetVM)"
|
|
@@ -633,7 +595,7 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
uses_default_kernel = False
|
|
|
|
|
|
if new_kernel == "default":
|
|
|
- kernel = self.qvm_collection.get_default_kernel()
|
|
|
+ kernel = self.app.get_default_kernel()
|
|
|
uses_default_kernel = True
|
|
|
elif new_kernel == "none":
|
|
|
kernel = None
|
|
@@ -685,10 +647,10 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
if new_dispvm_netvm_name == "none":
|
|
|
dispvm_netvm = None
|
|
|
else:
|
|
|
- dispvm_netvm = self.qvm_collection.get_vm_by_name(
|
|
|
+ dispvm_netvm = self.app.get_vm_by_name(
|
|
|
new_dispvm_netvm_name)
|
|
|
assert (dispvm_netvm is None or (dispvm_netvm.qid in
|
|
|
- self.qvm_collection and dispvm_netvm.is_netvm()))
|
|
|
+ self.app and dispvm_netvm.is_netvm()))
|
|
|
|
|
|
if uses_default_dispvm_netvm:
|
|
|
self.vm.uses_default_dispvm_netvm = True
|
|
@@ -711,7 +673,7 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
drv_domain = str(self.drive_domain.currentText())
|
|
|
if drv_domain.count("(current)") > 0:
|
|
|
drv_domain = drv_domain.split(' ')[0]
|
|
|
- backend_vm = self.qvm_collection.get_vm_by_name(drv_domain)
|
|
|
+ backend_vm = self.app.get_vm_by_name(drv_domain)
|
|
|
if backend_vm:
|
|
|
new_path = get_path_for_vm(backend_vm, "qubes.SelectFile")
|
|
|
if new_path:
|
|
@@ -820,7 +782,7 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
self.services_list.addItem(item)
|
|
|
|
|
|
self.connect(self.services_list, SIGNAL("itemClicked(QListWidgetItem *)"), self.services_item_clicked)
|
|
|
- self.new_srv_dict = copy(self.vm.services)
|
|
|
+ self.new_srv_dict = copy.copy(self.vm.services)
|
|
|
|
|
|
def __add_service__(self):
|
|
|
srv = str(self.service_line_edit.text()).strip()
|
|
@@ -1005,17 +967,17 @@ class VMSettingsWindow(Ui_SettingsDialog, QDialog):
|
|
|
# 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 ):
|
|
|
+def handle_exception(exc_type, exc_value, exc_traceback):
|
|
|
import sys
|
|
|
import os.path
|
|
|
import traceback
|
|
|
|
|
|
- filename, line, dummy, dummy = traceback.extract_tb( exc_traceback ).pop()
|
|
|
- filename = os.path.basename( filename )
|
|
|
- error = "%s: %s" % ( exc_type.__name__, exc_value )
|
|
|
+ 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 )
|
|
|
+ stacktrace = traceback.extract_tb(exc_traceback)
|
|
|
while len(stacktrace) > 0:
|
|
|
(filename, line, func, txt) = stacktrace.pop()
|
|
|
strace += "----\n"
|
|
@@ -1027,7 +989,7 @@ def handle_exception( exc_type, exc_value, exc_traceback ):
|
|
|
msg_box = QMessageBox()
|
|
|
msg_box.setDetailedText(strace)
|
|
|
msg_box.setIcon(QMessageBox.Critical)
|
|
|
- msg_box.setWindowTitle( "Houston, we have a problem...")
|
|
|
+ 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 +
|
|
@@ -1037,55 +999,30 @@ def handle_exception( exc_type, exc_value, exc_traceback ):
|
|
|
msg_box.exec_()
|
|
|
|
|
|
|
|
|
-def main():
|
|
|
-
|
|
|
- global qubes_host
|
|
|
- qubes_host = QubesHost()
|
|
|
+parser = qubesadmin.tools.QubesArgumentParser(vmname_nargs=1)
|
|
|
+parser.add_argument('--tab', metavar='TAB',
|
|
|
+ action='store',
|
|
|
+ choices=VMSettingsWindow.tabs_indices.keys())
|
|
|
+parser.set_defaults(tab='basic')
|
|
|
|
|
|
- global app
|
|
|
- app = QApplication(sys.argv)
|
|
|
- app.setOrganizationName("The Qubes Project")
|
|
|
- app.setOrganizationDomain("http://qubes-os.org")
|
|
|
- app.setApplicationName("Qubes VM Settings")
|
|
|
-
|
|
|
- sys.excepthook = handle_exception
|
|
|
+def main(args=None):
|
|
|
+ global settings_window
|
|
|
|
|
|
- qvm_collection = QubesVmCollection()
|
|
|
- qvm_collection.lock_db_for_reading()
|
|
|
- qvm_collection.load()
|
|
|
- qvm_collection.unlock_db()
|
|
|
-
|
|
|
- vm = None
|
|
|
- tab = "basic"
|
|
|
-
|
|
|
- if len(sys.argv) > 1:
|
|
|
- vm = qvm_collection.get_vm_by_name(sys.argv[1])
|
|
|
- if vm is None or vm.qid not in qvm_collection:
|
|
|
- QMessageBox.critical(None, "Qubes VM Settings Error",
|
|
|
- "A VM with the name '{0}' does not exist in the system.".format(sys.argv[1]))
|
|
|
- sys.exit(1)
|
|
|
- if len(sys.argv) > 2:
|
|
|
- tab_arg = sys.argv[2]
|
|
|
- if tab_arg in VMSettingsWindow.tabs_indices:
|
|
|
- tab = tab_arg
|
|
|
- else: QMessageBox.warning(None, "Qubes VM Settings Error",
|
|
|
- "There is no such tab as '{0}'. Opening default tab instead.".format(tab_arg))
|
|
|
-
|
|
|
- else:
|
|
|
- vms_list = [vm.name for vm in qvm_collection.values() if (vm.is_appvm() or vm.is_template())]
|
|
|
- vmname = QInputDialog.getItem(None, "Select VM", "Select VM:", vms_list, editable = False)
|
|
|
- if not vmname[1]:
|
|
|
- sys.exit(1)
|
|
|
- vm = qvm_collection.get_vm_by_name(vmname[0])
|
|
|
+ args = parser.parse_args(args)
|
|
|
+ vm = args.domains.pop()
|
|
|
|
|
|
+ qapp = QApplication(sys.argv)
|
|
|
+ qapp.setOrganizationName('Invisible Things Lab')
|
|
|
+ qapp.setOrganizationDomain("https://www.qubes-os.org/")
|
|
|
+ qapp.setApplicationName("Qubes VM Settings")
|
|
|
|
|
|
- global settings_window
|
|
|
- settings_window = VMSettingsWindow(vm, app, qvm_collection, tab)
|
|
|
+ sys.excepthook = handle_exception
|
|
|
|
|
|
+ settings_window = VMSettingsWindow(vm, qapp, args.tab)
|
|
|
settings_window.show()
|
|
|
|
|
|
- app.exec_()
|
|
|
- app.exit()
|
|
|
+ qapp.exec_()
|
|
|
+ qapp.exit()
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|