441 lines
17 KiB
Python
441 lines
17 KiB
Python
import logging
|
|
import os
|
|
import re
|
|
|
|
import sau
|
|
import sau.helpers
|
|
import sau.services
|
|
|
|
EIX_SYNC_PATH='/usr/bin/eix-sync'
|
|
RC_SERVICE_PATH='/sbin/rc-service'
|
|
SYSTEMCTL='/usr/bin/systemctl'
|
|
EMERGE_PATH='/usr/bin/emerge'
|
|
EQUERY_PATH='/usr/bin/equery'
|
|
EMAINT_PATH='/usr/sbin/emaint'
|
|
PCLEAN_PATH='/usr/bin/perl-cleaner'
|
|
GRUB_MKCONFIG='/usr/sbin/grub-mkconfig'
|
|
|
|
# parsing output from eix -Ttnc
|
|
package_re = re.compile(r'^\[([^\]])\] ([^ ]*) \((.*)\): .*$')
|
|
# parsing version information from substrings of the above
|
|
slot_re = re.compile(r'^(\(~\))?([^\(]+)(\([^\)]+\))$')
|
|
|
|
def identify_service_from_bin(exe):
|
|
log = logging.getLogger(sau.LOGNAME)
|
|
|
|
if sau.services.on_systemd():
|
|
init_script_re = re.compile(r'[^/]*(.*)\.service$')
|
|
else:
|
|
init_script_re = re.compile(r'/etc/init\.d/(.*)')
|
|
|
|
cmd = [ EQUERY_PATH, '-Cq', 'b', exe ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd)
|
|
|
|
if ret != 0:
|
|
raise sau.errors.UnknownServiceError("searching for owner of {} failed:".format(exe))
|
|
|
|
pkg = out.strip()
|
|
cmd = [ EQUERY_PATH, '-Cq', 'f', pkg ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd)
|
|
|
|
if ret != 0:
|
|
log.warning("listing files for package {} failed:".format(pkg))
|
|
for line in out.splitlines():
|
|
log.warning("stdout: {}".format(line))
|
|
for line in err.splitlines():
|
|
log.warning("stderr: {}".format(line))
|
|
return None
|
|
matches = set()
|
|
for line in out.splitlines():
|
|
match = re.match(init_script_re, line)
|
|
if match:
|
|
matches.add(match.group(1))
|
|
if len(matches) < 1:
|
|
raise sau.errors.UnknownServiceError('Could not find any init script in package {}'.format(pkg))
|
|
elif len(matches) > 1:
|
|
raise sau.errors.UnknownServiceError('Found multiple init script in package {}'.format(pkg))
|
|
else:
|
|
return matches.pop()
|
|
return None
|
|
|
|
|
|
def restart_service(service):
|
|
log = logging.getLogger(sau.LOGNAME)
|
|
if sau.services.on_systemd():
|
|
cmd = [ SYSTEMCTL, 'restart', service ]
|
|
else:
|
|
cmd = [ RC_SERVICE_PATH, service, 'restart' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd)
|
|
|
|
if ret != 0:
|
|
log.warning("Restart of {} failed:".format(service))
|
|
for line in out.splitlines():
|
|
log.warning("stdout: {}".format(line))
|
|
for line in err.splitlines():
|
|
log.warning("stderr: {}".format(line))
|
|
else:
|
|
log.info("restarted service {}".format(service))
|
|
|
|
def system_upgrade():
|
|
log = logging.getLogger(sau.LOGNAME)
|
|
log.debug('Gentoo "system_upgrade" is done at package upgrade stage; ignoring here...')
|
|
return False
|
|
|
|
def _sync_portage():
|
|
log = logging.getLogger(sau.LOGNAME)
|
|
|
|
if os.path.exists(EIX_SYNC_PATH):
|
|
cmd = [ EIX_SYNC_PATH, '-q' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=3600)
|
|
else:
|
|
cmd = [ EMERGE_PATH, '-q', '--sync' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=3600)
|
|
|
|
if ret != 0:
|
|
log.error("Portage sync failed:")
|
|
for line in out.splitlines():
|
|
log.error("stdout: {}".format(line))
|
|
for line in err.splitlines():
|
|
log.error("stderr: {}".format(line))
|
|
raise sau.errors.UpgradeError(f'Sync command {cmd} failed')
|
|
|
|
cmd = [ EMAINT_PATH, '-f', 'all' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=3600)
|
|
|
|
if ret != 0:
|
|
log.warning("emaint failed:")
|
|
for line in out.splitlines():
|
|
log.warning("stdout: {}".format(line))
|
|
for line in err.splitlines():
|
|
log.warning("stderr: {}".format(line))
|
|
|
|
def is_system_package(atom, eclasses):
|
|
log = logging.getLogger(sau.LOGNAME)
|
|
name=re.sub(r'^[<=>]*(.*?)(?:-\d)?(?:::\w+)?$', r'\1', atom)
|
|
|
|
# sys-boot/ category should probably always be considered
|
|
# system-packages
|
|
if name.split('/')[0] == 'sys-boot':
|
|
log.debug(f"{name} is a sys-boot package")
|
|
return True
|
|
|
|
if eclasses is True:
|
|
return True
|
|
|
|
# libc-packages should be considered system-packages as they generally
|
|
# requires the system to be restarted. Not sure if there is a better way
|
|
# then just checking for specific packages here, but as far as I know there
|
|
# are not many of them anyway...
|
|
if re.search(r'^sys-libs/(glibc|musl)', name):
|
|
log.debug(f"{name} is a libc package")
|
|
return True
|
|
|
|
if any([
|
|
x in eclasses for x in [
|
|
'dist-kernel-utils',
|
|
'linux-mod',
|
|
'kernel-install' ]
|
|
]):
|
|
log.debug(f"{name} is of system eclass (eclasses: {eclasses})")
|
|
return True
|
|
return False
|
|
|
|
def get_eclasses(atom):
|
|
log = logging.getLogger(sau.LOGNAME)
|
|
eclasses = []
|
|
name=re.sub(r'^[<=>]*(.*?)(?:-\d+)?(?:::\w+)?$', r'\1', atom)
|
|
test_re = re.compile(r'^\s*inherit\s+')
|
|
cmd=[ EQUERY_PATH, 'w', name ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd)
|
|
if not ret == 0:
|
|
log.warning(f'Unable to locate ebuild for {atom}')
|
|
# better safe than sorry; if we don't know, let's pretend it's a system
|
|
# package
|
|
return True
|
|
path = out.strip()
|
|
if not os.path.isfile(path):
|
|
log.warning(f"This path doesn't look lika a path to the ebuild for {name}: {path}")
|
|
return True
|
|
with open(path, 'r', encoding='utf-8') as f:
|
|
for line in f.readlines():
|
|
if eclasses and eclasses[-1] == '\\':
|
|
eclasses = eclasses[:-1]
|
|
eclasses.extend(line.split())
|
|
if re.search(test_re, line):
|
|
if re.search(test_re, line):
|
|
eclasses.extend(line.split()[1:])
|
|
|
|
# Remove revisions from eclasses, hopefully makes it less messy if they get
|
|
# updated
|
|
eclasses = [re.sub(r'^(.*?)-r\d+', r'\1', x) for x in eclasses]
|
|
return eclasses
|
|
|
|
def get_dependencies(atom):
|
|
cmd=[ EQUERY_PATH, '-q', 'd', '-F', '$cp', atom ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd)
|
|
dependencies = [l.strip() for l in out.splitlines()]
|
|
return dependencies
|
|
|
|
|
|
def pkg_upgrade():
|
|
log = logging.getLogger(sau.LOGNAME)
|
|
conf = sau.config
|
|
do_system_upgrade = conf.getboolean('default', 'do_system_upgrade', fallback=False)
|
|
|
|
if conf.getboolean('default', 'do_reposync', fallback=True):
|
|
_sync_portage()
|
|
|
|
# [ebuild U ] media-plugins/alsa-plugins-1.1.8 [1.1.6]
|
|
pretend_re = re.compile(r'^\[(?:ebuild|binary) ([^\]]*)\] ([^ ]+?)-(\d[-\.\w]*)( \[[^\]]+\])?')
|
|
ignore_re = re.compile(r'^(|.*caus.* rebuilds.*|.*scheduled for merge.*|.*waiting for lock on.*)$')
|
|
|
|
default_version_sens = conf.getint('default', 'version_sensitivity', fallback=1)
|
|
|
|
## Query upgradeable packages
|
|
cmd = [ EMERGE_PATH, '--color', 'n', '-uDNpq', '--with-bdeps=y', '@world' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd)
|
|
|
|
if not ret == 0:
|
|
log.error('emerge pretend returned {}'.format(ret))
|
|
for line in out.splitlines():
|
|
log.error('stdout: {}'.format(line))
|
|
for line in err.splitlines():
|
|
log.error('stderr: {}'.format(line))
|
|
raise sau.errors.UpgradeError(f'Failed to calculate upgrade path')
|
|
|
|
do_rebuild = True
|
|
do_grub = False
|
|
rebuild_packages = {}
|
|
for line in out.splitlines():
|
|
if re.match(ignore_re, line):
|
|
continue
|
|
match = re.match(pretend_re, line)
|
|
if not match:
|
|
log.warning('No match on line: {}'.format(line))
|
|
continue
|
|
status = match.group(1)
|
|
name = match.group(2)
|
|
new = match.group(3)
|
|
old = match.group(4)
|
|
if not old:
|
|
continue
|
|
old = old.strip(' []')
|
|
|
|
sens = conf.getint('packages', name, fallback=default_version_sens)
|
|
common = sau.helpers.version_diff(new, old)
|
|
if sens <= common:
|
|
log.info('{} -- {} -> {} configured level {} <= pkg level {}'.format(name, old, new, sens, common))
|
|
else:
|
|
log.error('{} -- {} -> {} configured level {} > pkg level {}'.format(name, old, new, sens, common))
|
|
do_rebuild = False
|
|
|
|
nameversion = f'{name}-{new}'
|
|
eclasses = get_eclasses(nameversion)
|
|
rebuild_packages[name] = eclasses
|
|
|
|
for package,eclasses in rebuild_packages.items():
|
|
if is_system_package(package, eclasses):
|
|
if do_system_upgrade:
|
|
do_grub = True
|
|
else:
|
|
raise sau.errors.UpgradeError(f"System package {package} has an update, but system upgrade is disabled")
|
|
|
|
if not do_rebuild:
|
|
raise sau.errors.UpgradeError('Some packages require manual attention, did not upgrade')
|
|
|
|
if not rebuild_packages:
|
|
log.info('No packages to upgrade')
|
|
return False
|
|
|
|
## Actual upgrade
|
|
cmd = [ EMERGE_PATH, '--color', 'n', '-uDNq', '--with-bdeps=y', '@world' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=72000)
|
|
|
|
if ret != 0 or err:
|
|
log.error('emerge returned {}'.format(ret))
|
|
for line in out.splitlines():
|
|
log.error('stdout: {}'.format(line))
|
|
for line in err.splitlines():
|
|
log.error('stderr: {}'.format(line))
|
|
raise sau.errors.UpgradeError(f'Error during upgrade')
|
|
else:
|
|
log.info('upgrade complete')
|
|
for line in out.splitlines():
|
|
if line.startswith(' * '):
|
|
log.warning(line)
|
|
|
|
## rebuild as needed
|
|
do_rebuild = conf.getboolean('default', 'do_rebuilds', fallback=True)
|
|
if do_rebuild:
|
|
# from here on we shouldn't need to rebuild the upgraded packages again
|
|
exclude_list = ' --exclude '.join(rebuild_packages.keys()).split()
|
|
|
|
# Rebuild go
|
|
go_packages = []
|
|
cmd = None
|
|
for package,eclasses in rebuild_packages.items():
|
|
if 'go-module' in eclasses or package == 'dev-lang/go':
|
|
go_packages.append(package)
|
|
if 'dev-lang/go' in go_packages:
|
|
log.info("Running golang-rebuild due to update of dev-lang/go")
|
|
cmd = [
|
|
EMERGE_PATH,
|
|
'--color', 'n',
|
|
'-q',
|
|
'--usepkg', 'n',
|
|
'@golang-rebuild',
|
|
'--exclude' ] + exclude_list
|
|
elif go_packages:
|
|
dependencies = []
|
|
for package in go_packages:
|
|
dependencies.extend(get_dependencies(package))
|
|
dependencies = set(dependencies)
|
|
upgraded = set(rebuild_packages.keys())
|
|
not_upgraded = dependencies-upgraded
|
|
if not_upgraded:
|
|
log.info(f'Rebuilding packages dependant of go modules {", ".join(go_packages)}')
|
|
cmd = [
|
|
EMERGE_PATH,
|
|
'--color', 'n',
|
|
'-q',
|
|
'--usepkg', 'n'] + not_upgraded
|
|
if cmd:
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=72000)
|
|
if ret != 0 or err:
|
|
log.error('Rebuild of go packages returned {}'.format(ret))
|
|
for line in out.splitlines():
|
|
log.error('stdout: {}'.format(line))
|
|
for line in err.splitlines():
|
|
log.error('stderr: {}'.format(line))
|
|
raise sau.errors.UpgradeError(f'Error during go rebuild')
|
|
else:
|
|
log.info('go rebuild complete')
|
|
for line in out.splitlines():
|
|
if line.startswith(' * '):
|
|
log.warning(line)
|
|
|
|
# rebuild rust
|
|
if any([x in rebuild_packages for x in ('dev-lang/rust', 'dev-lang/rust-bin')]):
|
|
log.info("Running rust-rebuild due to update of rust")
|
|
cmd = [
|
|
EMERGE_PATH,
|
|
'--color', 'n',
|
|
'-q',
|
|
'--usepkg', 'n',
|
|
'@rust-rebuild',
|
|
'--exclude' ] + exclude_list
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=72000)
|
|
if ret != 0 or err:
|
|
log.error('Rebuild of rust packages returned {}'.format(ret))
|
|
for line in out.splitlines():
|
|
log.error('stdout: {}'.format(line))
|
|
for line in err.splitlines():
|
|
log.error('stderr: {}'.format(line))
|
|
raise sau.errors.UpgradeError(f'Error during rust rebuild')
|
|
else:
|
|
log.info('rust rebuild complete')
|
|
for line in out.splitlines():
|
|
if line.startswith(' * '):
|
|
log.warning(line)
|
|
|
|
# run perl-cleaner
|
|
if 'dev-lang/perl' in rebuild_packages:
|
|
log.info("Running perl-cleaner due to perl upgrade")
|
|
cmd = [ PCLEAN_PATH, '--all', '--', '-q', '--usepkg', 'n']
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=72000)
|
|
if ret != 0 or err:
|
|
log.error('perl-cleaner failed with code {}'.format(ret))
|
|
for line in out.splitlines():
|
|
log.error('stdout: {}'.format(line))
|
|
for line in err.splitlines():
|
|
log.error('stderr: {}'.format(line))
|
|
raise sau.errors.UpgradeError(f'Error during perl-cleaner')
|
|
else:
|
|
log.info('perl-cleaner complete')
|
|
for line in out.splitlines():
|
|
if line.startswith(' * '):
|
|
log.warning(line)
|
|
|
|
# rebuild live packages
|
|
cmd = [ EMERGE_PATH, '--color', 'n', '-q', '--usepkg', 'n', '@live-rebuild' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=3600)
|
|
if ret != 0 or err:
|
|
log.error('live-rebuild returned {}'.format(ret))
|
|
for line in out.splitlines():
|
|
log.error('stdout: {}'.format(line))
|
|
for line in err.splitlines():
|
|
log.error('stderr: {}'.format(line))
|
|
raise sau.errors.UpgradeError(f'Error during live-rebuild')
|
|
else:
|
|
log.info('live-rebuild complete')
|
|
for line in out.splitlines():
|
|
if line.startswith(' * '):
|
|
log.warning(line)
|
|
|
|
|
|
## Depclean
|
|
if conf.getboolean('default', 'do_depclean', fallback=False):
|
|
cmd = [ EMERGE_PATH, '--color', 'n', '-q', '--depclean' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=3600)
|
|
if ret != 0 or err:
|
|
log.error('depclean returned {}'.format(ret))
|
|
for line in out.splitlines():
|
|
log.error('stdout: {}'.format(line))
|
|
for line in err.splitlines():
|
|
log.error('stderr: {}'.format(line))
|
|
raise sau.errors.UpgradeError(f'Error during depclean')
|
|
else:
|
|
log.info('depclean complete')
|
|
for line in out.splitlines():
|
|
if line.startswith(' * '):
|
|
log.warning(line)
|
|
|
|
|
|
## Preserved rebuild
|
|
cmd = [ EMERGE_PATH, '--color', 'n', '--usepkg', 'n', '-q', '@preserved-rebuild' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd, timeout=72000)
|
|
|
|
if ret != 0 or err:
|
|
log.error('preserved-rebuild returned {}'.format(ret))
|
|
for line in out.splitlines():
|
|
log.error('stdout: {}'.format(line))
|
|
for line in err.splitlines():
|
|
log.error('stderr: {}'.format(line))
|
|
raise sau.errors.UpgradeError(f'Error during preserved-rebuild')
|
|
else:
|
|
log.info('preserved-rebuild complete')
|
|
for line in out.splitlines():
|
|
if line.startswith(' * '):
|
|
log.warning(line)
|
|
|
|
|
|
# doing grub reconfig and clean old kernels
|
|
if do_grub and os.path.exists(GRUB_MKCONFIG):
|
|
keep_kernels = conf.getint('default', 'keep_kernels', fallback=4)
|
|
if keep_kernels < 1:
|
|
log.error('keep_kernels cannot be less than one; falling back to default')
|
|
keep_kernels = 4
|
|
for root, dirs, files in os.walk('/boot'):
|
|
for sysfile in ['config', 'initramfs', 'System.map', 'vmlinuz', 'kernel']:
|
|
match = sorted(
|
|
[f for f in files if f.startswith(f'{sysfile}-')],
|
|
reverse=True,
|
|
key=lambda x: tuple(map(int, x.split('-')[1].split('.')[:3])))
|
|
for f in match[keep_kernels:]:
|
|
log.debug(f"Removing old kernel file {f}")
|
|
os.remove(os.path.join(root, f))
|
|
break
|
|
|
|
cmd = [ GRUB_MKCONFIG, '-o', '/boot/grub/grub.cfg' ]
|
|
ret, out, err = sau.helpers.exec_cmd(cmd)
|
|
if ret != 0:
|
|
log.error(f"grub-mkconfig returned {ret}:")
|
|
for line in out.splitlines():
|
|
log.error('stdout: {}'.format(line))
|
|
for line in err.splitlines():
|
|
log.error('stderr: {}'.format(line))
|
|
raise sau.errors.UpgradeError(f'Failed to reconfiugre grub')
|
|
else:
|
|
log.info("grub reconfigured")
|
|
return True
|