def main():
qt_app = QtWidgets.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"))
qt_app.lastWindowClosed.connect(loop_shutdown)
qubes_app = Qubes()
loop = quamash.QEventLoop(qt_app)
asyncio.set_event_loop(loop)
dispatcher = events.EventsDispatcher(qubes_app)
manager_window = TemplateManagerWindow(qt_app, qubes_app, dispatcher)
manager_window.show()
try:
loop.run_until_complete(
asyncio.ensure_future(dispatcher.listen_for_events()))
except asyncio.CancelledError:
pass
except Exception: # pylint: disable=broad-except
loop_shutdown()
exc_type, exc_value, exc_traceback = sys.exc_info()[:3]
handle_exception(exc_type, exc_value, exc_traceback)
def setUp(self):
super(DomainsWidgetTest, self).setUp()
self.widget = domains_widget.DomainTray('org.qubes.ui.tray.Domains')
self.widget.initialize_menu()
self.qapp = Qubes()
def main():
parser = ArgumentParser()
parser.add_argument('--profile-interceptors',
action='store_true',
default=False)
args = parser.parse_args()
profile_if_requested = profile if args.profile_interceptors else identity
with Popen([
"i3status", "-c",
os.path.join(os.path.dirname(sys.argv[0]), "i3status.conf")
],
stdout=PIPE) as proc:
qubes = Qubes()
restarted = os.environ.get('RESTARTED') == '1'
potentially_add_skipped_statuses = identity # not supported in the sync script
modify = potentially_add_skipped_statuses(
create_modify_specific_fields(
interceptors_by_instance=profile_if_requested({
'holder_disk_info':
DiskInterceptor(qubes), #LatencyInterceptor(100, 5000, ),
'holder_running_qubes':
RunningQubesInterceptor(qubes),
}),
interceptors_by_name=profile_if_requested(
{'battery': BatteryInterceptor()})))
intercept_i3status(proc, restarted, modify)
def setUp(self):
super(CloneVMTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.qapp = Qubes()
# mock up the Create VM Thread to avoid changing system state
self.patcher_thread = unittest.mock.patch(
'qubesmanager.common_threads.CloneVMThread')
self.mock_thread = self.patcher_thread.start()
self.addCleanup(self.patcher_thread.stop)
# mock the progress dialog to speed testing up
self.patcher_progress = unittest.mock.patch(
'PyQt5.QtWidgets.QProgressDialog')
self.mock_progress = self.patcher_progress.start()
self.addCleanup(self.patcher_progress.stop)
# mock the progress dialog to speed testing up
self.patcher_warning = unittest.mock.patch(
'PyQt5.QtWidgets.QMessageBox.warning')
self.mock_warning = self.patcher_warning.start()
self.addCleanup(self.patcher_warning.stop)
self.dialog = clone_vm.CloneVMDlg(self.qtapp, self.qapp)
def validate_existing_size(self):
"""This method checks for existing private volume size and new
values in the config.json"""
assert "vmsizes" in self.config
assert "sd_app" in self.config["vmsizes"]
assert "sd_log" in self.config["vmsizes"]
assert isinstance(self.config["vmsizes"]["sd_app"], int), \
"Private volume size of sd-app must be an integer value."
assert isinstance(self.config["vmsizes"]["sd_log"], int), \
"Private volume size of sd-log must be an integer value."
app = Qubes()
if "sd-app" in app.domains:
vm = app.domains["sd-app"]
vol = vm.volumes["private"]
assert (
vol.size <=
self.config["vmsizes"]["sd_app"] * 1024 * 1024 * 1024
), "sd-app private volume is already bigger than configuration."
if "sd-log" in app.domains:
vm = app.domains["sd-log"]
vol = vm.volumes["private"]
assert (
vol.size <=
self.config["vmsizes"]["sd_log"] * 1024 * 1024 * 1024
), "sd-log private volume is already bigger than configuration."
def setUp(self):
super(BackupTest, self).setUp()
# mock up nonexistence of saved backup settings
self.patcher_open = unittest.mock.patch('builtins.open')
self.mock_open = self.patcher_open.start()
self.mock_open.side_effect = FileNotFoundError()
self.addCleanup(self.patcher_open.stop)
# mock up the Backup Thread to avoid accidentally changing system state
self.patcher_thread = unittest.mock.patch(
'qubesmanager.backup.BackupThread')
self.mock_thread = self.patcher_thread.start()
self.addCleanup(self.patcher_thread.stop)
self.qapp = Qubes()
self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"])
self.dispatcher = events.EventsDispatcher(self.qapp)
self.loop = quamash.QEventLoop(self.qtapp)
self.dialog = backup.BackupVMsWindow(self.qtapp, self.qapp,
self.dispatcher)
self.dialog.show()
def setUp(self):
self.app = Qubes()
self.vm = self.app.domains[self.vm_name]
# self._reboot()
if self.vm.is_running():
pass
else:
self.vm.start()
def __init__(self):
self.qubes_app = Qubes()
self.pools = []
self.total_size = 0
self.used_size = 0
self.warning_message = []
self.__populate_pools()
def main():
qubes_app = Qubes()
qt_app = QtGui.QApplication(sys.argv)
log_window = LogDialog(qubes_app, sys.argv[1])
log_window.show()
qt_app.exec_()
qt_app.exit()
def parse_args():
app = Qubes()
names = [x.name for x in app.domains if x.klass != 'AdminVM']
ap = ArgumentParser()
ap.add_argument('vm', choices=names)
ap.add_argument('--rules', default=DEFAULT_RULES, nargs='*')
args = ap.parse_args()
args.vm = next(x for x in app.domains if x.name == args.vm)
return args
def setUp(self):
self.app = Qubes()
with open("config.json") as c:
config = json.load(c)
if 'environment' not in config:
config['environment'] = 'dev'
if config['environment'] == 'prod':
self.apt_url = FPF_APT_SOURCES_BUSTER
else:
self.apt_url = FPF_APT_SOURCES_BUSTER_DEV
def setUp(self):
self.app = Qubes()
with open("config.json") as c:
config = json.load(c)
if "environment" not in config:
config["environment"] = "dev"
if config["environment"] == "prod":
self.apt_url = FPF_APT_SOURCES_BUSTER
else:
self.apt_url = FPF_APT_SOURCES_BUSTER_DEV
def setUp(self):
super(VMSettingsTest, self).setUp()
self.mock_qprogress = unittest.mock.patch('PyQt4.QtGui.QProgressDialog')
self.mock_qprogress.start()
self.addCleanup(self.mock_qprogress.stop)
self.qapp = Qubes()
self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"])
self.loop = quamash.QEventLoop(self.qtapp)
def setUp(self):
super(BackupTest, self).setUp()
# mock up nonexistence of saved backup settings
self.patcher = unittest.mock.patch('builtins.open')
self.mock_open = self.patcher.start()
self.mock_open.side_effect = FileNotFoundError()
self.addCleanup(self.patcher.stop)
self.qapp = Qubes()
self.qtapp = QtGui.QApplication(sys.argv)
self.dialog = backup_gui.BackupVMsWindow(self.qtapp, self.qapp)
def setUp(self):
super(QubeManagerTest, self).setUp()
# # todo: mockup no settings file
# self.patcher = unittest.mock.patch('builtins.open')
# self.mock_open = self.patcher.start()
# self.mock_open.side_effect = FileNotFoundError()
# self.addCleanup(self.patcher.stop)
self.qapp = Qubes()
self.qtapp = QtGui.QApplication(sys.argv)
self.dialog = qube_manager.VmManagerWindow(self.qtapp, self.qapp)
def setUp(self):
super(GlobalSettingsTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.qapp = Qubes()
self.dialog = global_settings.GlobalSettingsWindow(
self.qtapp, self.qapp)
self.setattr_patcher = unittest.mock.patch.object(
type(self.dialog.qubes_app), "__setattr__")
self.setattr_mock = self.setattr_patcher.start()
self.addCleanup(self.setattr_patcher.stop)
def setUp(self):
super(GlobalSettingsTest, self).setUp()
self.qapp = Qubes()
self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"])
self.loop = quamash.QEventLoop(self.qtapp)
self.dialog = global_settings.GlobalSettingsWindow(self.qtapp,
self.qapp)
self.setattr_patcher = unittest.mock.patch.object(
type(self.dialog.qvm_collection), "__setattr__")
self.setattr_mock = self.setattr_patcher.start()
self.addCleanup(self.setattr_patcher.stop)
def setUp(self):
super(VMSettingsTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.mock_qprogress = unittest.mock.patch(
'PyQt5.QtWidgets.QProgressDialog')
self.mock_qprogress.start()
self.addCleanup(self.mock_qprogress.stop)
self.qapp = Qubes()
if "test-vm" in self.qapp.domains:
del self.qapp.domains["test-vm"]
def setUpClass(cls):
qapp = Qubes()
cls.dom0_name = "dom0"
cls.vms = []
cls.running_vm = None
for vm in qapp.domains:
if vm.klass != "AdminVM" and vm.is_running():
cls.running_vm = vm.name
if vm.klass != "AdminVM" and vm.get_disk_utilization() > 0:
cls.vms.append(vm.name)
if cls.running_vm and len(cls.vms) >= 3:
break
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(qubes_app, qt_app)
manager_window.show()
manager_window.update_table()
qt_app.exec_()
def main():
qtapp = QtGui.QApplication(sys.argv)
qtapp.setOrganizationName("The Qubes Project")
qtapp.setOrganizationDomain("http://qubes-os.org")
qtapp.setApplicationName("Qubes Global Settings")
sys.excepthook = handle_exception
app = Qubes()
global_window = GlobalSettingsWindow(qtapp, app)
global_window.show()
qtapp.exec_()
qtapp.exit()
def main():
qt_app = QtWidgets.QApplication(sys.argv)
qt_app.setOrganizationName("The Qubes Project")
qt_app.setOrganizationDomain("http://qubes-os.org")
qt_app.setApplicationName("Qubes Restore VMs")
sys.excepthook = handle_exception
qubes_app = Qubes()
restore_window = RestoreVMsWindow(qt_app, qubes_app)
restore_window.show()
qt_app.exec_()
qt_app.exit()
def main():
qt_app = QtGui.QApplication(sys.argv)
qt_app.setOrganizationName("The Qubes Project")
qt_app.setOrganizationDomain("http://qubes-os.org")
qt_app.setApplicationName("Qubes Backup VMs")
sys.excepthook = handle_exception
app = Qubes()
backup_window = BackupVMsWindow(qt_app, app)
backup_window.show()
qt_app.exec_()
qt_app.exit()
def setUp(self):
super(NewVmTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.qapp = Qubes()
# mock up the Create VM Thread to avoid changing system state
self.patcher_thread = unittest.mock.patch(
'qubesmanager.create_new_vm.CreateVMThread')
self.mock_thread = self.patcher_thread.start()
self.addCleanup(self.patcher_thread.stop)
# mock the progress dialog to speed testing up
self.patcher_progress = unittest.mock.patch(
'PyQt5.QtWidgets.QProgressDialog')
self.mock_progress = self.patcher_progress.start()
self.addCleanup(self.patcher_progress.stop)
self.dialog = create_new_vm.NewVmDlg(self.qtapp, self.qapp)
def __init__(self, **properties):
super().__init__(**properties)
self.pool_warned = False
self.vms_warned = set()
self.qubes_app = Qubes()
self.set_application_id("org.qubes.qui.tray.DiskSpace")
self.register()
prefs_action = Gio.SimpleAction.new("prefs", GLib.VariantType.new("s"))
prefs_action.connect("activate", launch_preferences_dialog)
self.add_action(prefs_action)
self.icon = Gtk.StatusIcon()
self.icon.connect('button-press-event', self.make_menu)
self.refresh_icon()
GObject.timeout_add_seconds(120, self.refresh_icon)
Gtk.main()
def __init__(self, **properties):
super().__init__(**properties)
self.qubes_app: Qubes = Qubes()
self.set_application_id("org.qubes.qui.tray.RemoteSupport")
self.register()
# load objects
self.builder: Gtk.Builder = Gtk.Builder()
self.builder.add_from_file(pkg_resources.resource_filename(
__name__, 'remote_gui.glade'))
# ask window
self.ask_window: AskWindow = AskWindow(
self.builder, self.qubes_app, self)
self.ask_window.ok_button.connect("clicked", self.start_remote)
self.ask_window.cancel_button.connect("clicked", self.exit_app)
# progress window
self.progress_window: ProgressWindow = ProgressWindow(
self.builder, self.qubes_app, self)
self.progress_window.abort_button.connect("clicked", self.exit_app)
# status icon
self.status_icon: RemoteSupportIcon = RemoteSupportIcon(
self.qubes_app, self.exit_app)
self.start_process: typing.Optional[subprocess.Popen] = None
self.current_window: typing.Optional[Gtk.Dialog] = None
self.ask_window.ask_dialog.show()
self.vm_name: typing.Optional[str] = None
self.aborted = False
Gtk.main()
class GlobalSettingsTest(unittest.TestCase):
def setUp(self):
super(GlobalSettingsTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.qapp = Qubes()
self.dialog = global_settings.GlobalSettingsWindow(
self.qtapp, self.qapp)
self.setattr_patcher = unittest.mock.patch.object(
type(self.dialog.qubes_app), "__setattr__")
self.setattr_mock = self.setattr_patcher.start()
self.addCleanup(self.setattr_patcher.stop)
def test_00_settings_started(self):
# non-empty drop-downs
self.assertNotEqual(self.dialog.default_kernel_combo.currentText(), "",
"Default kernel not listed")
self.assertNotEqual(self.dialog.default_netvm_combo.currentText(), "",
"Default netVM not listed")
self.assertNotEqual(self.dialog.default_template_combo.currentText(),
"", "Default template not listed")
self.assertNotEqual(self.dialog.clock_vm_combo.currentText(), "",
"ClockVM not listed")
self.assertNotEqual(self.dialog.update_vm_combo.currentText(), "",
"UpdateVM for dom0 not listed")
self.assertNotEqual(self.dialog.default_dispvm_combo.currentText(), "",
"Default DispVM not listed")
# not empty memory settings
self.assertTrue(
len(self.dialog.min_vm_mem.text()) > 4, "Too short min mem value")
self.assertTrue(
len(self.dialog.dom0_mem_boost.text()) > 4,
"Too short dom0 mem boost value")
def test_01_load_correct_defs(self):
# correctly selected default template
selected_default_template = \
self.dialog.default_template_combo.currentText()
self.assertTrue(
selected_default_template.startswith(
str(getattr(self.qapp, 'default_template', '(none)'))),
"Incorrect default template loaded")
# correctly selected default NetVM
selected_default_netvm = self.dialog.default_netvm_combo.currentText()
self.assertTrue(
selected_default_netvm.startswith(
str(getattr(self.qapp, 'default_netvm', '(none)'))),
"Incorrect default netVM loaded")
# correctly selected default kernel
selected_default_kernel = self.dialog.default_kernel_combo.currentText(
)
self.assertTrue(
selected_default_kernel.startswith(
str(getattr(self.qapp, 'default_kernel', '(none)'))),
"Incorrect default kernel loaded")
# correct ClockVM
selected_clockvm = self.dialog.clock_vm_combo.currentText()
correct_clockvm = str(getattr(self.qapp, 'clockvm', "(none)"))
self.assertTrue(selected_clockvm.startswith(correct_clockvm),
"Incorrect clockVM loaded")
# correct updateVM
selected_updatevm = self.dialog.update_vm_combo.currentText()
correct_updatevm = str(getattr(self.qapp, 'updatevm', "(none)"))
self.assertTrue(selected_updatevm.startswith(correct_updatevm),
"Incorrect updateVm loaded")
# correct defaultDispVM
selected_default_dispvm = self.dialog.default_dispvm_combo.currentText(
)
current_default_dispvm = getattr(self.qapp, 'default_dispvm', None)
if current_default_dispvm is None:
correct_default_dispvm = "(none)"
else:
correct_default_dispvm = str(current_default_dispvm)
self.assertTrue(
selected_default_dispvm.startswith(correct_default_dispvm),
"Incorrect defaultDispVM loaded")
# update vm status
self.assertEqual(self.qapp.check_updates_vm,
self.dialog.updates_vm.isChecked(),
"Incorrect check qube updates value loaded")
def test_02_dom0_updates_load(self):
# check dom0 updates
dom0_updates = self.qapp.domains['dom0'].features.get(
'service.qubes-update-check', True)
self.assertEqual(bool(dom0_updates),
self.dialog.updates_dom0.isChecked(),
"Incorrect dom0 updates value")
def __set_noncurrent(self, widget):
if widget.count() < 2:
self.skipTest("not enough choices for " + widget.objectName())
widget.setCurrentIndex(0)
while widget.currentText().endswith("(current)") \
or widget.currentText().startswith("(none)"):
widget.setCurrentIndex(widget.currentIndex() + 1)
return widget.currentData()
def __set_none(self, widget):
widget.setCurrentIndex(0)
while not widget.currentText().startswith("(none)"):
if widget.currentIndex() == widget.count():
self.skipTest("none not available for " + widget.objectName())
widget.setCurrentIndex(widget.currentIndex() + 1)
def __click_ok(self):
okwidget = self.dialog.buttonBox.button(self.dialog.buttonBox.Ok)
QtTest.QTest.mouseClick(okwidget, QtCore.Qt.LeftButton)
def __click_cancel(self):
cancelwidget = self.dialog.buttonBox.button(
self.dialog.buttonBox.Cancel)
QtTest.QTest.mouseClick(cancelwidget, QtCore.Qt.LeftButton)
def test_03_nothing_changed_ok(self):
self.__click_ok()
self.assertEqual(self.setattr_mock.call_count, 0,
"Changes occurred despite no changes being made")
def test_04_nothing_changed_cancel(self):
self.__click_cancel()
self.assertEqual(self.setattr_mock.call_count, 0,
"Changes occurred despite no changes being made")
def test_10_set_update_vm(self):
new_updatevm_name = self.__set_noncurrent(self.dialog.update_vm_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('updatevm',
new_updatevm_name)
def test_11_set_update_vm_to_none(self):
self.__set_none(self.dialog.update_vm_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('updatevm', None)
def test_20_set_clock_vm(self):
new_clockvm_name = self.__set_noncurrent(self.dialog.clock_vm_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('clockvm', new_clockvm_name)
def test_21_set_clock_vm_to_none(self):
self.__set_none(self.dialog.clock_vm_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('clockvm', None)
def test_30_set_default_netvm(self):
new_netvm_name = self.__set_noncurrent(self.dialog.default_netvm_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('default_netvm',
new_netvm_name)
def test_31_set_default_netvm_to_none(self):
self.__set_none(self.dialog.default_netvm_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('default_netvm', None)
def test_40_set_default_template(self):
new_def_template_name = self.__set_noncurrent(
self.dialog.default_template_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('default_template',
new_def_template_name)
def test_50_set_default_kernel(self):
new_def_kernel_name = self.__set_noncurrent(
self.dialog.default_kernel_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('default_kernel',
new_def_kernel_name)
def test_51_set_default_kernel_to_none(self):
self.__set_none(self.dialog.default_kernel_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('default_kernel', None)
def test_60_set_dom0_updates_true(self):
current_state = self.dialog.updates_dom0.isChecked()
self.dialog.updates_dom0.setChecked(not current_state)
with unittest.mock.patch.object(
type(self.dialog.qubes_app.domains['dom0'].features),
'__setitem__') as mock_features:
self.__click_ok()
mock_features.assert_called_once_with('service.qubes-update-check',
not current_state)
def test_70_change_vm_updates(self):
current_state = self.dialog.updates_vm.isChecked()
self.dialog.updates_vm.setChecked(not current_state)
self.__click_ok()
self.setattr_mock.assert_called_once_with('check_updates_vm',
not current_state)
@unittest.mock.patch("PyQt5.QtWidgets.QMessageBox.question",
return_value=QtWidgets.QMessageBox.Yes)
@unittest.mock.patch('qubesadmin.features.Features.__setitem__')
def test_72_set_all_vms_true(self, mock_features, msgbox):
QtTest.QTest.mouseClick(self.dialog.enable_updates_all,
QtCore.Qt.LeftButton)
self.assertEqual(msgbox.call_count, 1,
"Wrong number of confirmation window calls")
call_list_expected = \
[unittest.mock.call('service.qubes-update-check', True) for vm
in self.qapp.domains if vm.klass != 'AdminVM']
self.assertListEqual(call_list_expected, mock_features.call_args_list)
@unittest.mock.patch("PyQt5.QtWidgets.QMessageBox.question",
return_value=QtWidgets.QMessageBox.Yes)
@unittest.mock.patch('qubesadmin.features.Features.__setitem__')
def test_73_set_all_vms_false(self, mock_features, msgbox):
QtTest.QTest.mouseClick(self.dialog.disable_updates_all,
QtCore.Qt.LeftButton)
self.assertEqual(msgbox.call_count, 1,
"Wrong number of confirmation window calls")
call_list_expected = \
[unittest.mock.call('service.qubes-update-check', False) for vm
in self.qapp.domains if vm.klass != 'AdminVM']
self.assertListEqual(call_list_expected, mock_features.call_args_list)
def test_80_set_default_dispvm(self):
new_dispvm_name = self.__set_noncurrent(
self.dialog.default_dispvm_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('default_dispvm',
new_dispvm_name)
def test_81_set_default_dispvm_to_none(self):
self.__set_none(self.dialog.default_dispvm_combo)
self.__click_ok()
self.setattr_mock.assert_called_once_with('default_dispvm', None)
@unittest.mock.patch.object(
type(Qubes()),
'__getattr__',
side_effect=(lambda x: False if x == 'check_updates_vm' else None))
def test_90_test_all_set_none(self, mock_qubes):
mock_qubes.configure_mock()
self.dialog = global_settings.GlobalSettingsWindow(
self.qtapp, self.qapp)
self.assertEqual(self.dialog.update_vm_combo.currentText(),
"(none) (current)",
"UpdateVM displays as none incorrectly")
self.assertEqual(self.dialog.clock_vm_combo.currentText(),
"(none) (current)",
"ClockVM displays as none incorrectly")
self.assertEqual(self.dialog.default_netvm_combo.currentText(),
"(none) (current)",
"Default NetVM displays as none incorrectly")
self.assertEqual(self.dialog.default_template_combo.currentText(),
"(none) (current)",
"Default template displays as none incorrectly")
self.assertEqual(self.dialog.default_kernel_combo.currentText(),
"(none) (current)",
"Defautl kernel displays as none incorrectly")
self.assertEqual(self.dialog.default_dispvm_combo.currentText(),
"(none) (current)",
"Default DispVM displays as none incorrectly")
def setUp(self):
self.app = Qubes()
with open("config.json") as c:
self.config = json.load(c)
def setUp(self):
super(BackupUtilsTest, self).setUp()
self.qapp = Qubes()
self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"])
self.loop = quamash.QEventLoop(self.qtapp)
def setUp(self):
self.app = Qubes()