__init__.py 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852
  1. #
  2. # The Qubes OS Project, https://www.qubes-os.org/
  3. #
  4. # Copyright (C) 2013-2015 Joanna Rutkowska <joanna@invisiblethingslab.com>
  5. # Copyright (C) 2013-2015 Marek Marczykowski-Górecki
  6. # <marmarek@invisiblethingslab.com>
  7. # Copyright (C) 2015 Wojtek Porczyk <woju@invisiblethingslab.com>
  8. #
  9. # This program is free software; you can redistribute it and/or modify
  10. # it under the terms of the GNU General Public License as published by
  11. # the Free Software Foundation; either version 2 of the License, or
  12. # (at your option) any later version.
  13. #
  14. # This program is distributed in the hope that it will be useful,
  15. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. # GNU General Public License for more details.
  18. #
  19. # You should have received a copy of the GNU General Public License along
  20. # with this program; if not, write to the Free Software Foundation, Inc.,
  21. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  22. #
  23. """ Qubes storage system"""
  24. from __future__ import absolute_import
  25. import inspect
  26. import os
  27. import os.path
  28. import string # pylint: disable=deprecated-module
  29. import time
  30. from datetime import datetime
  31. import asyncio
  32. import lxml.etree
  33. import pkg_resources
  34. import qubes
  35. import qubes.exc
  36. import qubes.utils
  37. STORAGE_ENTRY_POINT = 'qubes.storage'
  38. class StoragePoolException(qubes.exc.QubesException):
  39. ''' A general storage exception '''
  40. pass
  41. class BlockDevice(object):
  42. ''' Represents a storage block device. '''
  43. # pylint: disable=too-few-public-methods
  44. def __init__(self, path, name, script=None, rw=True, domain=None,
  45. devtype='disk'):
  46. assert name, 'Missing device name'
  47. assert path, 'Missing device path'
  48. self.path = path
  49. self.name = name
  50. self.rw = rw
  51. self.script = script
  52. self.domain = domain
  53. self.devtype = devtype
  54. class Volume(object):
  55. ''' Encapsulates all data about a volume for serialization to qubes.xml and
  56. libvirt config.
  57. Keep in mind!
  58. volatile = not snap_on_start and not save_on_stop
  59. snapshot = snap_on_start and not save_on_stop
  60. origin = not snap_on_start and save_on_stop
  61. origin_snapshot = snap_on_start and save_on_stop
  62. '''
  63. devtype = 'disk'
  64. domain = None
  65. path = None
  66. script = None
  67. #: disk space used by this volume, can be smaller than :py:attr:`size`
  68. #: for sparse volumes
  69. usage = 0
  70. def __init__(self, name, pool, vid,
  71. revisions_to_keep=0, rw=False, save_on_stop=False, size=0,
  72. snap_on_start=False, source=None, **kwargs):
  73. ''' Initialize a volume.
  74. :param str name: The name of the volume inside owning domain
  75. :param Pool pool: The pool object
  76. :param str vid: Volume identifier needs to be unique in pool
  77. :param int revisions_to_keep: Amount of revisions to keep around
  78. :param bool rw: If true volume will be mounted read-write
  79. :param bool snap_on_start: Create a snapshot from source on
  80. start, instead of using volume own data
  81. :param bool save_on_stop: Write changes to the volume in
  82. vm.stop(), otherwise - discard
  83. :param Volume source: other volume in same pool to make snapshot
  84. from, required if *snap_on_start*=`True`
  85. :param str/int size: Size of the volume
  86. '''
  87. super(Volume, self).__init__(**kwargs)
  88. assert isinstance(pool, Pool)
  89. assert source is None or (isinstance(source, Volume)
  90. and source.pool == pool)
  91. if snap_on_start and source is None:
  92. msg = "snap_on_start specified on {!r} but no volume source set"
  93. msg = msg.format(name)
  94. raise StoragePoolException(msg)
  95. elif not snap_on_start and source is not None:
  96. msg = "source specified on {!r} but no snap_on_start set"
  97. msg = msg.format(name)
  98. raise StoragePoolException(msg)
  99. #: Name of the volume in a domain it's attached to (like `root` or
  100. #: `private`).
  101. self.name = str(name)
  102. #: :py:class:`Pool` instance owning this volume
  103. self.pool = pool
  104. #: How many revisions of the volume to keep. Each revision is created
  105. # at :py:meth:`stop`, if :py:attr:`save_on_stop` is True
  106. self.revisions_to_keep = int(revisions_to_keep)
  107. #: Should this volume be writable by domain.
  108. self.rw = rw
  109. #: Should volume state be saved or discarded at :py:meth:`stop`
  110. self.save_on_stop = save_on_stop
  111. self._size = int(size)
  112. #: Should the volume state be initialized with a snapshot of
  113. #: same-named volume of domain's template.
  114. self.snap_on_start = snap_on_start
  115. #: source volume for :py:attr:`snap_on_start` volumes
  116. self.source = source
  117. #: Volume unique (inside given pool) identifier
  118. self.vid = vid
  119. def __eq__(self, other):
  120. if isinstance(other, Volume):
  121. return other.pool == self.pool and other.vid == self.vid
  122. return NotImplemented
  123. def __hash__(self):
  124. return hash('%s:%s' % (self.pool, self.vid))
  125. def __neq__(self, other):
  126. return not self.__eq__(other)
  127. def __repr__(self):
  128. return '{!r}'.format(str(self.pool) + ':' + self.vid)
  129. def __str__(self):
  130. return str(self.vid)
  131. def __xml__(self):
  132. config = _sanitize_config(self.config)
  133. return lxml.etree.Element('volume', **config)
  134. def create(self):
  135. ''' Create the given volume on disk.
  136. This method is called only once in the volume lifetime. Before
  137. calling this method, no data on disk should be touched (in
  138. context of this volume).
  139. This can be implemented as a coroutine.
  140. '''
  141. raise self._not_implemented("create")
  142. def remove(self):
  143. ''' Remove volume.
  144. This can be implemented as a coroutine.'''
  145. raise self._not_implemented("remove")
  146. def export(self):
  147. ''' Returns a path to read the volume data from.
  148. Reading from this path when domain owning this volume is
  149. running (i.e. when :py:meth:`is_dirty` is True) should return the
  150. data from before domain startup.
  151. Reading from the path returned by this method should return the
  152. volume data. If extracting volume data require something more
  153. than just reading from file (for example connecting to some other
  154. domain, or decompressing the data), the returned path may be a pipe.
  155. '''
  156. raise self._not_implemented("export")
  157. def import_data(self):
  158. ''' Returns a path to overwrite volume data.
  159. This method is called after volume was already :py:meth:`create`-ed.
  160. Writing to this path should overwrite volume data. If importing
  161. volume data require something more than just writing to a file (
  162. for example connecting to some other domain, or converting data
  163. on the fly), the returned path may be a pipe.
  164. '''
  165. raise self._not_implemented("import")
  166. def import_data_end(self, success):
  167. ''' End the data import operation. This may be used by pool
  168. implementation to commit changes, cleanup temporary files etc.
  169. This method is called regardless the operation was successful or not.
  170. :param success: True if data import was successful, otherwise False
  171. '''
  172. # by default do nothing
  173. pass
  174. def import_volume(self, src_volume):
  175. ''' Imports data from a different volume (possibly in a different
  176. pool.
  177. The volume needs to be create()d first.
  178. This can be implemented as a coroutine. '''
  179. # pylint: disable=unused-argument
  180. raise self._not_implemented("import_volume")
  181. def is_dirty(self):
  182. ''' Return `True` if volume was not properly shutdown and committed.
  183. This include the situation when domain owning the volume is still
  184. running.
  185. '''
  186. raise self._not_implemented("is_dirty")
  187. def is_outdated(self):
  188. ''' Returns `True` if this snapshot of a source volume (for
  189. `snap_on_start`=True) is outdated.
  190. '''
  191. raise self._not_implemented("is_outdated")
  192. def resize(self, size):
  193. ''' Expands volume, throws
  194. :py:class:`qubes.storage.StoragePoolException` if
  195. given size is less than current_size
  196. This can be implemented as a coroutine.
  197. :param int size: new size in bytes
  198. '''
  199. # pylint: disable=unused-argument
  200. raise self._not_implemented("resize")
  201. def revert(self, revision=None):
  202. ''' Revert volume to previous revision
  203. :param revision: revision to revert volume to, see :py:attr:`revisions`
  204. '''
  205. # pylint: disable=unused-argument
  206. raise self._not_implemented("revert")
  207. def start(self):
  208. ''' Do what ever is needed on start.
  209. This include making a snapshot of template's volume if
  210. :py:attr:`snap_on_start` is set.
  211. This can be implemented as a coroutine.'''
  212. raise self._not_implemented("start")
  213. def stop(self):
  214. ''' Do what ever is needed on stop.
  215. This include committing data if :py:attr:`save_on_stop` is set.
  216. This can be implemented as a coroutine.'''
  217. def verify(self):
  218. ''' Verifies the volume.
  219. This can be implemented as a coroutine.'''
  220. raise self._not_implemented("verify")
  221. def block_device(self):
  222. ''' Return :py:class:`BlockDevice` for serialization in
  223. the libvirt XML template as <disk>.
  224. '''
  225. return BlockDevice(self.path, self.name, self.script,
  226. self.rw, self.domain, self.devtype)
  227. @property
  228. def revisions(self):
  229. ''' Returns a dict containing revision identifiers and time of their
  230. creation '''
  231. msg = "{!s} has revisions not implemented".format(self.__class__)
  232. raise NotImplementedError(msg)
  233. @property
  234. def size(self):
  235. ''' Volume size in bytes '''
  236. return self._size
  237. @size.setter
  238. def size(self, size):
  239. # pylint: disable=attribute-defined-outside-init
  240. self._size = int(size)
  241. @property
  242. def config(self):
  243. ''' return config data for serialization to qubes.xml '''
  244. result = {
  245. 'name': self.name,
  246. 'pool': str(self.pool),
  247. 'vid': self.vid,
  248. 'revisions_to_keep': self.revisions_to_keep,
  249. 'rw': self.rw,
  250. 'save_on_stop': self.save_on_stop,
  251. 'snap_on_start': self.snap_on_start,
  252. }
  253. if self.size:
  254. result['size'] = self.size
  255. if self.source:
  256. result['source'] = str(self.source)
  257. return result
  258. def _not_implemented(self, method_name):
  259. ''' Helper for emitting helpful `NotImplementedError` exceptions '''
  260. msg = "Volume {!s} has {!s}() not implemented"
  261. msg = msg.format(str(self.__class__.__name__), method_name)
  262. return NotImplementedError(msg)
  263. class Storage(object):
  264. ''' Class for handling VM virtual disks.
  265. This is base class for all other implementations, mostly with Xen on Linux
  266. in mind.
  267. '''
  268. AVAILABLE_FRONTENDS = set(['xvd' + c for c in string.ascii_lowercase])
  269. def __init__(self, vm):
  270. #: Domain for which we manage storage
  271. self.vm = vm
  272. self.log = self.vm.log
  273. #: Additional drive (currently used only by HVM)
  274. self.drive = None
  275. if hasattr(vm, 'volume_config'):
  276. for name, conf in self.vm.volume_config.items():
  277. self.init_volume(name, conf)
  278. def _update_volume_config_source(self, name, volume_config):
  279. '''Retrieve 'source' volume from VM's template'''
  280. template = getattr(self.vm, 'template', None)
  281. # recursively lookup source volume - templates may be
  282. # chained (TemplateVM -> AppVM -> DispVM, where the
  283. # actual source should be used from TemplateVM)
  284. while template:
  285. source = template.volumes[name]
  286. volume_config['source'] = source
  287. volume_config['pool'] = source.pool
  288. volume_config['size'] = source.size
  289. if source.source is not None:
  290. template = getattr(template, 'template', None)
  291. else:
  292. break
  293. def init_volume(self, name, volume_config):
  294. ''' Initialize Volume instance attached to this domain '''
  295. if 'name' not in volume_config:
  296. volume_config['name'] = name
  297. if 'source' in volume_config:
  298. # we have no control over VM load order,
  299. # so initialize storage recursively if needed
  300. template = getattr(self.vm, 'template', None)
  301. if template and template.storage is None:
  302. template.storage = Storage(template)
  303. if volume_config['source'] is None:
  304. self._update_volume_config_source(name, volume_config)
  305. else:
  306. # if source is already specified, pool needs to be too
  307. pool = self.vm.app.get_pool(volume_config['pool'])
  308. volume_config['source'] = pool.volumes[volume_config['source']]
  309. # if pool still unknown, load default
  310. if 'pool' not in volume_config:
  311. volume_config['pool'] = \
  312. getattr(self.vm.app, 'default_pool_' + name)
  313. pool = self.vm.app.get_pool(volume_config['pool'])
  314. if 'internal' in volume_config:
  315. # migrate old config
  316. del volume_config['internal']
  317. volume = pool.init_volume(self.vm, volume_config)
  318. self.vm.volumes[name] = volume
  319. return volume
  320. def attach(self, volume, rw=False):
  321. ''' Attach a volume to the domain '''
  322. assert self.vm.is_running()
  323. if self._is_already_attached(volume):
  324. self.vm.log.info("{!r} already attached".format(volume))
  325. return
  326. try:
  327. frontend = self.unused_frontend()
  328. except IndexError:
  329. raise StoragePoolException("No unused frontend found")
  330. disk = lxml.etree.Element("disk")
  331. disk.set('type', 'block')
  332. disk.set('device', 'disk')
  333. lxml.etree.SubElement(disk, 'driver').set('name', 'phy')
  334. lxml.etree.SubElement(disk, 'source').set('dev', '/dev/%s' % volume.vid)
  335. lxml.etree.SubElement(disk, 'target').set('dev', frontend)
  336. if not rw:
  337. lxml.etree.SubElement(disk, 'readonly')
  338. if volume.domain is not None:
  339. lxml.etree.SubElement(disk, 'backenddomain').set(
  340. 'name', volume.domain.name)
  341. xml_string = lxml.etree.tostring(disk, encoding='utf-8')
  342. self.vm.libvirt_domain.attachDevice(xml_string)
  343. # trigger watches to update device status
  344. # FIXME: this should be removed once libvirt will report such
  345. # events itself
  346. # self.vm.untrusted_qdb.write('/qubes-block-devices', '')
  347. # ← do we need this?
  348. def _is_already_attached(self, volume):
  349. ''' Checks if the given volume is already attached '''
  350. parsed_xml = lxml.etree.fromstring(self.vm.libvirt_domain.XMLDesc())
  351. disk_sources = parsed_xml.xpath("//domain/devices/disk/source")
  352. for source in disk_sources:
  353. if source.get('dev') == '/dev/%s' % volume.vid:
  354. return True
  355. return False
  356. def detach(self, volume):
  357. ''' Detach a volume from domain '''
  358. parsed_xml = lxml.etree.fromstring(self.vm.libvirt_domain.XMLDesc())
  359. disks = parsed_xml.xpath("//domain/devices/disk")
  360. for disk in disks:
  361. source = disk.xpath('source')[0]
  362. if source.get('dev') == '/dev/%s' % volume.vid:
  363. disk_xml = lxml.etree.tostring(disk, encoding='utf-8')
  364. self.vm.libvirt_domain.detachDevice(disk_xml)
  365. return
  366. raise StoragePoolException('Volume {!r} is not attached'.format(volume))
  367. @property
  368. def kernels_dir(self):
  369. '''Directory where kernel resides.
  370. If :py:attr:`self.vm.kernel` is :py:obj:`None`, the this points inside
  371. :py:attr:`self.vm.dir_path`
  372. '''
  373. assert 'kernel' in self.vm.volumes, "VM has no kernel volume"
  374. return self.vm.volumes['kernel'].kernels_dir
  375. def get_disk_utilization(self):
  376. ''' Returns summed up disk utilization for all domain volumes '''
  377. result = 0
  378. for volume in self.vm.volumes.values():
  379. result += volume.usage
  380. return result
  381. @asyncio.coroutine
  382. def resize(self, volume, size):
  383. ''' Resizes volume a read-writable volume '''
  384. if isinstance(volume, str):
  385. volume = self.vm.volumes[volume]
  386. ret = volume.resize(size)
  387. if asyncio.iscoroutine(ret):
  388. yield from ret
  389. if self.vm.is_running():
  390. yield from self.vm.run_service_for_stdio('qubes.ResizeDisk',
  391. input=volume.name.encode(),
  392. user='root')
  393. @asyncio.coroutine
  394. def create(self):
  395. ''' Creates volumes on disk '''
  396. old_umask = os.umask(0o002)
  397. coros = []
  398. for volume in self.vm.volumes.values():
  399. # launch the operation, if it's asynchronous, then append to wait
  400. # for them at the end
  401. ret = volume.create()
  402. if asyncio.iscoroutine(ret):
  403. coros.append(ret)
  404. if coros:
  405. yield from asyncio.wait(coros)
  406. os.umask(old_umask)
  407. @asyncio.coroutine
  408. def clone_volume(self, src_vm, name):
  409. ''' Clone single volume from the specified vm
  410. :param QubesVM src_vm: source VM
  411. :param str name: name of volume to clone ('root', 'private' etc)
  412. :return cloned volume object
  413. '''
  414. config = self.vm.volume_config[name]
  415. dst_pool = self.vm.app.get_pool(config['pool'])
  416. dst = dst_pool.init_volume(self.vm, config)
  417. src_volume = src_vm.volumes[name]
  418. msg = "Importing volume {!s} from vm {!s}"
  419. self.vm.log.info(msg.format(src_volume.name, src_vm.name))
  420. # First create the destination volume
  421. create_op_ret = dst.create()
  422. # clone/import functions may be either synchronous or asynchronous
  423. # in the later case, we need to wait for them to finish
  424. if asyncio.iscoroutine(create_op_ret):
  425. yield from create_op_ret
  426. # Then import data from source volume
  427. clone_op_ret = dst.import_volume(src_volume)
  428. # clone/import functions may be either synchronous or asynchronous
  429. # in the later case, we need to wait for them to finish
  430. if asyncio.iscoroutine(clone_op_ret):
  431. yield from clone_op_ret
  432. self.vm.volumes[name] = dst
  433. return self.vm.volumes[name]
  434. @asyncio.coroutine
  435. def clone(self, src_vm):
  436. ''' Clone volumes from the specified vm '''
  437. self.vm.volumes = {}
  438. with VmCreationManager(self.vm):
  439. yield from asyncio.wait([self.clone_volume(src_vm, vol_name)
  440. for vol_name in self.vm.volume_config.keys()])
  441. @property
  442. def outdated_volumes(self):
  443. ''' Returns a list of outdated volumes '''
  444. result = []
  445. if self.vm.is_halted():
  446. return result
  447. volumes = self.vm.volumes
  448. for volume in volumes.values():
  449. if volume.is_outdated():
  450. result += [volume]
  451. return result
  452. @asyncio.coroutine
  453. def verify(self):
  454. '''Verify that the storage is sane.
  455. On success, returns normally. On failure, raises exception.
  456. '''
  457. if not os.path.exists(self.vm.dir_path):
  458. raise qubes.exc.QubesVMError(
  459. self.vm,
  460. 'VM directory does not exist: {}'.format(self.vm.dir_path))
  461. futures = []
  462. for volume in self.vm.volumes.values():
  463. ret = volume.verify()
  464. if asyncio.iscoroutine(ret):
  465. futures.append(ret)
  466. if futures:
  467. yield from asyncio.wait(futures)
  468. self.vm.fire_event('domain-verify-files')
  469. return True
  470. @asyncio.coroutine
  471. def remove(self):
  472. ''' Remove all the volumes.
  473. Errors on removal are catched and logged.
  474. '''
  475. futures = []
  476. for name, volume in self.vm.volumes.items():
  477. self.log.info('Removing volume %s: %s' % (name, volume.vid))
  478. try:
  479. ret = volume.remove()
  480. if asyncio.iscoroutine(ret):
  481. futures.append(ret)
  482. except (IOError, OSError) as e:
  483. self.vm.log.exception("Failed to remove volume %s", name, e)
  484. if futures:
  485. try:
  486. yield from asyncio.wait(futures)
  487. except (IOError, OSError) as e:
  488. self.vm.log.exception("Failed to remove some volume", e)
  489. @asyncio.coroutine
  490. def start(self):
  491. ''' Execute the start method on each pool '''
  492. futures = []
  493. for volume in self.vm.volumes.values():
  494. ret = volume.start()
  495. if asyncio.iscoroutine(ret):
  496. futures.append(ret)
  497. if futures:
  498. yield from asyncio.wait(futures)
  499. @asyncio.coroutine
  500. def stop(self):
  501. ''' Execute the start method on each pool '''
  502. futures = []
  503. for volume in self.vm.volumes.values():
  504. ret = volume.stop()
  505. if asyncio.iscoroutine(ret):
  506. futures.append(ret)
  507. if futures:
  508. yield from asyncio.wait(futures)
  509. def unused_frontend(self):
  510. ''' Find an unused device name '''
  511. unused_frontends = self.AVAILABLE_FRONTENDS.difference(
  512. self.used_frontends)
  513. return sorted(unused_frontends)[0]
  514. @property
  515. def used_frontends(self):
  516. ''' Used device names '''
  517. xml = self.vm.libvirt_domain.XMLDesc()
  518. parsed_xml = lxml.etree.fromstring(xml)
  519. return set([target.get('dev', None)
  520. for target in parsed_xml.xpath(
  521. "//domain/devices/disk/target")])
  522. def export(self, volume):
  523. ''' Helper function to export volume (pool.export(volume))'''
  524. assert isinstance(volume, (Volume, str)), \
  525. "You need to pass a Volume or pool name as str"
  526. if isinstance(volume, Volume):
  527. return volume.export()
  528. return self.vm.volumes[volume].export()
  529. def import_data(self, volume):
  530. ''' Helper function to import volume data (pool.import_data(volume))'''
  531. assert isinstance(volume, (Volume, str)), \
  532. "You need to pass a Volume or pool name as str"
  533. if isinstance(volume, Volume):
  534. return volume.import_data()
  535. return self.vm.volumes[volume].import_data()
  536. def import_data_end(self, volume, success):
  537. ''' Helper function to finish/cleanup data import
  538. (pool.import_data_end( volume))'''
  539. assert isinstance(volume, (Volume, str)), \
  540. "You need to pass a Volume or pool name as str"
  541. if isinstance(volume, Volume):
  542. return volume.import_data_end(success=success)
  543. return self.vm.volumes[volume].import_data_end(success=success)
  544. class VolumesCollection(object):
  545. '''Convenient collection wrapper for pool.get_volume and
  546. pool.list_volumes
  547. '''
  548. def __init__(self, pool):
  549. self._pool = pool
  550. def __getitem__(self, item):
  551. ''' Get a single volume with given Volume ID.
  552. You can also a Volume instance to get the same Volume or KeyError if
  553. Volume no longer exists.
  554. :param item: a Volume ID (str) or a Volume instance
  555. '''
  556. if isinstance(item, Volume):
  557. if item.pool == self._pool:
  558. return self[item.vid]
  559. else:
  560. raise KeyError(item)
  561. try:
  562. return self._pool.get_volume(item)
  563. except NotImplementedError:
  564. for vol in self:
  565. if vol.vid == item:
  566. return vol
  567. # if list_volumes is not implemented too, it will raise
  568. # NotImplementedError again earlier
  569. raise KeyError(item)
  570. def __iter__(self):
  571. ''' Get iterator over pool's volumes '''
  572. return iter(self._pool.list_volumes())
  573. def __contains__(self, item):
  574. ''' Check if given volume (either Volume ID or Volume instance) is
  575. present in the pool
  576. '''
  577. try:
  578. return self[item] is not None
  579. except KeyError:
  580. return False
  581. def keys(self):
  582. ''' Return list of volume IDs '''
  583. return [vol.vid for vol in self]
  584. def values(self):
  585. ''' Return list of Volumes'''
  586. return [vol for vol in self]
  587. class Pool(object):
  588. ''' A Pool is used to manage different kind of volumes (File
  589. based/LVM/Btrfs/...).
  590. 3rd Parties providing own storage implementations will need to extend
  591. this class.
  592. ''' # pylint: disable=unused-argument
  593. private_img_size = qubes.config.defaults['private_img_size']
  594. root_img_size = qubes.config.defaults['root_img_size']
  595. def __init__(self, name, revisions_to_keep=1, **kwargs):
  596. super(Pool, self).__init__(**kwargs)
  597. self._volumes_collection = VolumesCollection(self)
  598. self.name = name
  599. self.revisions_to_keep = revisions_to_keep
  600. kwargs['name'] = self.name
  601. def __eq__(self, other):
  602. if isinstance(other, Pool):
  603. return self.name == other.name
  604. elif isinstance(other, str):
  605. return self.name == other
  606. return NotImplemented
  607. def __neq__(self, other):
  608. return not self.__eq__(other)
  609. def __str__(self):
  610. return self.name
  611. def __hash__(self):
  612. return hash(self.name)
  613. def __xml__(self):
  614. config = _sanitize_config(self.config)
  615. return lxml.etree.Element('pool', **config)
  616. @property
  617. def config(self):
  618. ''' Returns the pool config to be written to qubes.xml '''
  619. raise self._not_implemented("config")
  620. def destroy(self):
  621. ''' Called when removing the pool. Use this for implementation specific
  622. clean up.
  623. '''
  624. raise self._not_implemented("destroy")
  625. def init_volume(self, vm, volume_config):
  626. ''' Initialize a :py:class:`qubes.storage.Volume` from `volume_config`.
  627. '''
  628. raise self._not_implemented("init_volume")
  629. def setup(self):
  630. ''' Called when adding a pool to the system. Use this for implementation
  631. specific set up.
  632. '''
  633. raise self._not_implemented("setup")
  634. @property
  635. def volumes(self):
  636. ''' Return a collection of volumes managed by this pool '''
  637. return self._volumes_collection
  638. def list_volumes(self):
  639. ''' Return a list of volumes managed by this pool '''
  640. raise self._not_implemented("list_volumes")
  641. def get_volume(self, vid):
  642. ''' Return a volume with *vid* from this pool
  643. :raise KeyError: if no volume is found
  644. '''
  645. raise self._not_implemented("get_volume")
  646. def _not_implemented(self, method_name):
  647. ''' Helper for emitting helpful `NotImplementedError` exceptions '''
  648. msg = "Pool driver {!s} has {!s}() not implemented"
  649. msg = msg.format(str(self.__class__.__name__), method_name)
  650. return NotImplementedError(msg)
  651. def _sanitize_config(config):
  652. ''' Helper function to convert types to appropriate strings
  653. ''' # FIXME: find another solution for serializing basic types
  654. result = {}
  655. for key, value in config.items():
  656. if isinstance(value, bool):
  657. if value:
  658. result[key] = 'True'
  659. else:
  660. result[key] = str(value)
  661. return result
  662. def pool_drivers():
  663. """ Return a list of EntryPoints names """
  664. return [ep.name
  665. for ep in pkg_resources.iter_entry_points(STORAGE_ENTRY_POINT)]
  666. def driver_parameters(name):
  667. ''' Get __init__ parameters from a driver with out `self` & `name`. '''
  668. init_function = qubes.utils.get_entry_point_one(
  669. qubes.storage.STORAGE_ENTRY_POINT, name).__init__
  670. signature = inspect.signature(init_function)
  671. params = signature.parameters.keys()
  672. ignored_params = ['self', 'name', 'kwargs']
  673. return [p for p in params if p not in ignored_params]
  674. def isodate(seconds=time.time()):
  675. ''' Helper method which returns an iso date '''
  676. return datetime.utcfromtimestamp(seconds).isoformat("T")
  677. class VmCreationManager(object):
  678. ''' A `ContextManager` which cleans up if volume creation fails.
  679. ''' # pylint: disable=too-few-public-methods
  680. def __init__(self, vm):
  681. self.vm = vm
  682. def __enter__(self):
  683. pass
  684. def __exit__(self, type, value, tb): # pylint: disable=redefined-builtin
  685. if type is not None and value is not None and tb is not None:
  686. for volume in self.vm.volumes.values():
  687. try:
  688. volume.remove()
  689. except Exception: # pylint: disable=broad-except
  690. pass
  691. os.rmdir(self.vm.dir_path)