lib/portage/repository/storage/hardlink_quarantine.py

# Copyright 2018-2021 Gentoo Authors
# Distributed under the terms of the GNU General Public License v2

from portage import os
from portage.repository.storage.interface import (
	RepoStorageException,
	RepoStorageInterface,
)
from portage.util.futures import asyncio

from _emerge.SpawnProcess import SpawnProcess


class HardlinkQuarantineRepoStorage(RepoStorageInterface):
	"""
	This is the default storage module, since its quite compatible with
	most configurations.

	It's desirable to be able to create shared hardlinks between the
	download directory and the normal repository, and this is facilitated
	by making the download directory be a subdirectory of the normal
	repository location (ensuring that no mountpoints are crossed).
	Shared hardlinks are created by using the rsync --link-dest option.

	Since the download is initially unverified, it is safest to save
	it in a quarantine directory. The quarantine directory is also
	useful for making the repository update more atomic, so that it
	less likely that normal repository location will be observed in
	a partially synced state.
	"""
	def __init__(self, repo, spawn_kwargs):
		self._user_location = repo.location
		self._update_location = None
		self._spawn_kwargs = spawn_kwargs
		self._current_update = None

	async def _check_call(self, cmd):
		"""
		Run cmd and raise RepoStorageException on failure.

		@param cmd: command to executre
		@type cmd: list
		"""
		p = SpawnProcess(args=cmd, scheduler=asyncio.get_event_loop(), **self._spawn_kwargs)
		p.start()
		if await p.async_wait() != os.EX_OK:
			raise RepoStorageException('command exited with status {}: {}'.\
				format(p.returncode, ' '.join(cmd)))

	async def init_update(self):
		update_location = os.path.join(self._user_location, '.tmp-unverified-download-quarantine')
		await self._check_call(['rm', '-rf', update_location])

		# Use  rsync --link-dest to hardlink a files into self._update_location,
		# since cp -l is not portable.
		await self._check_call(['rsync', '-a', '--link-dest', self._user_location,
			'--exclude=/distfiles', '--exclude=/local', '--exclude=/lost+found', '--exclude=/packages',
			'--exclude', '/{}'.format(os.path.basename(update_location)),
			self._user_location + '/', update_location + '/'])

		self._update_location = update_location

		return self._update_location

	@property
	def current_update(self):
		if self._update_location is None:
			raise RepoStorageException('current update does not exist')
		return self._update_location

	async def commit_update(self):
		update_location = self.current_update
		self._update_location = None
		await self._check_call(['rsync', '-a', '--delete',
			'--exclude=/distfiles', '--exclude=/local', '--exclude=/lost+found', '--exclude=/packages',
			'--exclude', '/{}'.format(os.path.basename(update_location)),
			update_location + '/', self._user_location + '/'])

		await self._check_call(['rm', '-rf', update_location])

	async def abort_update(self):
		if self._update_location is not None:
			update_location = self._update_location
			self._update_location = None
			await self._check_call(['rm', '-rf', update_location])

	async def garbage_collection(self):
		await self.abort_update()