__init__.py 42 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214
  1. # pylint: disable=invalid-name
  2. #
  3. # The Qubes OS Project, https://www.qubes-os.org/
  4. #
  5. # Copyright (C) 2014-2015 Joanna Rutkowska <joanna@invisiblethingslab.com>
  6. # Copyright (C) 2014-2015
  7. # Marek Marczykowski-Górecki <marmarek@invisiblethingslab.com>
  8. # Copyright (C) 2014-2015 Wojtek Porczyk <woju@invisiblethingslab.com>
  9. #
  10. # This library is free software; you can redistribute it and/or
  11. # modify it under the terms of the GNU Lesser General Public
  12. # License as published by the Free Software Foundation; either
  13. # version 2.1 of the License, or (at your option) any later version.
  14. #
  15. # This library 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 GNU
  18. # Lesser General Public License for more details.
  19. #
  20. # You should have received a copy of the GNU Lesser General Public
  21. # License along with this library; if not, see <https://www.gnu.org/licenses/>.
  22. #
  23. """
  24. .. warning::
  25. The test suite hereby claims any domain whose name starts with
  26. :py:data:`VMPREFIX` as fair game. This is needed to enforce sane
  27. test executing environment. If you have domains named ``test-*``,
  28. don't run the tests.
  29. """
  30. import asyncio
  31. import collections
  32. import functools
  33. import logging
  34. import os
  35. import pathlib
  36. import shlex
  37. import shutil
  38. import subprocess
  39. import sys
  40. import tempfile
  41. import time
  42. import traceback
  43. import unittest
  44. import warnings
  45. from distutils import spawn
  46. import gc
  47. import lxml.etree
  48. import pkg_resources
  49. import qubes
  50. import qubes.api
  51. import qubes.api.admin
  52. import qubes.api.internal
  53. import qubes.backup
  54. import qubes.config
  55. import qubes.devices
  56. import qubes.events
  57. import qubes.exc
  58. import qubes.ext.pci
  59. import qubes.vm.standalonevm
  60. import qubes.vm.templatevm
  61. XMLPATH = '/var/lib/qubes/qubes-test.xml'
  62. CLASS_XMLPATH = '/var/lib/qubes/qubes-class-test.xml'
  63. TEMPLATE = 'fedora-23'
  64. VMPREFIX = 'test-inst-'
  65. CLSVMPREFIX = 'test-cls-'
  66. if 'DEFAULT_LVM_POOL' in os.environ.keys():
  67. DEFAULT_LVM_POOL = os.environ['DEFAULT_LVM_POOL']
  68. else:
  69. DEFAULT_LVM_POOL = 'qubes_dom0/pool00'
  70. POOL_CONF = {'name': 'test-lvm',
  71. 'driver': 'lvm_thin',
  72. 'volume_group': DEFAULT_LVM_POOL.split('/')[0],
  73. 'thin_pool': DEFAULT_LVM_POOL.split('/')[1]}
  74. #: :py:obj:`True` if running in dom0, :py:obj:`False` otherwise
  75. in_dom0 = False
  76. #: :py:obj:`False` if outside of git repo,
  77. #: path to root of the directory otherwise
  78. in_git = False
  79. try:
  80. import libvirt
  81. libvirt.openReadOnly(qubes.config.defaults['libvirt_uri']).close()
  82. in_dom0 = True
  83. except libvirt.libvirtError:
  84. pass
  85. if in_dom0:
  86. import libvirtaio
  87. libvirt_event_impl = libvirtaio.virEventRegisterAsyncIOImpl()
  88. else:
  89. libvirt_event_impl = None
  90. try:
  91. in_git = subprocess.check_output(
  92. ['git', 'rev-parse', '--show-toplevel']).decode().strip()
  93. qubes.log.LOGPATH = '/tmp'
  94. qubes.log.LOGFILE = '/tmp/qubes.log'
  95. except subprocess.CalledProcessError:
  96. # git returned nonzero, we are outside git repo
  97. pass
  98. except OSError:
  99. # command not found; let's assume we're outside
  100. pass
  101. def skipUnlessDom0(test_item):
  102. '''Decorator that skips test outside dom0.
  103. Some tests (especially integration tests) have to be run in more or less
  104. working dom0. This is checked by connecting to libvirt.
  105. '''
  106. return unittest.skipUnless(in_dom0, 'outside dom0')(test_item)
  107. def skipUnlessGit(test_item):
  108. '''Decorator that skips test outside git repo.
  109. There are very few tests that an be run only in git. One example is
  110. correctness of example code that won't get included in RPM.
  111. '''
  112. return unittest.skipUnless(in_git, 'outside git tree')(test_item)
  113. def skipUnlessEnv(varname):
  114. '''Decorator generator for skipping tests without environment variable set.
  115. Some tests require working X11 display, like those using GTK library, which
  116. segfaults without connection to X.
  117. Other require their own, custom variables.
  118. '''
  119. return unittest.skipUnless(os.getenv(varname), 'no {} set'.format(varname))
  120. class TestEmitter(qubes.events.Emitter):
  121. '''Dummy event emitter which records events fired on it.
  122. Events are counted in :py:attr:`fired_events` attribute, which is
  123. :py:class:`collections.Counter` instance. For each event, ``(event, args,
  124. kwargs)`` object is counted. *event* is event name (a string), *args* is
  125. tuple with positional arguments and *kwargs* is sorted tuple of items from
  126. keyword arguments.
  127. >>> emitter = TestEmitter()
  128. >>> emitter.fired_events
  129. Counter()
  130. >>> emitter.fire_event('event', spam='eggs', foo='bar')
  131. >>> emitter.fired_events
  132. Counter({('event', (1, 2, 3), (('foo', 'bar'), ('spam', 'eggs'))): 1})
  133. '''
  134. def __init__(self, *args, **kwargs):
  135. super(TestEmitter, self).__init__(*args, **kwargs)
  136. #: :py:class:`collections.Counter` instance
  137. self.fired_events = collections.Counter()
  138. def fire_event(self, event, **kwargs):
  139. effects = super(TestEmitter, self).fire_event(event, **kwargs)
  140. ev_kwargs = frozenset(
  141. (key,
  142. frozenset(value.items()) if isinstance(value, dict)
  143. else tuple(value) if isinstance(value, list)
  144. else value)
  145. for key, value in kwargs.items()
  146. )
  147. self.fired_events[(event, ev_kwargs)] += 1
  148. return effects
  149. @asyncio.coroutine
  150. def fire_event_async(self, event, pre_event=False, **kwargs):
  151. effects = yield from super(TestEmitter, self).fire_event_async(
  152. event, pre_event=pre_event, **kwargs)
  153. ev_kwargs = frozenset(
  154. (key,
  155. frozenset(value.items()) if isinstance(value, dict) else value)
  156. for key, value in kwargs.items()
  157. )
  158. self.fired_events[(event, ev_kwargs)] += 1
  159. return effects
  160. def expectedFailureIfTemplate(templates):
  161. """
  162. Decorator for marking specific test as expected to fail only for some
  163. templates. Template name is compared as substring, so 'whonix' will
  164. handle both 'whonix-ws' and 'whonix-gw'.
  165. templates can be either a single string, or an iterable
  166. """
  167. def decorator(func):
  168. @functools.wraps(func)
  169. def wrapper(self, *args, **kwargs):
  170. template = self.template
  171. if isinstance(templates, str):
  172. should_expect_fail = template in templates
  173. else:
  174. should_expect_fail = any([template in x for x in templates])
  175. if should_expect_fail:
  176. try:
  177. func(self, *args, **kwargs)
  178. except Exception:
  179. raise unittest.case._ExpectedFailure(sys.exc_info())
  180. raise unittest.case._UnexpectedSuccess()
  181. else:
  182. # Call directly:
  183. func(self, *args, **kwargs)
  184. return wrapper
  185. return decorator
  186. class _AssertNotRaisesContext(object):
  187. """A context manager used to implement TestCase.assertNotRaises methods.
  188. Stolen from unittest and hacked. Regexp support stripped.
  189. """ # pylint: disable=too-few-public-methods
  190. def __init__(self, expected, test_case, expected_regexp=None):
  191. if expected_regexp is not None:
  192. raise NotImplementedError('expected_regexp is unsupported')
  193. self.expected = expected
  194. self.exception = None
  195. self.failureException = test_case.failureException
  196. def __enter__(self):
  197. return self
  198. def __exit__(self, exc_type, exc_value, tb):
  199. if exc_type is None:
  200. return True
  201. if issubclass(exc_type, self.expected):
  202. raise self.failureException(
  203. "{!r} raised, traceback:\n{!s}".format(
  204. exc_value, ''.join(traceback.format_tb(tb))))
  205. else:
  206. # pass through
  207. return False
  208. self.exception = exc_value # store for later retrieval
  209. class _QrexecPolicyContext(object):
  210. '''Context manager for SystemTestCase.qrexec_policy'''
  211. def __init__(self, service, source, destination, allow=True, action=None):
  212. try:
  213. source = source.name
  214. except AttributeError:
  215. pass
  216. try:
  217. destination = destination.name
  218. except AttributeError:
  219. pass
  220. self._filename = pathlib.Path('/etc/qubes-rpc/policy') / service
  221. if action is None:
  222. action = 'allow' if allow else 'deny'
  223. self._rule = '{} {} {}\n'.format(source, destination, action)
  224. self._did_create = False
  225. self._handle = None
  226. def load(self):
  227. if self._handle is None:
  228. try:
  229. self._handle = self._filename.open('r+')
  230. except FileNotFoundError:
  231. self._handle = self._filename.open('w+')
  232. self._did_create = True
  233. self._handle.seek(0)
  234. return self._handle.readlines()
  235. def save(self, rules):
  236. assert self._handle is not None
  237. self._handle.truncate(0)
  238. self._handle.seek(0)
  239. self._handle.write(''.join(rules))
  240. self._handle.flush()
  241. def close(self):
  242. assert self._handle is not None
  243. self._handle.close()
  244. self._handle = None
  245. def __enter__(self):
  246. rules = self.load()
  247. rules.insert(0, self._rule)
  248. self.save(rules)
  249. return self
  250. def __exit__(self, exc_type, exc_value, tb):
  251. if not self._did_create:
  252. try:
  253. rules = self.load()
  254. rules.remove(self._rule)
  255. self.save(rules)
  256. finally:
  257. self.close()
  258. else:
  259. self.close()
  260. self._filename.unlink()
  261. class substitute_entry_points(object):
  262. '''Monkey-patch pkg_resources to substitute one group in iter_entry_points
  263. This is for testing plugins, like device classes.
  264. :param str group: The group that is to be overloaded.
  265. :param str tempgroup: The substitute group.
  266. Inside this context, if one iterates over entry points in overloaded group,
  267. the iteration actually happens over the other group.
  268. This context manager is stackable. To substitute more than one entry point
  269. group, just nest two contexts.
  270. ''' # pylint: disable=invalid-name
  271. def __init__(self, group, tempgroup):
  272. self.group = group
  273. self.tempgroup = tempgroup
  274. self._orig_iter_entry_points = None
  275. def _iter_entry_points(self, group, *args, **kwargs):
  276. if group == self.group:
  277. group = self.tempgroup
  278. return self._orig_iter_entry_points(group, *args, **kwargs)
  279. def __enter__(self):
  280. self._orig_iter_entry_points = pkg_resources.iter_entry_points
  281. pkg_resources.iter_entry_points = self._iter_entry_points
  282. return self
  283. def __exit__(self, exc_type, exc_value, tb):
  284. pkg_resources.iter_entry_points = self._orig_iter_entry_points
  285. self._orig_iter_entry_points = None
  286. class QubesTestCase(unittest.TestCase):
  287. '''Base class for Qubes unit tests.
  288. '''
  289. def __init__(self, *args, **kwargs):
  290. super(QubesTestCase, self).__init__(*args, **kwargs)
  291. self.longMessage = True
  292. self.log = logging.getLogger('{}.{}.{}'.format(
  293. self.__class__.__module__,
  294. self.__class__.__name__,
  295. self._testMethodName))
  296. self.addTypeEqualityFunc(qubes.devices.DeviceManager,
  297. self.assertDevicesEqual)
  298. self.loop = None
  299. def __str__(self):
  300. return '{}/{}/{}'.format(
  301. self.__class__.__module__,
  302. self.__class__.__name__,
  303. self._testMethodName)
  304. def setUp(self):
  305. super().setUp()
  306. self.addCleanup(self.cleanup_gc)
  307. self.loop = asyncio.get_event_loop()
  308. self.addCleanup(self.cleanup_loop)
  309. self.addCleanup(qubes.ext.pci._cache_get.cache_clear)
  310. def cleanup_gc(self):
  311. gc.collect()
  312. leaked = [obj for obj in gc.get_objects() + gc.garbage
  313. if isinstance(obj,
  314. (qubes.Qubes, qubes.vm.BaseVM,
  315. libvirt.virConnect, libvirt.virDomain))]
  316. if leaked:
  317. try:
  318. import objgraph
  319. objgraph.show_backrefs(leaked,
  320. max_depth=15, extra_info=extra_info,
  321. filename='/tmp/objgraph-{}.png'.format(self.id()))
  322. except ImportError:
  323. pass
  324. assert not leaked
  325. def cleanup_loop(self):
  326. '''Check if the loop is empty'''
  327. # XXX BEWARE this is touching undocumented, implementation-specific
  328. # attributes of the loop. This is most certainly unsupported and likely
  329. # will break when messing with: Python version, kernel family, loop
  330. # implementation, a combination thereof, or other things.
  331. # KEYWORDS for searching:
  332. # win32, SelectorEventLoop, ProactorEventLoop, uvloop, gevent
  333. global libvirt_event_impl
  334. # Check for unfinished libvirt business.
  335. if libvirt_event_impl is not None:
  336. try:
  337. self.loop.run_until_complete(asyncio.wait_for(
  338. libvirt_event_impl.drain(), timeout=4))
  339. except asyncio.TimeoutError:
  340. raise AssertionError('libvirt event impl drain timeout')
  341. # Check there are no Tasks left.
  342. assert not self.loop._ready
  343. assert not self.loop._scheduled
  344. # Check the loop watches no descriptors.
  345. # NOTE the loop has a pipe for self-interrupting, created once per
  346. # lifecycle, and it is unwatched only at loop.close(); so we cannot just
  347. # check selector for non-emptiness
  348. assert len(self.loop._selector.get_map()) \
  349. == int(self.loop._ssock is not None)
  350. del self.loop
  351. def assertNotRaises(self, excClass, callableObj=None, *args, **kwargs):
  352. """Fail if an exception of class excClass is raised
  353. by callableObj when invoked with arguments args and keyword
  354. arguments kwargs. If a different type of exception is
  355. raised, it will not be caught, and the test case will be
  356. deemed to have suffered an error, exactly as for an
  357. unexpected exception.
  358. If called with callableObj omitted or None, will return a
  359. context object used like this::
  360. with self.assertRaises(SomeException):
  361. do_something()
  362. The context manager keeps a reference to the exception as
  363. the 'exception' attribute. This allows you to inspect the
  364. exception after the assertion::
  365. with self.assertRaises(SomeException) as cm:
  366. do_something()
  367. the_exception = cm.exception
  368. self.assertEqual(the_exception.error_code, 3)
  369. """
  370. context = _AssertNotRaisesContext(excClass, self)
  371. if callableObj is None:
  372. return context
  373. with context:
  374. callableObj(*args, **kwargs)
  375. def assertXMLEqual(self, xml1, xml2, msg=''):
  376. '''Check for equality of two XML objects.
  377. :param xml1: first element
  378. :param xml2: second element
  379. :type xml1: :py:class:`lxml.etree._Element`
  380. :type xml2: :py:class:`lxml.etree._Element`
  381. '''
  382. self.assertEqual(xml1.tag, xml2.tag)
  383. msg += '/' + str(xml1.tag)
  384. if xml1.text is not None and xml2.text is not None:
  385. self.assertEqual(xml1.text.strip(), xml2.text.strip(), msg)
  386. else:
  387. self.assertEqual(xml1.text, xml2.text, msg)
  388. self.assertCountEqual(xml1.keys(), xml2.keys(), msg)
  389. for key in xml1.keys():
  390. self.assertEqual(xml1.get(key), xml2.get(key), msg)
  391. self.assertEqual(len(xml1), len(xml2), msg + ' children count')
  392. for child1, child2 in zip(xml1, xml2):
  393. self.assertXMLEqual(child1, child2, msg=msg)
  394. def assertDevicesEqual(self, devices1, devices2, msg=None):
  395. self.assertEqual(devices1.keys(), devices2.keys(), msg)
  396. for dev_class in devices1.keys():
  397. self.assertEqual(
  398. [str(dev) for dev in devices1[dev_class]],
  399. [str(dev) for dev in devices2[dev_class]],
  400. "Devices of class {} differs{}".format(
  401. dev_class, (": " + msg) if msg else "")
  402. )
  403. def assertEventFired(self, subject, event, kwargs=None):
  404. '''Check whether event was fired on given emitter and fail if it did
  405. not.
  406. :param subject: emitter which is being checked
  407. :type emitter: :py:class:`TestEmitter`
  408. :param str event: event identifier
  409. :param dict kwargs: when given, all items must appear in kwargs passed \
  410. to an event
  411. '''
  412. will_not_match = object()
  413. for ev, ev_kwargs in subject.fired_events:
  414. if ev != event:
  415. continue
  416. if kwargs is not None:
  417. ev_kwargs = dict(ev_kwargs)
  418. if any(ev_kwargs.get(k, will_not_match) != v
  419. for k, v in kwargs.items()):
  420. continue
  421. return
  422. self.fail('event {!r} {}did not fire on {!r}'.format(
  423. event, ('' if kwargs is None else '{!r} '.format(kwargs)), subject))
  424. def assertEventNotFired(self, subject, event, kwargs=None):
  425. '''Check whether event was fired on given emitter. Fail if it did.
  426. :param subject: emitter which is being checked
  427. :type emitter: :py:class:`TestEmitter`
  428. :param str event: event identifier
  429. :param list kwargs: when given, all items must appear in kwargs passed \
  430. to an event
  431. '''
  432. will_not_match = object()
  433. for ev, ev_kwargs in subject.fired_events:
  434. if ev != event:
  435. continue
  436. if kwargs is not None:
  437. ev_kwargs = dict(ev_kwargs)
  438. if any(ev_kwargs.get(k, will_not_match) != v
  439. for k, v in kwargs.items()):
  440. continue
  441. self.fail('event {!r} {}did fire on {!r}'.format(
  442. event,
  443. ('' if kwargs is None else '{!r} '.format(kwargs)),
  444. subject))
  445. return
  446. def assertXMLIsValid(self, xml, file=None, schema=None):
  447. '''Check whether given XML fulfills Relax NG schema.
  448. Schema can be given in a couple of ways:
  449. - As separate file. This is most common, and also the only way to
  450. handle file inclusion. Call with file name as second argument.
  451. - As string containing actual schema. Put that string in *schema*
  452. keyword argument.
  453. :param lxml.etree._Element xml: XML element instance to check
  454. :param str file: filename of Relax NG schema
  455. :param str schema: optional explicit schema string
  456. ''' # pylint: disable=redefined-builtin
  457. if schema is not None and file is None:
  458. relaxng = schema
  459. if isinstance(relaxng, str):
  460. relaxng = lxml.etree.XML(relaxng)
  461. # pylint: disable=protected-access
  462. if isinstance(relaxng, lxml.etree._Element):
  463. relaxng = lxml.etree.RelaxNG(relaxng)
  464. elif file is not None and schema is None:
  465. if not os.path.isabs(file):
  466. basedirs = ['/usr/share/doc/qubes/relaxng']
  467. if in_git:
  468. basedirs.insert(0, os.path.join(in_git, 'relaxng'))
  469. for basedir in basedirs:
  470. abspath = os.path.join(basedir, file)
  471. if os.path.exists(abspath):
  472. file = abspath
  473. break
  474. relaxng = lxml.etree.RelaxNG(file=file)
  475. else:
  476. raise TypeError("There should be excactly one of 'file' and "
  477. "'schema' arguments specified.")
  478. # We have to be extra careful here in case someone messed up with
  479. # self.failureException. It should by default be AssertionError, just
  480. # what is spewed by RelaxNG(), but who knows what might happen.
  481. try:
  482. relaxng.assert_(xml)
  483. except self.failureException:
  484. raise
  485. except AssertionError as e:
  486. self.fail(str(e))
  487. @staticmethod
  488. def make_vm_name(name, class_teardown=False):
  489. if class_teardown:
  490. return CLSVMPREFIX + name
  491. else:
  492. return VMPREFIX + name
  493. class SystemTestCase(QubesTestCase):
  494. """
  495. Mixin for integration tests. All the tests here should use self.app
  496. object and when need qubes.xml path - should use :py:data:`XMLPATH`
  497. defined in this file.
  498. Every VM created by test, must use :py:meth:`SystemTestCase.make_vm_name`
  499. for VM name.
  500. By default self.app represents empty collection, if anything is needed
  501. there from the real collection it can be imported from self.host_app in
  502. :py:meth:`SystemTestCase.setUp`. But *can not be modified* in any way -
  503. this include both changing attributes in
  504. :py:attr:`SystemTestCase.host_app` and modifying files of such imported
  505. VM. If test need to make some modification, it must clone the VM first.
  506. If some group of tests needs class-wide initialization, first of all the
  507. author should consider if it is really needed. But if so, setUpClass can
  508. be used to create Qubes(CLASS_XMLPATH) object and create/import required
  509. stuff there. VMs created in :py:meth:`TestCase.setUpClass` should
  510. use self.make_vm_name('...', class_teardown=True) for name creation.
  511. Such (group of) test need to take care about
  512. :py:meth:`TestCase.tearDownClass` implementation itself.
  513. """
  514. # noinspection PyAttributeOutsideInit
  515. def setUp(self):
  516. if not in_dom0:
  517. self.skipTest('outside dom0')
  518. super(SystemTestCase, self).setUp()
  519. self.remove_test_vms()
  520. # need some information from the real qubes.xml - at least installed
  521. # templates; should not be used for testing, only to initialize self.app
  522. self.host_app = qubes.Qubes(os.path.join(
  523. qubes.config.qubes_base_dir,
  524. qubes.config.system_path['qubes_store_filename']))
  525. if os.path.exists(CLASS_XMLPATH):
  526. shutil.copy(CLASS_XMLPATH, XMLPATH)
  527. else:
  528. shutil.copy(self.host_app.store, XMLPATH)
  529. self.app = qubes.Qubes(XMLPATH)
  530. os.environ['QUBES_XML_PATH'] = XMLPATH
  531. self.app.register_event_handlers()
  532. self.qubesd = self.loop.run_until_complete(
  533. qubes.api.create_servers(
  534. qubes.api.admin.QubesAdminAPI,
  535. qubes.api.internal.QubesInternalAPI,
  536. app=self.app, debug=True))
  537. self.addCleanup(self.cleanup_app)
  538. self.app.add_handler('domain-delete', self.close_qdb_on_remove)
  539. def close_qdb_on_remove(self, app, event, vm, **kwargs):
  540. # only close QubesDB connection, do not perform other (destructive)
  541. # actions of vm.close()
  542. if vm._qdb_connection_watch is not None:
  543. asyncio.get_event_loop().remove_reader(
  544. vm._qdb_connection_watch.watch_fd())
  545. vm._qdb_connection_watch.close()
  546. vm._qdb_connection_watch = None
  547. def cleanup_app(self):
  548. self.remove_test_vms()
  549. server = None
  550. for server in self.qubesd:
  551. for sock in server.sockets:
  552. os.unlink(sock.getsockname())
  553. server.close()
  554. del server
  555. # close all existing connections, especially this will interrupt
  556. # running admin.Events calls, which do keep reference to Qubes() and
  557. # libvirt connection
  558. conn = None
  559. for conn in qubes.api.QubesDaemonProtocol.connections:
  560. if conn.transport:
  561. conn.transport.abort()
  562. del conn
  563. self.loop.run_until_complete(asyncio.wait([
  564. server.wait_closed() for server in self.qubesd]))
  565. del self.qubesd
  566. # remove all references to any complex qubes objects, to release
  567. # resources - most importantly file descriptors; this object will live
  568. # during the whole test run, but all the file descriptors would be
  569. # depleted earlier
  570. self.app.close()
  571. self.host_app.close()
  572. del self.app
  573. del self.host_app
  574. for attr in dir(self):
  575. obj_type = type(getattr(self, attr))
  576. if obj_type.__module__.startswith('qubes'):
  577. delattr(self, attr)
  578. # then trigger garbage collector to really destroy those objects
  579. gc.collect()
  580. def init_default_template(self, template=None):
  581. if template is None:
  582. template = self.host_app.default_template
  583. elif isinstance(template, str):
  584. template = self.host_app.domains[template]
  585. self.app.default_template = str(template)
  586. def init_networking(self):
  587. if not self.app.default_template:
  588. self.skipTest('Default template required for testing networking')
  589. default_netvm = self.host_app.default_netvm
  590. # if testing Whonix Workstation based VMs, try to use sys-whonix instead
  591. if self.app.default_template.name.startswith('whonix-ws'):
  592. if 'sys-whonix' in self.host_app.domains:
  593. default_netvm = self.host_app.domains['sys-whonix']
  594. if default_netvm is None:
  595. self.skipTest('Default netvm required')
  596. if not default_netvm.is_running():
  597. self.skipTest('VM {} required to be running'.format(
  598. default_netvm.name))
  599. self.app.default_netvm = str(default_netvm)
  600. def _find_pool(self, volume_group, thin_pool):
  601. ''' Returns the pool matching the specified ``volume_group`` &
  602. ``thin_pool``, or None.
  603. '''
  604. pools = [p for p in self.app.pools
  605. if issubclass(p.__class__, qubes.storage.lvm.ThinPool)]
  606. for pool in pools:
  607. if pool.volume_group == volume_group \
  608. and pool.thin_pool == thin_pool:
  609. return pool
  610. return None
  611. def init_lvm_pool(self):
  612. volume_group, thin_pool = DEFAULT_LVM_POOL.split('/', 1)
  613. path = "/dev/mapper/{!s}-{!s}".format(volume_group, thin_pool)
  614. if not os.path.exists(path):
  615. self.skipTest('LVM thin pool {!r} does not exist'.
  616. format(DEFAULT_LVM_POOL))
  617. self.pool = self._find_pool(volume_group, thin_pool)
  618. if not self.pool:
  619. self.pool = self.app.add_pool(**POOL_CONF)
  620. self.created_pool = True
  621. def _remove_vm_qubes(self, vm):
  622. vmname = vm.name
  623. app = vm.app
  624. # avoid race with DispVM.auto_cleanup=True
  625. try:
  626. self.loop.run_until_complete(
  627. asyncio.wait_for(vm.startup_lock.acquire(), 10))
  628. except asyncio.TimeoutError:
  629. pass
  630. try:
  631. # XXX .is_running() may throw libvirtError if undefined
  632. if vm.is_running():
  633. self.loop.run_until_complete(vm.kill())
  634. except: # pylint: disable=bare-except
  635. pass
  636. try:
  637. self.loop.run_until_complete(vm.remove_from_disk())
  638. except: # pylint: disable=bare-except
  639. pass
  640. try:
  641. del app.domains[vm.qid]
  642. except KeyError:
  643. pass
  644. vm.close()
  645. del vm
  646. app.save()
  647. del app
  648. # Now ensure it really went away. This may not have happened,
  649. # for example if vm.libvirt_domain malfunctioned.
  650. try:
  651. conn = libvirt.open(qubes.config.defaults['libvirt_uri'])
  652. except: # pylint: disable=bare-except
  653. pass
  654. else:
  655. try:
  656. dom = conn.lookupByName(vmname)
  657. except: # pylint: disable=bare-except
  658. pass
  659. else:
  660. self._remove_vm_libvirt(dom)
  661. conn.close()
  662. self._remove_vm_disk(vmname)
  663. @staticmethod
  664. def _remove_vm_libvirt(dom):
  665. try:
  666. dom.destroy()
  667. except libvirt.libvirtError: # not running
  668. pass
  669. dom.undefine()
  670. @staticmethod
  671. def _remove_vm_disk(vmname):
  672. for dirspec in (
  673. 'qubes_appvms_dir',
  674. 'qubes_servicevms_dir',
  675. 'qubes_templates_dir'):
  676. dirpath = os.path.join(qubes.config.qubes_base_dir,
  677. qubes.config.system_path[dirspec], vmname)
  678. if os.path.exists(dirpath):
  679. if os.path.isdir(dirpath):
  680. shutil.rmtree(dirpath)
  681. else:
  682. os.unlink(dirpath)
  683. @staticmethod
  684. def _remove_vm_disk_lvm(prefix=VMPREFIX):
  685. ''' Remove LVM volumes with given prefix
  686. This is "a bit" drastic, as it removes volumes regardless of volume
  687. group, thin pool etc. But we assume no important data on test system.
  688. '''
  689. try:
  690. volumes = subprocess.check_output(
  691. ['sudo', 'lvs', '--noheadings', '-o', 'vg_name,name',
  692. '--separator', '/']).decode()
  693. if ('/vm-' + prefix) not in volumes:
  694. return
  695. subprocess.check_call(['sudo', 'lvremove', '-f'] +
  696. [vol.strip() for vol in volumes.splitlines()
  697. if ('/vm-' + prefix) in vol],
  698. stdout=subprocess.DEVNULL)
  699. except subprocess.CalledProcessError:
  700. pass
  701. def remove_vms(self, vms):
  702. vms = list(vms)
  703. if not vms:
  704. return
  705. # break dependencies
  706. for vm in vms:
  707. vm.default_dispvm = None
  708. # then remove in reverse topological order (wrt netvm), using naive
  709. # algorithm
  710. # this heavily depends on lack of netvm loops
  711. while vms:
  712. vm = vms.pop(0)
  713. # make sure that all connected VMs are going to be removed,
  714. # otherwise this will loop forever
  715. assert all(x in vms for x in vm.connected_vms)
  716. if list(vm.connected_vms):
  717. # if still something use this VM, put it at the end of queue
  718. # and try next one
  719. vms.append(vm)
  720. continue
  721. self._remove_vm_qubes(vm)
  722. def remove_test_vms(self, xmlpath=XMLPATH, prefix=VMPREFIX):
  723. '''Aggresively remove any domain that has name in testing namespace.
  724. '''
  725. # first, remove them Qubes-way
  726. if os.path.exists(xmlpath):
  727. try:
  728. try:
  729. app = self.app
  730. except AttributeError:
  731. app = qubes.Qubes(xmlpath)
  732. try:
  733. host_app = self.host_app
  734. except AttributeError:
  735. host_app = qubes.Qubes()
  736. self.remove_vms([vm for vm in app.domains
  737. if vm.name.startswith(prefix) or
  738. (isinstance(vm, qubes.vm.dispvm.DispVM) and vm.name
  739. not in host_app.domains)])
  740. if not hasattr(self, 'host_app'):
  741. host_app.close()
  742. del host_app
  743. if not hasattr(self, 'app'):
  744. app.close()
  745. del app
  746. except qubes.exc.QubesException:
  747. pass
  748. os.unlink(xmlpath)
  749. # now remove what was only in libvirt
  750. conn = libvirt.open(qubes.config.defaults['libvirt_uri'])
  751. for dom in conn.listAllDomains():
  752. if dom.name().startswith(prefix):
  753. self._remove_vm_libvirt(dom)
  754. conn.close()
  755. # finally remove anything that is left on disk
  756. vmnames = set()
  757. for dirspec in (
  758. 'qubes_appvms_dir',
  759. 'qubes_servicevms_dir',
  760. 'qubes_templates_dir'):
  761. dirpath = os.path.join(qubes.config.qubes_base_dir,
  762. qubes.config.system_path[dirspec])
  763. if not os.path.exists(dirpath):
  764. continue
  765. for name in os.listdir(dirpath):
  766. if name.startswith(prefix):
  767. vmnames.add(name)
  768. for vmname in vmnames:
  769. self._remove_vm_disk(vmname)
  770. self._remove_vm_disk_lvm(prefix)
  771. def qrexec_policy(self, service, source, destination, allow=True,
  772. action=None):
  773. """
  774. Allow qrexec calls for duration of the test
  775. :param service: service name
  776. :param source: source VM name
  777. :param destination: destination VM name
  778. :param allow: add rule with 'allow' action, otherwise 'deny'
  779. :param action: custom action, if specified *allow* argument is ignored
  780. :return:
  781. """
  782. return _QrexecPolicyContext(service, source, destination,
  783. allow=allow, action=action)
  784. def wait_for_window(self, title, timeout=30, show=True):
  785. """
  786. Wait for a window with a given title. Depending on show parameter,
  787. it will wait for either window to show or to disappear.
  788. :param title: title of the window to wait for
  789. :param timeout: timeout of the operation, in seconds
  790. :param show: if True - wait for the window to be visible,
  791. otherwise - to not be visible
  792. :return: None
  793. """
  794. wait_count = 0
  795. while subprocess.call(['xdotool', 'search', '--name', title],
  796. stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) \
  797. != int(not show):
  798. wait_count += 1
  799. if wait_count > timeout*10:
  800. self.fail("Timeout while waiting for {} window to {}".format(
  801. title, "show" if show else "hide")
  802. )
  803. self.loop.run_until_complete(asyncio.sleep(0.1))
  804. def enter_keys_in_window(self, title, keys):
  805. """
  806. Search for window with given title, then enter listed keys there.
  807. The function will wait for said window to appear.
  808. :param title: title of window
  809. :param keys: list of keys to enter, as for `xdotool key`
  810. :return: None
  811. """
  812. # 'xdotool search --sync' sometimes crashes on some race when
  813. # accessing window properties
  814. self.wait_for_window(title)
  815. command = ['xdotool', 'search', '--name', title,
  816. 'windowactivate', '--sync',
  817. 'key'] + keys
  818. subprocess.check_call(command)
  819. def shutdown_and_wait(self, vm, timeout=60):
  820. self.loop.run_until_complete(vm.shutdown())
  821. while timeout > 0:
  822. if not vm.is_running():
  823. return
  824. self.loop.run_until_complete(asyncio.sleep(1))
  825. timeout -= 1
  826. name = vm.name
  827. del vm
  828. self.fail("Timeout while waiting for VM {} shutdown".format(name))
  829. def prepare_hvm_system_linux(self, vm, init_script, extra_files=None):
  830. if not os.path.exists('/usr/lib/grub/i386-pc'):
  831. self.skipTest('grub2 not installed')
  832. if not spawn.find_executable('grub2-install'):
  833. self.skipTest('grub2-tools not installed')
  834. if not spawn.find_executable('dracut'):
  835. self.skipTest('dracut not installed')
  836. # create a single partition
  837. p = subprocess.Popen(['sfdisk', '-q', '-L', vm.storage.root_img],
  838. stdin=subprocess.PIPE,
  839. stdout=subprocess.DEVNULL,
  840. stderr=subprocess.STDOUT)
  841. p.communicate('2048,\n')
  842. assert p.returncode == 0, 'sfdisk failed'
  843. # TODO: check if root_img is really file, not already block device
  844. p = subprocess.Popen(['sudo', 'losetup', '-f', '-P', '--show',
  845. vm.storage.root_img], stdout=subprocess.PIPE)
  846. (loopdev, _) = p.communicate()
  847. loopdev = loopdev.strip()
  848. looppart = loopdev + 'p1'
  849. assert p.returncode == 0, 'losetup failed'
  850. subprocess.check_call(['sudo', 'mkfs.ext2', '-q', '-F', looppart])
  851. mountpoint = tempfile.mkdtemp()
  852. subprocess.check_call(['sudo', 'mount', looppart, mountpoint])
  853. try:
  854. subprocess.check_call(['sudo', 'grub2-install',
  855. '--target', 'i386-pc',
  856. '--modules', 'part_msdos ext2',
  857. '--boot-directory', mountpoint, loopdev],
  858. stderr=subprocess.DEVNULL
  859. )
  860. grub_cfg = '{}/grub2/grub.cfg'.format(mountpoint)
  861. subprocess.check_call(
  862. ['sudo', 'chown', '-R', os.getlogin(), mountpoint])
  863. with open(grub_cfg, 'w') as f:
  864. f.write(
  865. "set timeout=1\n"
  866. "menuentry 'Default' {\n"
  867. " linux /vmlinuz root=/dev/xvda1 "
  868. "rd.driver.blacklist=bochs_drm "
  869. "rd.driver.blacklist=uhci_hcd console=hvc0\n"
  870. " initrd /initrd\n"
  871. "}"
  872. )
  873. p = subprocess.Popen(['uname', '-r'], stdout=subprocess.PIPE)
  874. (kernel_version, _) = p.communicate()
  875. kernel_version = kernel_version.strip()
  876. kernel = '/boot/vmlinuz-{}'.format(kernel_version)
  877. shutil.copy(kernel, os.path.join(mountpoint, 'vmlinuz'))
  878. init_path = os.path.join(mountpoint, 'init')
  879. with open(init_path, 'w') as f:
  880. f.write(init_script)
  881. os.chmod(init_path, 0o755)
  882. dracut_args = [
  883. '--kver', kernel_version,
  884. '--include', init_path,
  885. '/usr/lib/dracut/hooks/pre-pivot/initscript.sh',
  886. '--no-hostonly', '--nolvmconf', '--nomdadmconf',
  887. ]
  888. if extra_files:
  889. dracut_args += ['--install', ' '.join(extra_files)]
  890. subprocess.check_call(
  891. ['dracut'] + dracut_args + [os.path.join(mountpoint,
  892. 'initrd')],
  893. stderr=subprocess.DEVNULL
  894. )
  895. finally:
  896. subprocess.check_call(['sudo', 'umount', mountpoint])
  897. shutil.rmtree(mountpoint)
  898. subprocess.check_call(['sudo', 'losetup', '-d', loopdev])
  899. def create_bootable_iso(self):
  900. '''Create simple bootable ISO image.
  901. Type 'poweroff' to it to terminate that VM.
  902. '''
  903. isolinux_cfg = (
  904. 'prompt 1\n'
  905. 'label poweroff\n'
  906. ' kernel poweroff.c32\n'
  907. )
  908. output_fd, output_path = tempfile.mkstemp('.iso')
  909. with tempfile.TemporaryDirectory() as tmp_dir:
  910. try:
  911. shutil.copy('/usr/share/syslinux/isolinux.bin', tmp_dir)
  912. shutil.copy('/usr/share/syslinux/ldlinux.c32', tmp_dir)
  913. shutil.copy('/usr/share/syslinux/poweroff.c32', tmp_dir)
  914. with open(os.path.join(tmp_dir, 'isolinux.cfg'), 'w') as cfg:
  915. cfg.write(isolinux_cfg)
  916. subprocess.check_call(['genisoimage', '-o', output_path,
  917. '-c', 'boot.cat',
  918. '-b', 'isolinux.bin',
  919. '-no-emul-boot',
  920. '-boot-load-size', '4',
  921. '-boot-info-table',
  922. '-q',
  923. tmp_dir])
  924. except FileNotFoundError:
  925. self.skipTest('syslinux or genisoimage not installed')
  926. os.close(output_fd)
  927. self.addCleanup(os.unlink, output_path)
  928. return output_path
  929. def create_local_file(self, filename, content, mode='w'):
  930. with open(filename, mode) as file:
  931. file.write(content)
  932. self.addCleanup(os.unlink, filename)
  933. def create_remote_file(self, vm, filename, content):
  934. self.loop.run_until_complete(vm.run_for_stdio(
  935. 'cat > {}'.format(shlex.quote(filename)),
  936. user='root', input=content.encode('utf-8')))
  937. @asyncio.coroutine
  938. def wait_for_session(self, vm):
  939. yield from asyncio.wait_for(
  940. vm.run_service_for_stdio(
  941. 'qubes.WaitForSession', input=vm.default_user.encode()),
  942. timeout=30)
  943. _templates = None
  944. def list_templates():
  945. '''Returns tuple of template names available in the system.'''
  946. global _templates
  947. if _templates is None:
  948. try:
  949. app = qubes.Qubes()
  950. _templates = tuple(vm.name for vm in app.domains
  951. if isinstance(vm, qubes.vm.templatevm.TemplateVM))
  952. app.close()
  953. del app
  954. except OSError:
  955. _templates = ()
  956. return _templates
  957. def extra_info(obj):
  958. '''Return short info identifying object.
  959. For example, if obj is a qube, return its name. This is for use with
  960. :py:mod:`objgraph` package.
  961. '''
  962. # Feel free to extend to other cases.
  963. if isinstance(obj, qubes.vm.qubesvm.QubesVM):
  964. try:
  965. return obj.name
  966. except AttributeError:
  967. pass
  968. if isinstance(obj, unittest.TestCase):
  969. return obj.id()
  970. return ''
  971. def load_tests(loader, tests, pattern): # pylint: disable=unused-argument
  972. # discard any tests from this module, because it hosts base classes
  973. tests = unittest.TestSuite()
  974. for modname in (
  975. # unit tests
  976. 'qubes.tests.events',
  977. 'qubes.tests.devices',
  978. 'qubes.tests.devices_block',
  979. 'qubes.tests.firewall',
  980. 'qubes.tests.init',
  981. 'qubes.tests.vm.init',
  982. 'qubes.tests.storage',
  983. 'qubes.tests.storage_file',
  984. 'qubes.tests.storage_lvm',
  985. 'qubes.tests.storage_kernels',
  986. 'qubes.tests.ext',
  987. 'qubes.tests.vm.qubesvm',
  988. 'qubes.tests.vm.mix.net',
  989. 'qubes.tests.vm.adminvm',
  990. 'qubes.tests.vm.appvm',
  991. 'qubes.tests.vm.dispvm',
  992. 'qubes.tests.app',
  993. 'qubes.tests.tarwriter',
  994. 'qubes.tests.api',
  995. 'qubes.tests.api_admin',
  996. 'qubes.tests.api_misc',
  997. 'qubespolicy.tests',
  998. 'qubespolicy.tests.cli',
  999. ):
  1000. tests.addTests(loader.loadTestsFromName(modname))
  1001. # GTK/Glib is way too old there
  1002. if 'TRAVIS' not in os.environ:
  1003. for modname in (
  1004. 'qubespolicy.tests.gtkhelpers',
  1005. 'qubespolicy.tests.rpcconfirmation',
  1006. ):
  1007. tests.addTests(loader.loadTestsFromName(modname))
  1008. tests.addTests(loader.discover(
  1009. os.path.join(os.path.dirname(__file__), 'tools')))
  1010. if not in_dom0:
  1011. return tests
  1012. for modname in (
  1013. # integration tests
  1014. 'qubes.tests.integ.basic',
  1015. 'qubes.tests.integ.storage',
  1016. 'qubes.tests.integ.pvgrub',
  1017. 'qubes.tests.integ.devices_pci',
  1018. 'qubes.tests.integ.dom0_update',
  1019. 'qubes.tests.integ.network',
  1020. 'qubes.tests.integ.dispvm',
  1021. 'qubes.tests.integ.vm_qrexec_gui',
  1022. 'qubes.tests.integ.salt',
  1023. 'qubes.tests.integ.backup',
  1024. 'qubes.tests.integ.backupcompatibility',
  1025. # 'qubes.tests.regressions',
  1026. # external modules
  1027. 'qubes.tests.extra',
  1028. ):
  1029. tests.addTests(loader.loadTestsFromName(modname))
  1030. return tests