prepare for 1.4.0

Instead emit warning about the need to log out and log in again

bin/sau

@@ -115,6 +115,9 @@ def main():
         log.error(f'Upgrade failed: {e}')
         return 1
 
+    if not conf.getboolean('default', 'live_system', fallback=True):
+        return 0
+
     if conf.getboolean('default', 'do_service_restart', fallback=True):
         reboot_recommended = sau.services.restart_services()
 
@@ -124,7 +127,7 @@ def main():
         elif reboot_recommended:
             log.info('Rebooting because service restarts did not close all deleted files')
         if reboot_required or reboot_recommended:
-            fork_and_reboot(report_success=conf.getboolean('default', 'reboot_is_success', Fallback=True))
+            fork_and_reboot(report_success=conf.getboolean('default', 'reboot_is_success', fallback=True))
 
     if reboot_required:
         log.warning("Upgrade was success, but a reboot is required due to a system upgrade")

config.cfg

@@ -12,11 +12,15 @@
 # 1.0.1 -> 1.0.1.1 (3)
 version_sensitivity=1
 
+# Set to no if you're using sau in an environment where running processes
+# shouldn't be touched and reboots shouldn't be done, for example in chroots
+live_system=yes
+
 # sau can reboot on system upgrades (FreeBSD) or if the service restarts does
 # not close all deleted files (any platform)
 do_reboot=no
 
-# Set to 0 to exit with failure code when going for reboot.
+# Set to no to exit with failure code when going for reboot.
 reboot_is_success=yes
 
 # Attempt to do a system upgrade
@@ -41,6 +45,11 @@ do_depclean=yes
 # do eix-sync on Gentoo
 do_reposync=yes
 
+# do live-rebuild, go-rebuild, rust-rebuild, perl-cleaner etc. on Gentoo
+# set to no if using binary packages that are bumped when needed.
+# Leave as yes on package builders and if not using binary packages.
+do_rebuilds=yes
+
 # to only write to stderr when something unexpected happens or manual action is required
 # set stderr_loglevel to warning
 stderr_loglevel=debug

sau/gentoo.py

@@ -4,6 +4,7 @@ import re
 
 import sau
 import sau.helpers
+import sau.services
 
 EIX_SYNC_PATH='/usr/bin/eix-sync'
 RC_SERVICE_PATH='/sbin/rc-service'
@@ -11,21 +12,21 @@ 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('^\[([^\]])\] ([^ ]*) \((.*)\): .*$')
+package_re = re.compile(r'^\[([^\]])\] ([^ ]*) \((.*)\): .*$')
 # parsing version information from substrings of the above
-slot_re = re.compile('^(\(~\))?([^\(]+)(\([^\)]+\))$')
+slot_re = re.compile(r'^(\(~\))?([^\(]+)(\([^\)]+\))$')
 
 def identify_service_from_bin(exe):
     log = logging.getLogger(sau.LOGNAME)
 
-    with open('/proc/1/comm', 'r') as f:
-        if f.readline().strip() == 'systemd':
-            init_script_re = re.compile(r'[^/]*(.*)\.service$')
-        else:
-            init_script_re = re.compile(r'/etc/init\.d/(.*)')
+    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)
@@ -60,11 +61,10 @@ def identify_service_from_bin(exe):
 
 def restart_service(service):
     log = logging.getLogger(sau.LOGNAME)
-    with open('/proc/1/comm', 'r') as f:
-        if f.readline().strip() == 'systemd':
-            cmd = [ SYSTEMCTL, 'restart', service ]
-        else:
-            cmd = [ RC_SERVICE_PATH, service, 'restart' ]
+    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:
@@ -109,7 +109,69 @@ def _sync_portage():
         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
+
+    # 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', name ]
+    ret, out, err = sau.helpers.exec_cmd(cmd)
+    dependencies = [l.strip() for l in out.splitlines()]
+    return dependencies
 
 
 def pkg_upgrade():
@@ -126,6 +188,7 @@ def pkg_upgrade():
     
     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)
 
@@ -139,6 +202,7 @@ def pkg_upgrade():
 
     do_rebuild = True
     do_grub = False
+    rebuild_packages = {}
     for line in out.splitlines():
         if re.match(ignore_re, line):
             continue
@@ -161,15 +225,26 @@ def pkg_upgrade():
         else:
             log.error('{} -- {} -> {} configured level {} > pkg level {}'.format(name, old, new, sens, common))
             do_rebuild = False
-        if name.startswith('sys-kernel/'):
+
+        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"Kernel package {name} has an update, but system upgrade is disabled")
+                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)
 
@@ -186,22 +261,116 @@ def pkg_upgrade():
             if line.startswith(' * '):
                 log.warning(line)
 
-    cmd = [ EMERGE_PATH, '--color', 'n', '-q', '@preserved-rebuild' ]
-    ret, out, err = sau.helpers.exec_cmd(cmd, timeout=72000)
+    ## rebuild as needed
+    do_rebuild = conf.getboolean('default', 'do_rebuilds', fallback=True)
+    if do_rebuilds:
+        # from here on we shouldn't need to rebuild the upgraded packages again
+        exclude_list = ' --exclude '.join(rebuild_packages.keys()).split()
 
-    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)
+        # 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-exclude', '*/*',
+                    '@golang-rebuild',
+                    '--exclude' ] + exclude_list
+        elif go_packages:
+            dependencies = []
+            for package in go_packages:
+                dependencies.append(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-exclude', '*/*'] + 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 'dev-lang/rust' in rebuild_packages:
+            log.info("Running rust-rebuild due to update of dev-lang/rust")
+            cmd = [
+                    EMERGE_PATH,
+                    '--color', 'n',
+                    '-q',
+                    '--usepkg-exclude', '*/*',
+                    '@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-exclude', '*/*']
+            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-exclude', '*/*', '@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)
@@ -218,6 +387,26 @@ def pkg_upgrade():
                 if line.startswith(' * '):
                     log.warning(line)
 
+
+    ## Preserved rebuild
+    cmd = [ EMERGE_PATH, '--color', 'n', '--usepkg-exclude', '*/*', '-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:

sau/services.py

@@ -10,7 +10,7 @@ import sau.errors
 import sau.helpers
 import sau.platforms
 
-proc_fd_map_re = re.compile(r'^.*(/[^\(]*) \(deleted\)$')
+proc_fd_map_re = re.compile(r'^.*(/(?:usr|lib|opt|etc|s?bin)[^\(]*) \(deleted\)$')
 
 def _warn(policy, msg):
     log = logging.getLogger(sau.LOGNAME)
@@ -28,7 +28,8 @@ def get_deleted_open_files(proc):
             for line in f:
                 match = re.match(proc_fd_map_re, line)
                 if match:
-                    files.add(match.group(1))
+                    fname = match.group(1)
+                    files.add(fname)
         return files
 
     # on FreeBSD psutils open_files() helpfully returns a null path if a file
@@ -75,6 +76,16 @@ def _get_processes():
 
     return check_procs
 
+# Just return True if system is running on systemd
+def on_systemd():
+    try:
+        init_proc = psutil.Process(pid=1)
+        if init_proc.name() == 'systemd':
+            return True
+    except psutil.NoSuchProcess:
+        pass
+    return False
+
 def restart_services():
     log = logging.getLogger(sau.LOGNAME)
     platform = sau.platforms.get_platform()
@@ -84,14 +95,6 @@ def restart_services():
     # wait before the second test
     time.sleep(5)
 
-    on_systemd = False
-    try:
-        init_proc = psutil.Process(pid=1)
-        if init_proc.name() == 'systemd':
-            on_systemd = True
-    except psutil.NoSuchProcess:
-        pass
-
     # perform a second check to remove potential false positives
     service_procs = set()
     retest_procs = set()
@@ -105,7 +108,7 @@ def restart_services():
         except (psutil.NoSuchProcess, psutil.ZombieProcess, psutil.AccessDenied):
             # either of the above exceptions means the process has quit
             continue
-        if on_systemd:
+        if on_systemd():
             service_procs.add(proc)
         else:
             parent = _get_top_parent(proc)
@@ -114,7 +117,6 @@ def restart_services():
         retest_procs.add(proc)
 
     recommend_restart = False
-    processes = {}
     services = {}
     for proc in service_procs:
         if not proc:
@@ -128,41 +130,28 @@ def restart_services():
             log.debug('{} died before it could be restarted'.format(proc))
             continue
 
-        if on_systemd:
-            if proc.pid == 1:
-                log.info("Upgrade of systemd detected; doing daemon-reexec")
-                ret, _out, _err = sau.helpers.exec_cmd([ '/usr/bin/systemctl', 'daemon-reexec' ])
-                continue
-            ret, unit, err = sau.helpers.exec_cmd([ '/usr/bin/systemctl', 'whoami', f'{proc.pid}' ])
-            unit = unit.strip()
-            name, unit_type = unit.split('.')
-            if ret != 0:
-                log.debug(f'Non-success ({ret}) when checking unit for process: {err}')
-                continue
-            elif unit_type != 'service':
-                log.warning(f'not restarting non-service unit "{unit}"; owner of {proc}')
-            else:
-                _ret, enabled, _err = sau.helpers.exec_cmd([ '/usr/bin/systemctl', 'is-enabled', unit ])
-                enabled = enabled.strip()
-                if enabled in ('enabled', 'static'):
-                    log.warning(f'Unit {name}.service has enable status: {enabled} - will only restart "enabled" services')
-                else:
-                    service_name = name
-        else:
-            service_name = _get_service_from_proc(proc)
+        service_name = _get_service_from_proc(proc)
 
         if not service_name:
             log.warning('no service for process {}'.format(proc))
             recommend_restart = True
             continue
+        if service_name == 'systemd':
+            log.info("Upgrade of systemd detected; doing daemon-reexec")
+            sau.helpers.exec_cmd([ '/usr/bin/systemctl', 'daemon-reexec' ])
+            continue
+        elif service_name == '@ignore':
+            log.info(f"Process {proc} ignored by configuration")
+            retest_procs.discard(proc)
+            continue
 
         services[proc_name] = service_name
-        processes[service_name] = [proc]
 
     for service in set([x for x in services.values() if x]):
         policy = _get_service_restart_policy(service)
         if policy == 'ignore':
             log.info('Service "{}" ignored by configuration'.format(service))
+            [retest_procs.discard(x) for x,y in services.items() if y == service]
             continue
         elif policy == 'warn':
             log.warning('Service "{}" has open deleted files and should be restarted'.format(service))
@@ -185,7 +174,7 @@ def restart_services():
         if get_deleted_open_files(proc):
             service = services[proc_name]
             policy = _get_service_restart_policy(service)
-            _warn(policy, '{} still has deleted files open'.format(proc, parent))
+            _warn(policy, f'{proc} still has deleted files open')
             recommend_restart = True
     return recommend_restart
 
@@ -207,21 +196,50 @@ def _get_service_restart_policy(service):
 def _get_service_from_proc(proc):
     conf = sau.config
     platform = sau.platforms.get_platform()
-    proc = _get_top_parent(proc)
+    if not on_systemd():
+        proc = _get_top_parent(proc)
     log = logging.getLogger(sau.LOGNAME)
     try:
         proc_name = proc.name()
         service_exe = proc.exe()
     except (psutil.NoSuchProcess, psutil.ZombieProcess, psutil.AccessDenied):
         log.debug('{} died'.format(proc))
-        return None
+        return '@ignore'
 
     service_name = conf.get('processes', proc_name, fallback=None)
+    log.debug(f'configuration of process "{proc_name}" in config: "{service_name}"')
     if service_name == '':
         log.debug('Ignoring process {}'.format(proc))
-        return None
+        return '@ignore'
 
     if not service_name:
+        # Systemd has it's own way...
+        if on_systemd():
+            if proc.pid == 1:
+                return 'systemd'
+            ret, unit, err = sau.helpers.exec_cmd([ '/usr/bin/systemctl', 'whoami', f'{proc.pid}' ])
+            unit = unit.strip()
+            name, unit_type = unit.split('.')
+            if ret != 0:
+                log.debug(f'Non-success ({ret}) when checking unit for process: {err}')
+                return None
+            elif unit_type != 'service':
+                log.warning(f'not restarting non-service unit "{unit}"; owner of {proc}')
+                return None
+            elif name.startswith('user@'):
+                log.warning(f'Not restarting user service {unit}; please log out and log in again')
+                return None
+            else:
+                _ret, enabled, _err = sau.helpers.exec_cmd([ '/usr/bin/systemctl', 'is-enabled', unit ])
+                enabled = enabled.strip()
+                if enabled not in ('enabled', 'static'):
+                    log.warning(f'Unit {name}.service has enable status: {enabled} - will only restart "enabled" services')
+                    return None
+                else:
+                    return name
+            log.error(f'This should be an unreachable path when checking process {proc}')
+            return None
+
         # if the exe file has been deleted since started, service_exe will be empty
         # and we'll have to guess
         if not service_exe:

setup.py

@@ -1,11 +1,11 @@
-#!/usr/bin/env python3.7
+#!/usr/bin/env python3
 from os import environ
 
 from setuptools import setup, find_packages
 
 setup(
         name='sau',
-        version='1.2.0',
+        version='1.4.0',
         description='Tool for auto-updating OS and packages',
         author='Feffe',
         author_email='feffe@fulh.ax',