qube_manager.py 50 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350
  1. #!/usr/bin/python3
  2. #
  3. # The Qubes OS Project, http://www.qubes-os.org
  4. #
  5. # Copyright (C) 2012 Agnieszka Kostrzewa <agnieszka.kostrzewa@gmail.com>
  6. # Copyright (C) 2012 Marek Marczykowski-Górecki
  7. # <marmarek@invisiblethingslab.com>
  8. # Copyright (C) 2017 Wojtek Porczyk <woju@invisiblethingslab.com>
  9. #
  10. # This program is free software; you can redistribute it and/or
  11. # modify it under the terms of the GNU General Public License
  12. # as published by the Free Software Foundation; either version 2
  13. # of the License, or (at your option) any later version.
  14. #
  15. # This program is distributed in the hope that it will be useful,
  16. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. # GNU General Public License for more details.
  19. #
  20. # You should have received a copy of the GNU Lesser General Public License along
  21. # with this program; if not, see <http://www.gnu.org/licenses/>.
  22. #
  23. #
  24. import sys
  25. import os
  26. import os.path
  27. import subprocess
  28. import time
  29. from datetime import datetime, timedelta
  30. import traceback
  31. import threading
  32. import quamash
  33. import asyncio
  34. from contextlib import suppress
  35. from qubesadmin import Qubes
  36. from qubesadmin import exc
  37. from qubesadmin import utils
  38. from qubesadmin import events
  39. from PyQt4 import QtGui # pylint: disable=import-error
  40. from PyQt4 import QtCore # pylint: disable=import-error
  41. from qubesmanager.about import AboutDialog
  42. from . import ui_qubemanager # pylint: disable=no-name-in-module
  43. from . import thread_monitor
  44. from . import table_widgets
  45. from . import settings
  46. from . import global_settings
  47. from . import restore
  48. from . import backup
  49. from . import log_dialog
  50. from . import utils as manager_utils
  51. class SearchBox(QtGui.QLineEdit):
  52. def __init__(self, parent=None):
  53. super(SearchBox, self).__init__(parent)
  54. self.focusing = False
  55. def focusInEvent(self, e): # pylint: disable=invalid-name
  56. super(SearchBox, self).focusInEvent(e)
  57. self.selectAll()
  58. self.focusing = True
  59. def mousePressEvent(self, e): # pylint: disable=invalid-name
  60. super(SearchBox, self).mousePressEvent(e)
  61. if self.focusing:
  62. self.selectAll()
  63. self.focusing = False
  64. class VmRowInTable:
  65. # pylint: disable=too-few-public-methods
  66. def __init__(self, vm, row_no, table):
  67. self.vm = vm
  68. # TODO: replace a various different widgets with a more generic
  69. # VmFeatureWidget or VMPropertyWidget
  70. table_widgets.row_height = VmManagerWindow.row_height
  71. table.setRowHeight(row_no, VmManagerWindow.row_height)
  72. self.type_widget = table_widgets.VmTypeWidget(vm)
  73. table.setCellWidget(row_no, VmManagerWindow.columns_indices['Type'],
  74. self.type_widget)
  75. table.setItem(row_no, VmManagerWindow.columns_indices['Type'],
  76. self.type_widget.table_item)
  77. self.label_widget = table_widgets.VmLabelWidget(vm)
  78. table.setCellWidget(row_no, VmManagerWindow.columns_indices['Label'],
  79. self.label_widget)
  80. table.setItem(row_no, VmManagerWindow.columns_indices['Label'],
  81. self.label_widget.table_item)
  82. self.name_widget = table_widgets.VmNameItem(vm)
  83. table.setItem(row_no, VmManagerWindow.columns_indices['Name'],
  84. self.name_widget)
  85. self.info_widget = table_widgets.VmInfoWidget(vm)
  86. table.setCellWidget(row_no, VmManagerWindow.columns_indices['State'],
  87. self.info_widget)
  88. table.setItem(row_no, VmManagerWindow.columns_indices['State'],
  89. self.info_widget.table_item)
  90. self.template_widget = table_widgets.VmTemplateItem(vm)
  91. table.setItem(row_no, VmManagerWindow.columns_indices['Template'],
  92. self.template_widget)
  93. self.netvm_widget = table_widgets.VmNetvmItem(vm)
  94. table.setItem(row_no, VmManagerWindow.columns_indices['NetVM'],
  95. self.netvm_widget)
  96. self.size_widget = table_widgets.VmSizeOnDiskItem(vm)
  97. table.setItem(row_no, VmManagerWindow.columns_indices['Size'],
  98. self.size_widget)
  99. self.internal_widget = table_widgets.VmInternalItem(vm)
  100. table.setItem(row_no, VmManagerWindow.columns_indices['Internal'],
  101. self.internal_widget)
  102. self.ip_widget = table_widgets.VmIPItem(vm)
  103. table.setItem(row_no, VmManagerWindow.columns_indices['IP'],
  104. self.ip_widget)
  105. self.include_in_backups_widget = \
  106. table_widgets.VmIncludeInBackupsItem(vm)
  107. table.setItem(row_no, VmManagerWindow.columns_indices[
  108. 'Backups'], self.include_in_backups_widget)
  109. self.last_backup_widget = table_widgets.VmLastBackupItem(vm)
  110. table.setItem(row_no, VmManagerWindow.columns_indices[
  111. 'Last backup'], self.last_backup_widget)
  112. self.table = table
  113. def update(self, update_size_on_disk=False):
  114. """
  115. Update info in a single VM row
  116. :param update_size_on_disk: should disk utilization be updated? the
  117. widget will extract the data from VM object
  118. :return: None
  119. """
  120. try:
  121. self.info_widget.update_vm_state()
  122. self.template_widget.update()
  123. self.netvm_widget.update()
  124. self.internal_widget.update()
  125. self.ip_widget.update()
  126. self.include_in_backups_widget.update()
  127. self.last_backup_widget.update()
  128. if update_size_on_disk:
  129. self.size_widget.update()
  130. except exc.QubesPropertyAccessError:
  131. pass
  132. except exc.QubesDaemonNoResponseError:
  133. # TODO: this will be fixed by a rewrite moving the event system to
  134. # AdminAPI
  135. pass
  136. #force re-sorting
  137. self.table.setSortingEnabled(True)
  138. vm_shutdown_timeout = 20000 # in msec
  139. vm_restart_check_timeout = 1000 # in msec
  140. class VmShutdownMonitor(QtCore.QObject):
  141. def __init__(self, vm, shutdown_time=vm_shutdown_timeout,
  142. check_time=vm_restart_check_timeout,
  143. and_restart=False, caller=None):
  144. QtCore.QObject.__init__(self)
  145. self.vm = vm
  146. self.shutdown_time = shutdown_time
  147. self.check_time = check_time
  148. self.and_restart = and_restart
  149. self.shutdown_started = datetime.now()
  150. self.caller = caller
  151. def restart_vm_if_needed(self):
  152. if self.and_restart and self.caller:
  153. self.caller.start_vm(self.vm)
  154. def check_again_later(self):
  155. # noinspection PyTypeChecker,PyCallByClass
  156. QtCore.QTimer.singleShot(self.check_time, self.check_if_vm_has_shutdown)
  157. def timeout_reached(self):
  158. actual = datetime.now() - self.shutdown_started
  159. allowed = timedelta(milliseconds=self.shutdown_time)
  160. return actual > allowed
  161. def check_if_vm_has_shutdown(self):
  162. vm = self.vm
  163. vm_is_running = vm.is_running()
  164. try:
  165. vm_start_time = datetime.fromtimestamp(float(vm.start_time))
  166. except (AttributeError, TypeError, ValueError):
  167. vm_start_time = None
  168. if vm_is_running and vm_start_time \
  169. and vm_start_time < self.shutdown_started:
  170. if self.timeout_reached():
  171. reply = QtGui.QMessageBox.question(
  172. None, self.tr("Qube Shutdown"),
  173. self.tr(
  174. "The Qube <b>'{0}'</b> hasn't shutdown within the last "
  175. "{1} seconds, do you want to kill it?<br>").format(
  176. vm.name, self.shutdown_time / 1000),
  177. self.tr("Kill it!"),
  178. self.tr("Wait another {0} seconds...").format(
  179. self.shutdown_time / 1000))
  180. if reply == 0:
  181. try:
  182. vm.kill()
  183. except exc.QubesVMNotStartedError:
  184. # the VM shut down while the user was thinking about
  185. # shutting it down
  186. pass
  187. self.restart_vm_if_needed()
  188. else:
  189. self.shutdown_started = datetime.now()
  190. self.check_again_later()
  191. else:
  192. self.check_again_later()
  193. else:
  194. if vm_is_running:
  195. # Due to unknown reasons, Xen sometimes reports that a domain
  196. # is running even though its start-up timestamp is not valid.
  197. # Make sure that "restart_vm_if_needed" is not called until
  198. # the domain has been completely shut down according to Xen.
  199. self.check_again_later()
  200. return
  201. self.restart_vm_if_needed()
  202. class VmManagerWindow(ui_qubemanager.Ui_VmManagerWindow, QtGui.QMainWindow):
  203. # pylint: disable=too-many-instance-attributes
  204. row_height = 30
  205. column_width = 200
  206. search = ""
  207. # suppress saving settings while initializing widgets
  208. settings_loaded = False
  209. columns_indices = {"Type": 0,
  210. "Label": 1,
  211. "Name": 2,
  212. "State": 3,
  213. "Template": 4,
  214. "NetVM": 5,
  215. "Size": 6,
  216. "Internal": 7,
  217. "IP": 8,
  218. "Backups": 9,
  219. "Last backup": 10,
  220. }
  221. def __init__(self, qt_app, qubes_app, dispatcher, parent=None):
  222. # pylint: disable=unused-argument
  223. super(VmManagerWindow, self).__init__()
  224. self.setupUi(self)
  225. self.manager_settings = QtCore.QSettings(self)
  226. self.qubes_app = qubes_app
  227. self.qt_app = qt_app
  228. self.searchbox = SearchBox()
  229. self.searchbox.setValidator(QtGui.QRegExpValidator(
  230. QtCore.QRegExp("[a-zA-Z0-9_-]*", QtCore.Qt.CaseInsensitive), None))
  231. self.searchContainer.addWidget(self.searchbox)
  232. self.connect(self.table, QtCore.SIGNAL("itemSelectionChanged()"),
  233. self.table_selection_changed)
  234. self.table.setColumnWidth(0, self.column_width)
  235. self.sort_by_column = "Type"
  236. self.sort_order = QtCore.Qt.AscendingOrder
  237. self.vms_list = []
  238. self.vms_in_table = {}
  239. self.frame_width = 0
  240. self.frame_height = 0
  241. self.columns_actions = {
  242. self.columns_indices["Type"]: self.action_vm_type,
  243. self.columns_indices["Label"]: self.action_label,
  244. self.columns_indices["Name"]: self.action_name,
  245. self.columns_indices["State"]: self.action_state,
  246. self.columns_indices["Template"]: self.action_template,
  247. self.columns_indices["NetVM"]: self.action_netvm,
  248. self.columns_indices["Size"]: self.action_size_on_disk,
  249. self.columns_indices["Internal"]: self.action_internal,
  250. self.columns_indices["IP"]: self
  251. .action_ip, self.columns_indices["Backups"]: self
  252. .action_backups, self.columns_indices["Last backup"]: self
  253. .action_last_backup
  254. }
  255. self.visible_columns_count = len(self.columns_indices)
  256. # Other columns get sensible default sizes, but those have only
  257. # icon content, and thus PyQt makes them too wide
  258. self.table.setColumnWidth(self.columns_indices["State"], 80)
  259. self.table.setColumnWidth(self.columns_indices["Label"], 40)
  260. self.table.setColumnWidth(self.columns_indices["Type"], 40)
  261. self.table.horizontalHeader().setResizeMode(
  262. QtGui.QHeaderView.Interactive)
  263. self.table.horizontalHeader().setStretchLastSection(True)
  264. self.table.horizontalHeader().setMinimumSectionSize(40)
  265. self.context_menu = QtGui.QMenu(self)
  266. self.context_menu.addAction(self.action_settings)
  267. self.context_menu.addAction(self.action_editfwrules)
  268. self.context_menu.addAction(self.action_appmenus)
  269. self.context_menu.addAction(self.action_set_keyboard_layout)
  270. self.context_menu.addSeparator()
  271. self.context_menu.addAction(self.action_updatevm)
  272. self.context_menu.addAction(self.action_run_command_in_vm)
  273. self.context_menu.addAction(self.action_resumevm)
  274. self.context_menu.addAction(self.action_startvm_tools_install)
  275. self.context_menu.addAction(self.action_pausevm)
  276. self.context_menu.addAction(self.action_shutdownvm)
  277. self.context_menu.addAction(self.action_restartvm)
  278. self.context_menu.addAction(self.action_killvm)
  279. self.context_menu.addSeparator()
  280. self.context_menu.addAction(self.action_clonevm)
  281. self.context_menu.addAction(self.action_removevm)
  282. self.context_menu.addSeparator()
  283. self.context_menu.addMenu(self.logs_menu)
  284. self.context_menu.addSeparator()
  285. self.tools_context_menu = QtGui.QMenu(self)
  286. self.tools_context_menu.addAction(self.action_toolbar)
  287. self.tools_context_menu.addAction(self.action_menubar)
  288. self.dom0_context_menu = QtGui.QMenu(self)
  289. self.dom0_context_menu.addAction(self.action_global_settings)
  290. self.dom0_context_menu.addAction(self.action_updatevm)
  291. self.dom0_context_menu.addSeparator()
  292. self.dom0_context_menu.addMenu(self.logs_menu)
  293. self.dom0_context_menu.addSeparator()
  294. self.connect(
  295. self.table.horizontalHeader(),
  296. QtCore.SIGNAL("sortIndicatorChanged(int, Qt::SortOrder)"),
  297. self.sort_indicator_changed)
  298. self.connect(self.table,
  299. QtCore.SIGNAL("customContextMenuRequested(const QPoint&)"),
  300. self.open_context_menu)
  301. self.connect(self.menubar,
  302. QtCore.SIGNAL("customContextMenuRequested(const QPoint&)"),
  303. lambda pos: self.open_tools_context_menu(self.menubar,
  304. pos))
  305. self.connect(self.toolbar,
  306. QtCore.SIGNAL("customContextMenuRequested(const QPoint&)"),
  307. lambda pos: self.open_tools_context_menu(self.toolbar,
  308. pos))
  309. self.connect(self.logs_menu, QtCore.SIGNAL("triggered(QAction *)"),
  310. self.show_log)
  311. self.connect(self.searchbox,
  312. QtCore.SIGNAL("textChanged(const QString&)"),
  313. self.do_search)
  314. self.table.setContentsMargins(0, 0, 0, 0)
  315. self.centralwidget.layout().setContentsMargins(0, 0, 0, 0)
  316. self.layout().setContentsMargins(0, 0, 0, 0)
  317. self.connect(self.action_menubar, QtCore.SIGNAL("toggled(bool)"),
  318. self.showhide_menubar)
  319. self.connect(self.action_toolbar, QtCore.SIGNAL("toggled(bool)"),
  320. self.showhide_toolbar)
  321. self.load_manager_settings()
  322. self.fill_table()
  323. self.update_size_on_disk = False
  324. self.shutdown_monitor = {}
  325. # Connect dbus events
  326. self.dispatcher = dispatcher
  327. dispatcher.add_handler('domain-pre-start',
  328. self.on_domain_status_changed)
  329. dispatcher.add_handler('domain-start', self.on_domain_status_changed)
  330. dispatcher.add_handler('domain-start-failed',
  331. self.on_domain_status_changed)
  332. dispatcher.add_handler('domain-stopped', self.on_domain_status_changed)
  333. dispatcher.add_handler('domain-shutdown', self.on_domain_status_changed)
  334. dispatcher.add_handler('domain-add', self.on_domain_added)
  335. dispatcher.add_handler('domain-delete', self.on_domain_removed)
  336. dispatcher.add_handler('property-set:*',
  337. self.on_domain_changed)
  338. dispatcher.add_handler('property-del:*',
  339. self.on_domain_changed)
  340. dispatcher.add_handler('property-load',
  341. self.on_domain_changed)
  342. # Check Updates Timer
  343. timer = QtCore.QTimer(self)
  344. timer.timeout.connect(self.check_updates)
  345. timer.start(1000 * 30) # 30s
  346. self.check_updates()
  347. def closeEvent(self, event):
  348. # pylint: disable=invalid-name
  349. # save window size at close
  350. self.manager_settings.setValue("window_size", self.size())
  351. event.accept()
  352. def check_updates(self):
  353. for vm in self.qubes_app.domains:
  354. if vm.klass in {'TemplateVM', 'StandaloneVM'}:
  355. try:
  356. self.vms_in_table[vm.qid].update()
  357. except exc.QubesException:
  358. # the VM might have vanished in the meantime
  359. pass
  360. def on_domain_added(self, submitter, event, **kwargs):
  361. self.table.setSortingEnabled(False)
  362. row_no = self.table.rowCount()
  363. self.table.setRowCount(row_no + 1)
  364. for vm in self.qubes_app.domains:
  365. if vm == kwargs['vm']:
  366. vm_row = VmRowInTable(vm, row_no, self.table)
  367. self.vms_in_table[vm.qid] = vm_row
  368. self.table.setSortingEnabled(True)
  369. self.showhide_vms()
  370. return
  371. # Never should reach here
  372. raise RuntimeError('Added domain not found')
  373. def on_domain_removed(self, submitter, event, **kwargs):
  374. row_to_delete = None
  375. qid_to_delete = None
  376. for qid, row in self.vms_in_table.items():
  377. if row.vm.name == kwargs['vm']:
  378. row_to_delete = row
  379. qid_to_delete = qid
  380. if not row_to_delete:
  381. return # for some reason, the VM was removed in some other way
  382. del self.vms_in_table[qid_to_delete]
  383. self.table.removeRow(row_to_delete.name_widget.row())
  384. def on_domain_status_changed(self, vm, event, **kwargs):
  385. self.vms_in_table[vm.qid].info_widget.update_vm_state()
  386. if vm == self.get_selected_vm():
  387. self.table_selection_changed()
  388. if vm.klass == 'TemplateVM':
  389. for row in self.vms_in_table:
  390. if row.vm.template == vm:
  391. row.info_widget.update_vm_state()
  392. def on_domain_changed(self, vm, event, **kwargs):
  393. self.vms_in_table[vm.qid].update()
  394. def load_manager_settings(self):
  395. # visible columns
  396. self.visible_columns_count = 0
  397. for col in self.columns_indices:
  398. col_no = self.columns_indices[col]
  399. visible = self.manager_settings.value(
  400. 'columns/%s' % col,
  401. defaultValue="true")
  402. self.columns_actions[col_no].setChecked(visible == "true")
  403. self.visible_columns_count += 1
  404. self.sort_by_column = str(
  405. self.manager_settings.value("view/sort_column",
  406. defaultValue=self.sort_by_column))
  407. self.sort_order = QtCore.Qt.SortOrder(
  408. self.manager_settings.value("view/sort_order",
  409. defaultValue=self.sort_order))
  410. self.table.sortItems(self.columns_indices[self.sort_by_column],
  411. self.sort_order)
  412. if not self.manager_settings.value("view/menubar_visible",
  413. defaultValue=True):
  414. self.action_menubar.setChecked(False)
  415. if not self.manager_settings.value("view/toolbar_visible",
  416. defaultValue=True):
  417. self.action_toolbar.setChecked(False)
  418. # load last window size
  419. self.resize(self.manager_settings.value("window_size",
  420. QtCore.QSize(1100, 600)))
  421. self.settings_loaded = True
  422. def get_vms_list(self):
  423. return [vm for vm in self.qubes_app.domains]
  424. def fill_table(self):
  425. progress = QtGui.QProgressDialog(
  426. self.tr(
  427. "Loading Qube Manager..."), "", 0, 0)
  428. progress.setWindowTitle(self.tr("Qube Manager"))
  429. progress.setWindowFlags(QtCore.Qt.Window |
  430. QtCore.Qt.WindowTitleHint |
  431. QtCore.Qt.CustomizeWindowHint)
  432. progress.setCancelButton(None)
  433. progress.setModal(True)
  434. progress.show()
  435. self.table.setSortingEnabled(False)
  436. vms_list = self.get_vms_list()
  437. vms_in_table = {}
  438. self.table.setRowCount(len(vms_list))
  439. row_no = 0
  440. for vm in vms_list:
  441. vm_row = VmRowInTable(vm, row_no, self.table)
  442. vms_in_table[vm.qid] = vm_row
  443. row_no += 1
  444. self.qt_app.processEvents()
  445. self.vms_list = vms_list
  446. self.vms_in_table = vms_in_table
  447. self.table.setSortingEnabled(True)
  448. progress.hide()
  449. def showhide_vms(self):
  450. if not self.search:
  451. for row_no in range(self.table.rowCount()):
  452. self.table.setRowHidden(row_no, False)
  453. else:
  454. for row_no in range(self.table.rowCount()):
  455. widget = self.table.cellWidget(row_no,
  456. self.columns_indices["State"])
  457. show = (self.search in widget.vm.name)
  458. self.table.setRowHidden(row_no, not show)
  459. @QtCore.pyqtSlot(str)
  460. def do_search(self, search):
  461. self.search = str(search)
  462. self.showhide_vms()
  463. # noinspection PyArgumentList
  464. @QtCore.pyqtSlot(name='on_action_search_triggered')
  465. def action_search_triggered(self):
  466. self.searchbox.setFocus()
  467. # noinspection PyPep8Naming
  468. def sort_indicator_changed(self, column, order):
  469. self.sort_by_column = [name for name in self.columns_indices if
  470. self.columns_indices[name] == column][0]
  471. self.sort_order = order
  472. if self.settings_loaded:
  473. self.manager_settings.setValue('view/sort_column',
  474. self.sort_by_column)
  475. self.manager_settings.setValue('view/sort_order', self.sort_order)
  476. self.manager_settings.sync()
  477. def table_selection_changed(self):
  478. vm = self.get_selected_vm()
  479. if vm is not None and vm in self.qubes_app.domains:
  480. # TODO: add boot from device to menu and add windows tools there
  481. # Update available actions:
  482. self.action_settings.setEnabled(vm.klass != 'AdminVM')
  483. self.action_removevm.setEnabled(
  484. vm.klass != 'AdminVM' and not vm.is_running())
  485. self.action_clonevm.setEnabled(vm.klass != 'AdminVM')
  486. self.action_resumevm.setEnabled(
  487. not vm.is_running() or vm.get_power_state() == "Paused")
  488. self.action_pausevm.setEnabled(
  489. vm.is_running() and vm.get_power_state() != "Paused"
  490. and vm.klass != 'AdminVM')
  491. self.action_shutdownvm.setEnabled(
  492. vm.is_running() and vm.get_power_state() != "Paused"
  493. and vm.klass != 'AdminVM')
  494. self.action_restartvm.setEnabled(
  495. vm.is_running() and vm.get_power_state() != "Paused"
  496. and vm.klass != 'AdminVM'
  497. and (vm.klass != 'DispVM' or not vm.auto_cleanup))
  498. self.action_killvm.setEnabled(
  499. (vm.get_power_state() == "Paused" or vm.is_running())
  500. and vm.klass != 'AdminVM')
  501. self.action_appmenus.setEnabled(
  502. vm.klass != 'AdminVM' and vm.klass != 'DispVM'
  503. and not vm.features.get('internal', False))
  504. self.action_editfwrules.setEnabled(vm.klass != 'AdminVM')
  505. self.action_updatevm.setEnabled(getattr(vm, 'updateable', False)
  506. or vm.qid == 0)
  507. self.action_run_command_in_vm.setEnabled(
  508. not vm.get_power_state() == "Paused" and vm.qid != 0)
  509. self.action_set_keyboard_layout.setEnabled(
  510. vm.qid != 0 and
  511. vm.get_power_state() != "Paused" and vm.is_running())
  512. else:
  513. self.action_settings.setEnabled(False)
  514. self.action_removevm.setEnabled(False)
  515. self.action_clonevm.setEnabled(False)
  516. self.action_resumevm.setEnabled(False)
  517. self.action_pausevm.setEnabled(False)
  518. self.action_shutdownvm.setEnabled(False)
  519. self.action_restartvm.setEnabled(False)
  520. self.action_killvm.setEnabled(False)
  521. self.action_appmenus.setEnabled(False)
  522. self.action_editfwrules.setEnabled(False)
  523. self.action_updatevm.setEnabled(False)
  524. self.action_run_command_in_vm.setEnabled(False)
  525. self.action_set_keyboard_layout.setEnabled(False)
  526. # noinspection PyArgumentList
  527. @QtCore.pyqtSlot(name='on_action_createvm_triggered')
  528. def action_createvm_triggered(self): # pylint: disable=no-self-use
  529. subprocess.check_call('qubes-vm-create')
  530. def get_selected_vm(self):
  531. # vm selection relies on the VmInfo widget's value used
  532. # for sorting by VM name
  533. row_index = self.table.currentRow()
  534. if row_index != -1:
  535. vm_item = self.table.item(row_index, self.columns_indices["Name"])
  536. # here is possible race with update_table timer so check
  537. # if really got the item
  538. if vm_item is None:
  539. return None
  540. qid = vm_item.qid
  541. assert self.vms_in_table[qid] is not None
  542. vm = self.vms_in_table[qid].vm
  543. return vm
  544. return None
  545. # noinspection PyArgumentList
  546. @QtCore.pyqtSlot(name='on_action_removevm_triggered')
  547. def action_removevm_triggered(self):
  548. # pylint: disable=no-else-return
  549. vm = self.get_selected_vm()
  550. dependencies = utils.vm_dependencies(self.qubes_app, vm)
  551. if dependencies:
  552. list_text = "<br>" + \
  553. manager_utils.format_dependencies_list(dependencies) + \
  554. "<br>"
  555. info_dialog = QtGui.QMessageBox(self)
  556. info_dialog.setWindowTitle(self.tr("Warning!"))
  557. info_dialog.setText(
  558. self.tr("This qube cannot be removed. It is used as:"
  559. " <br> {} <small>If you want to remove this qube, "
  560. "you should remove or change settings of each qube "
  561. "or setting that uses it.</small>").format(list_text))
  562. info_dialog.setModal(False)
  563. info_dialog.show()
  564. self.qt_app.processEvents()
  565. return
  566. (requested_name, ok) = QtGui.QInputDialog.getText(
  567. None, self.tr("Qube Removal Confirmation"),
  568. self.tr("Are you sure you want to remove the Qube <b>'{0}'</b>"
  569. "?<br> All data on this Qube's private storage will be "
  570. "lost!<br><br>Type the name of the Qube (<b>{1}</b>) below "
  571. "to confirm:").format(vm.name, vm.name))
  572. if not ok:
  573. # user clicked cancel
  574. return
  575. if requested_name != vm.name:
  576. # name did not match
  577. QtGui.QMessageBox.warning(
  578. None,
  579. self.tr("Qube removal confirmation failed"),
  580. self.tr(
  581. "Entered name did not match! Not removing "
  582. "{0}.").format(vm.name))
  583. return
  584. else:
  585. # remove the VM
  586. t_monitor = thread_monitor.ThreadMonitor()
  587. thread = threading.Thread(target=self.do_remove_vm,
  588. args=(vm, self.qubes_app, t_monitor))
  589. thread.daemon = True
  590. thread.start()
  591. progress = QtGui.QProgressDialog(
  592. self.tr(
  593. "Removing Qube: <b>{0}</b>...").format(vm.name), "", 0, 0)
  594. progress.setWindowFlags(QtCore.Qt.Window |
  595. QtCore.Qt.WindowTitleHint |
  596. QtCore.Qt.CustomizeWindowHint)
  597. progress.setCancelButton(None)
  598. progress.setModal(True)
  599. progress.show()
  600. while not t_monitor.is_finished():
  601. self.qt_app.processEvents()
  602. time.sleep(0.1)
  603. progress.hide()
  604. if t_monitor.success:
  605. pass
  606. else:
  607. QtGui.QMessageBox.warning(None, self.tr("Error removing Qube!"),
  608. self.tr("ERROR: {0}").format(
  609. t_monitor.error_msg))
  610. @staticmethod
  611. def do_remove_vm(vm, qubes_app, t_monitor):
  612. try:
  613. del qubes_app.domains[vm.name]
  614. except exc.QubesException as ex:
  615. t_monitor.set_error_msg(str(ex))
  616. t_monitor.set_finished()
  617. # noinspection PyArgumentList
  618. @QtCore.pyqtSlot(name='on_action_clonevm_triggered')
  619. def action_clonevm_triggered(self):
  620. vm = self.get_selected_vm()
  621. name_number = 1
  622. name_format = vm.name + '-clone-%d'
  623. while name_format % name_number in self.qubes_app.domains.keys():
  624. name_number += 1
  625. (clone_name, ok) = QtGui.QInputDialog.getText(
  626. self, self.tr('Qubes clone Qube'),
  627. self.tr('Enter name for Qube <b>{}</b> clone:').format(vm.name),
  628. text=(name_format % name_number))
  629. if not ok or clone_name == "":
  630. return
  631. t_monitor = thread_monitor.ThreadMonitor()
  632. thread = threading.Thread(target=self.do_clone_vm,
  633. args=(vm, self.qubes_app,
  634. clone_name, t_monitor))
  635. thread.daemon = True
  636. thread.start()
  637. progress = QtGui.QProgressDialog(
  638. self.tr("Cloning Qube <b>{0}</b> to <b>{1}</b>...").format(
  639. vm.name, clone_name), "", 0, 0)
  640. progress.setWindowFlags(QtCore.Qt.Window |
  641. QtCore.Qt.WindowTitleHint |
  642. QtCore.Qt.CustomizeWindowHint)
  643. progress.setCancelButton(None)
  644. progress.setModal(True)
  645. progress.show()
  646. while not t_monitor.is_finished():
  647. self.qt_app.processEvents()
  648. time.sleep(0.2)
  649. progress.hide()
  650. if not t_monitor.success:
  651. QtGui.QMessageBox.warning(
  652. None,
  653. self.tr("Error while cloning Qube"),
  654. self.tr("Exception while cloning:<br>{0}").format(
  655. t_monitor.error_msg))
  656. @staticmethod
  657. def do_clone_vm(src_vm, qubes_app, dst_name, t_monitor):
  658. dst_vm = None
  659. try:
  660. dst_vm = qubes_app.clone_vm(src_vm, dst_name)
  661. except exc.QubesException as ex:
  662. t_monitor.set_error_msg(str(ex))
  663. if dst_vm:
  664. pass
  665. t_monitor.set_finished()
  666. # noinspection PyArgumentList
  667. @QtCore.pyqtSlot(name='on_action_resumevm_triggered')
  668. def action_resumevm_triggered(self):
  669. vm = self.get_selected_vm()
  670. if vm.get_power_state() in ["Paused", "Suspended"]:
  671. try:
  672. vm.unpause()
  673. self.vms_in_table[vm.qid].update()
  674. self.table_selection_changed()
  675. except exc.QubesException as ex:
  676. QtGui.QMessageBox.warning(
  677. None, self.tr("Error unpausing Qube!"),
  678. self.tr("ERROR: {0}").format(ex))
  679. return
  680. self.start_vm(vm)
  681. def start_vm(self, vm):
  682. if vm.is_running():
  683. return
  684. t_monitor = thread_monitor.ThreadMonitor()
  685. thread = threading.Thread(target=self.do_start_vm,
  686. args=(vm, t_monitor))
  687. thread.daemon = True
  688. thread.start()
  689. while not t_monitor.is_finished():
  690. self.qt_app.processEvents()
  691. time.sleep(0.1)
  692. if not t_monitor.success:
  693. QtGui.QMessageBox.warning(
  694. None,
  695. self.tr("Error starting Qube!"),
  696. self.tr("ERROR: {0}").format(t_monitor.error_msg))
  697. @staticmethod
  698. def do_start_vm(vm, t_monitor):
  699. try:
  700. vm.start()
  701. except exc.QubesException as ex:
  702. t_monitor.set_error_msg(str(ex))
  703. t_monitor.set_finished()
  704. return
  705. t_monitor.set_finished()
  706. # noinspection PyArgumentList
  707. @QtCore.pyqtSlot(name='on_action_startvm_tools_install_triggered')
  708. # TODO: replace with boot from device
  709. def action_startvm_tools_install_triggered(self):
  710. # pylint: disable=invalid-name
  711. pass
  712. @QtCore.pyqtSlot(name='on_action_pausevm_triggered')
  713. def action_pausevm_triggered(self):
  714. vm = self.get_selected_vm()
  715. try:
  716. vm.pause()
  717. self.vms_in_table[vm.qid].update()
  718. self.table_selection_changed()
  719. except exc.QubesException as ex:
  720. QtGui.QMessageBox.warning(
  721. None,
  722. self.tr("Error pausing Qube!"),
  723. self.tr("ERROR: {0}").format(ex))
  724. return
  725. # noinspection PyArgumentList
  726. @QtCore.pyqtSlot(name='on_action_shutdownvm_triggered')
  727. def action_shutdownvm_triggered(self):
  728. vm = self.get_selected_vm()
  729. reply = QtGui.QMessageBox.question(
  730. None, self.tr("Qube Shutdown Confirmation"),
  731. self.tr("Are you sure you want to power down the Qube"
  732. " <b>'{0}'</b>?<br><small>This will shutdown all the "
  733. "running applications within this Qube.</small>").format(
  734. vm.name), QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel)
  735. self.qt_app.processEvents()
  736. if reply == QtGui.QMessageBox.Yes:
  737. self.shutdown_vm(vm)
  738. def shutdown_vm(self, vm, shutdown_time=vm_shutdown_timeout,
  739. check_time=vm_restart_check_timeout, and_restart=False):
  740. try:
  741. vm.shutdown()
  742. except exc.QubesException as ex:
  743. QtGui.QMessageBox.warning(
  744. None,
  745. self.tr("Error shutting down Qube!"),
  746. self.tr("ERROR: {0}").format(ex))
  747. return
  748. self.shutdown_monitor[vm.qid] = VmShutdownMonitor(vm, shutdown_time,
  749. check_time,
  750. and_restart, self)
  751. # noinspection PyCallByClass,PyTypeChecker
  752. QtCore.QTimer.singleShot(check_time, self.shutdown_monitor[
  753. vm.qid].check_if_vm_has_shutdown)
  754. # noinspection PyArgumentList
  755. @QtCore.pyqtSlot(name='on_action_restartvm_triggered')
  756. def action_restartvm_triggered(self):
  757. vm = self.get_selected_vm()
  758. reply = QtGui.QMessageBox.question(
  759. None, self.tr("Qube Restart Confirmation"),
  760. self.tr("Are you sure you want to restart the Qube <b>'{0}'</b>?"
  761. "<br><small>This will shutdown all the running "
  762. "applications within this Qube.</small>").format(vm.name),
  763. QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel)
  764. self.qt_app.processEvents()
  765. if reply == QtGui.QMessageBox.Yes:
  766. # in case the user shut down the VM in the meantime
  767. if vm.is_running():
  768. self.shutdown_vm(vm, and_restart=True)
  769. else:
  770. self.start_vm(vm)
  771. # noinspection PyArgumentList
  772. @QtCore.pyqtSlot(name='on_action_killvm_triggered')
  773. def action_killvm_triggered(self):
  774. vm = self.get_selected_vm()
  775. if not (vm.is_running() or vm.is_paused()):
  776. info = self.tr("Qube <b>'{0}'</b> is not running. Are you "
  777. "absolutely sure you want to try to kill it?<br>"
  778. "<small>This will end <b>(not shutdown!)</b> all "
  779. "the running applications within this "
  780. "Qube.</small>").format(vm.name)
  781. else:
  782. info = self.tr("Are you sure you want to kill the Qube "
  783. "<b>'{0}'</b>?<br><small>This will end <b>(not "
  784. "shutdown!)</b> all the running applications within "
  785. "this Qube.</small>").format(vm.name)
  786. reply = QtGui.QMessageBox.question(
  787. None, self.tr("Qube Kill Confirmation"), info,
  788. QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel,
  789. QtGui.QMessageBox.Cancel)
  790. self.qt_app.processEvents()
  791. if reply == QtGui.QMessageBox.Yes:
  792. try:
  793. vm.kill()
  794. except exc.QubesException as ex:
  795. QtGui.QMessageBox.critical(
  796. None, self.tr("Error while killing Qube!"),
  797. self.tr(
  798. "<b>An exception ocurred while killing {0}.</b><br>"
  799. "ERROR: {1}").format(vm.name, ex))
  800. return
  801. # noinspection PyArgumentList
  802. @QtCore.pyqtSlot(name='on_action_settings_triggered')
  803. def action_settings_triggered(self):
  804. vm = self.get_selected_vm()
  805. if vm:
  806. settings_window = settings.VMSettingsWindow(
  807. vm, self.qt_app, "basic")
  808. settings_window.exec_()
  809. vm_deleted = False
  810. try:
  811. # the VM might not exist after running Settings - it might
  812. # have been cloned or removed
  813. self.vms_in_table[vm.qid].update()
  814. except exc.QubesException:
  815. # TODO: this will be replaced by proper signal handling once
  816. # settings are migrated to AdminAPI
  817. vm_deleted = True
  818. if vm_deleted:
  819. for row in self.vms_in_table:
  820. try:
  821. self.vms_in_table[row].update()
  822. except exc.QubesException:
  823. pass
  824. # noinspection PyArgumentList
  825. @QtCore.pyqtSlot(name='on_action_appmenus_triggered')
  826. def action_appmenus_triggered(self):
  827. vm = self.get_selected_vm()
  828. if vm:
  829. settings_window = settings.VMSettingsWindow(
  830. vm, self.qt_app, "applications")
  831. settings_window.exec_()
  832. # noinspection PyArgumentList
  833. @QtCore.pyqtSlot(name='on_action_updatevm_triggered')
  834. def action_updatevm_triggered(self):
  835. vm = self.get_selected_vm()
  836. if not vm.is_running():
  837. reply = QtGui.QMessageBox.question(
  838. None, self.tr("Qube Update Confirmation"),
  839. self.tr(
  840. "<b>{0}</b><br>The Qube has to be running to be updated."
  841. "<br>Do you want to start it?<br>").format(vm.name),
  842. QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel)
  843. if reply != QtGui.QMessageBox.Yes:
  844. return
  845. self.qt_app.processEvents()
  846. t_monitor = thread_monitor.ThreadMonitor()
  847. thread = threading.Thread(target=self.do_update_vm,
  848. args=(vm, t_monitor))
  849. thread.daemon = True
  850. thread.start()
  851. progress = QtGui.QProgressDialog(
  852. self.tr(
  853. "<b>{0}</b><br>Please wait for the updater to "
  854. "launch...").format(vm.name), "", 0, 0)
  855. progress.setWindowFlags(QtCore.Qt.Window |
  856. QtCore.Qt.WindowTitleHint |
  857. QtCore.Qt.CustomizeWindowHint)
  858. progress.setCancelButton(None)
  859. progress.setModal(True)
  860. progress.show()
  861. while not t_monitor.is_finished():
  862. self.qt_app.processEvents()
  863. time.sleep(0.2)
  864. progress.hide()
  865. if vm.qid != 0:
  866. if not t_monitor.success:
  867. QtGui.QMessageBox.warning(
  868. None,
  869. self.tr("Error on Qube update!"),
  870. self.tr("ERROR: {0}").format(t_monitor.error_msg))
  871. @staticmethod
  872. def do_update_vm(vm, t_monitor):
  873. try:
  874. if vm.qid == 0:
  875. subprocess.check_call(
  876. ["/usr/bin/qubes-dom0-update", "--clean", "--gui"])
  877. else:
  878. if not vm.is_running():
  879. vm.start()
  880. vm.run_service("qubes.InstallUpdatesGUI",
  881. user="root", wait=False)
  882. except (ChildProcessError, exc.QubesException) as ex:
  883. t_monitor.set_error_msg(str(ex))
  884. t_monitor.set_finished()
  885. return
  886. t_monitor.set_finished()
  887. # noinspection PyArgumentList
  888. @QtCore.pyqtSlot(name='on_action_run_command_in_vm_triggered')
  889. def action_run_command_in_vm_triggered(self):
  890. # pylint: disable=invalid-name
  891. vm = self.get_selected_vm()
  892. (command_to_run, ok) = QtGui.QInputDialog.getText(
  893. self, self.tr('Qubes command entry'),
  894. self.tr('Run command in <b>{}</b>:').format(vm.name))
  895. if not ok or command_to_run == "":
  896. return
  897. t_monitor = thread_monitor.ThreadMonitor()
  898. thread = threading.Thread(target=self.do_run_command_in_vm, args=(
  899. vm, command_to_run, t_monitor))
  900. thread.daemon = True
  901. thread.start()
  902. while not t_monitor.is_finished():
  903. self.qt_app.processEvents()
  904. time.sleep(0.2)
  905. if not t_monitor.success:
  906. QtGui.QMessageBox.warning(
  907. None, self.tr("Error while running command"),
  908. self.tr("Exception while running command:<br>{0}").format(
  909. t_monitor.error_msg))
  910. @staticmethod
  911. def do_run_command_in_vm(vm, command_to_run, t_monitor):
  912. try:
  913. vm.run(command_to_run)
  914. except (ChildProcessError, exc.QubesException) as ex:
  915. t_monitor.set_error_msg(str(ex))
  916. t_monitor.set_finished()
  917. # noinspection PyArgumentList
  918. @QtCore.pyqtSlot(name='on_action_set_keyboard_layout_triggered')
  919. def action_set_keyboard_layout_triggered(self):
  920. # pylint: disable=invalid-name
  921. vm = self.get_selected_vm()
  922. vm.run('qubes-change-keyboard-layout')
  923. # noinspection PyArgumentList
  924. @QtCore.pyqtSlot(name='on_action_editfwrules_triggered')
  925. def action_editfwrules_triggered(self):
  926. vm = self.get_selected_vm()
  927. settings_window = settings.VMSettingsWindow(vm, self.qt_app, "firewall")
  928. settings_window.exec_()
  929. # noinspection PyArgumentList
  930. @QtCore.pyqtSlot(name='on_action_global_settings_triggered')
  931. def action_global_settings_triggered(self): # pylint: disable=invalid-name
  932. global_settings_window = global_settings.GlobalSettingsWindow(
  933. self.qt_app,
  934. self.qubes_app)
  935. global_settings_window.exec_()
  936. # noinspection PyArgumentList
  937. @QtCore.pyqtSlot(name='on_action_show_network_triggered')
  938. def action_show_network_triggered(self):
  939. pass
  940. # TODO: revive for 4.1
  941. # network_notes_dialog = NetworkNotesDialog()
  942. # network_notes_dialog.exec_()
  943. # noinspection PyArgumentList
  944. @QtCore.pyqtSlot(name='on_action_restore_triggered')
  945. def action_restore_triggered(self):
  946. restore_window = restore.RestoreVMsWindow(self.qt_app, self.qubes_app)
  947. restore_window.exec_()
  948. # noinspection PyArgumentList
  949. @QtCore.pyqtSlot(name='on_action_backup_triggered')
  950. def action_backup_triggered(self):
  951. backup_window = backup.BackupVMsWindow(self.qt_app, self.qubes_app)
  952. backup_window.exec_()
  953. # noinspection PyArgumentList
  954. @QtCore.pyqtSlot(name='on_action_exit_triggered')
  955. def action_exit_triggered(self):
  956. self.close()
  957. def showhide_menubar(self, checked):
  958. self.menubar.setVisible(checked)
  959. if not checked:
  960. self.context_menu.addAction(self.action_menubar)
  961. else:
  962. self.context_menu.removeAction(self.action_menubar)
  963. if self.settings_loaded:
  964. self.manager_settings.setValue('view/menubar_visible', checked)
  965. self.manager_settings.sync()
  966. def showhide_toolbar(self, checked):
  967. self.toolbar.setVisible(checked)
  968. if not checked:
  969. self.context_menu.addAction(self.action_toolbar)
  970. else:
  971. self.context_menu.removeAction(self.action_toolbar)
  972. if self.settings_loaded:
  973. self.manager_settings.setValue('view/toolbar_visible', checked)
  974. self.manager_settings.sync()
  975. def showhide_column(self, col_num, show):
  976. self.table.setColumnHidden(col_num, not show)
  977. val = 1 if show else -1
  978. self.visible_columns_count += val
  979. if self.visible_columns_count == 1:
  980. # disable hiding the last one
  981. for col in self.columns_actions:
  982. if self.columns_actions[col].isChecked():
  983. self.columns_actions[col].setEnabled(False)
  984. break
  985. elif self.visible_columns_count == 2 and val == 1:
  986. # enable hiding previously disabled column
  987. for col in self.columns_actions:
  988. if not self.columns_actions[col].isEnabled():
  989. self.columns_actions[col].setEnabled(True)
  990. break
  991. if self.settings_loaded:
  992. col_name = [name for name in self.columns_indices if
  993. self.columns_indices[name] == col_num][0]
  994. self.manager_settings.setValue('columns/%s' % col_name, show)
  995. self.manager_settings.sync()
  996. def on_action_vm_type_toggled(self, checked):
  997. self.showhide_column(self.columns_indices['Type'], checked)
  998. def on_action_label_toggled(self, checked):
  999. self.showhide_column(self.columns_indices['Label'], checked)
  1000. def on_action_name_toggled(self, checked):
  1001. self.showhide_column(self.columns_indices['Name'], checked)
  1002. def on_action_state_toggled(self, checked):
  1003. self.showhide_column(self.columns_indices['State'], checked)
  1004. def on_action_internal_toggled(self, checked):
  1005. self.showhide_column(self.columns_indices['Internal'], checked)
  1006. def on_action_ip_toggled(self, checked):
  1007. self.showhide_column(self.columns_indices['IP'], checked)
  1008. def on_action_backups_toggled(self, checked):
  1009. self.showhide_column(self.columns_indices['Backups'], checked)
  1010. def on_action_last_backup_toggled(self, checked):
  1011. self.showhide_column(self.columns_indices['Last backup'], checked)
  1012. def on_action_template_toggled(self, checked):
  1013. self.showhide_column(self.columns_indices['Template'], checked)
  1014. def on_action_netvm_toggled(self, checked):
  1015. self.showhide_column(self.columns_indices['NetVM'], checked)
  1016. def on_action_size_on_disk_toggled(self, checked):
  1017. self.showhide_column(self.columns_indices['Size'], checked)
  1018. # noinspection PyArgumentList
  1019. @QtCore.pyqtSlot(name='on_action_about_qubes_triggered')
  1020. def action_about_qubes_triggered(self): # pylint: disable=no-self-use
  1021. about = AboutDialog()
  1022. about.exec_()
  1023. def createPopupMenu(self): # pylint: disable=invalid-name
  1024. menu = QtGui.QMenu()
  1025. menu.addAction(self.action_toolbar)
  1026. menu.addAction(self.action_menubar)
  1027. return menu
  1028. def open_tools_context_menu(self, widget, point):
  1029. self.tools_context_menu.exec_(widget.mapToGlobal(point))
  1030. @QtCore.pyqtSlot('const QPoint&')
  1031. def open_context_menu(self, point):
  1032. try:
  1033. vm = self.get_selected_vm()
  1034. # logs menu
  1035. self.logs_menu.clear()
  1036. if vm.qid == 0:
  1037. logfiles = ["/var/log/xen/console/hypervisor.log"]
  1038. else:
  1039. logfiles = [
  1040. "/var/log/xen/console/guest-" + vm.name + ".log",
  1041. "/var/log/xen/console/guest-" + vm.name + "-dm.log",
  1042. "/var/log/qubes/guid." + vm.name + ".log",
  1043. "/var/log/qubes/qrexec." + vm.name + ".log",
  1044. ]
  1045. menu_empty = True
  1046. for logfile in logfiles:
  1047. if os.path.exists(logfile):
  1048. action = self.logs_menu.addAction(QtGui.QIcon(":/log.png"),
  1049. logfile)
  1050. action.setData(logfile)
  1051. menu_empty = False
  1052. self.logs_menu.setEnabled(not menu_empty)
  1053. if vm.qid == 0:
  1054. self.dom0_context_menu.exec_(self.table.mapToGlobal(
  1055. point + QtCore.QPoint(10, 0)))
  1056. else:
  1057. self.context_menu.exec_(self.table.mapToGlobal(
  1058. point + QtCore.QPoint(10, 0)))
  1059. except exc.QubesPropertyAccessError:
  1060. pass
  1061. @QtCore.pyqtSlot('QAction *')
  1062. def show_log(self, action):
  1063. log = str(action.data())
  1064. log_dlg = log_dialog.LogDialog(self.qt_app, log)
  1065. log_dlg.exec_()
  1066. # Bases on the original code by:
  1067. # Copyright (c) 2002-2007 Pascal Varet <p.varet@gmail.com>
  1068. def handle_exception(exc_type, exc_value, exc_traceback):
  1069. filename, line, dummy, dummy = traceback.extract_tb(exc_traceback).pop()
  1070. filename = os.path.basename(filename)
  1071. error = "%s: %s" % (exc_type.__name__, exc_value)
  1072. strace = ""
  1073. stacktrace = traceback.extract_tb(exc_traceback)
  1074. while stacktrace:
  1075. (filename, line, func, txt) = stacktrace.pop()
  1076. strace += "----\n"
  1077. strace += "line: %s\n" % txt
  1078. strace += "func: %s\n" % func
  1079. strace += "line no.: %d\n" % line
  1080. strace += "file: %s\n" % filename
  1081. msg_box = QtGui.QMessageBox()
  1082. msg_box.setDetailedText(strace)
  1083. msg_box.setIcon(QtGui.QMessageBox.Critical)
  1084. msg_box.setWindowTitle("Houston, we have a problem...")
  1085. msg_box.setText("Whoops. A critical error has occured. "
  1086. "This is most likely a bug in Qubes Manager.<br><br>"
  1087. "<b><i>%s</i></b>" % error +
  1088. "<br/>at line <b>%d</b><br/>of file %s.<br/><br/>"
  1089. % (line, filename))
  1090. msg_box.exec_()
  1091. def loop_shutdown():
  1092. pending = asyncio.Task.all_tasks()
  1093. for task in pending:
  1094. with suppress(asyncio.CancelledError):
  1095. task.cancel()
  1096. def main():
  1097. qt_app = QtGui.QApplication(sys.argv)
  1098. qt_app.setOrganizationName("The Qubes Project")
  1099. qt_app.setOrganizationDomain("http://qubes-os.org")
  1100. qt_app.setApplicationName("Qube Manager")
  1101. qt_app.setWindowIcon(QtGui.QIcon.fromTheme("qubes-manager"))
  1102. qt_app.lastWindowClosed.connect(loop_shutdown)
  1103. qubes_app = Qubes()
  1104. loop = quamash.QEventLoop(qt_app)
  1105. asyncio.set_event_loop(loop)
  1106. dispatcher = events.EventsDispatcher(qubes_app)
  1107. manager_window = VmManagerWindow(qt_app, qubes_app, dispatcher)
  1108. manager_window.show()
  1109. try:
  1110. done, _ = loop.run_until_complete(
  1111. asyncio.ensure_future(dispatcher.listen_for_events()))
  1112. except asyncio.CancelledError:
  1113. pass
  1114. except Exception:
  1115. loop_shutdown()
  1116. exc_type, exc_value, exc_traceback = sys.exc_info()[:3]
  1117. handle_exception(exc_type, exc_value, exc_traceback)
  1118. if __name__ == "__main__":
  1119. main()