400 lines
15 KiB
Python
Executable File
400 lines
15 KiB
Python
Executable File
#!/usr/bin/python3
|
|
# Copyright (c) 2009 Canonical Ltd
|
|
#
|
|
# AUTHOR:
|
|
# Michael Vogt <mvo@ubuntu.com>
|
|
#
|
|
# unattended-upgrade-shutdown - helper that checks if a
|
|
# unattended-upgrade is in progress and waits until it exists
|
|
#
|
|
# This file is part of unattended-upgrades
|
|
#
|
|
# unattended-upgrades is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License as published
|
|
# by the Free Software Foundation; either version 2 of the License, or (at
|
|
# your option) any later version.
|
|
#
|
|
# unattended-upgrades is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with unattended-upgrades; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
#
|
|
|
|
import copy
|
|
import dbus
|
|
import signal
|
|
import sys
|
|
import time
|
|
import logging
|
|
import logging.handlers
|
|
import gettext
|
|
import subprocess
|
|
import os.path
|
|
|
|
# for dbus signal handling
|
|
try:
|
|
from dbus.mainloop.glib import DBusGMainLoop
|
|
from gi.repository import GLib
|
|
except ImportError:
|
|
pass
|
|
|
|
from optparse import OptionParser
|
|
from gettext import gettext as _
|
|
from threading import Event
|
|
|
|
try:
|
|
import apt_pkg
|
|
except Exception:
|
|
# if there is no python-apt no unattended-upgrades can run so not
|
|
# need to stop the shutdown
|
|
logging.exception("importing of apt_pkg failed, exiting")
|
|
sys.exit(0)
|
|
|
|
|
|
def do_usplash(msg):
|
|
# type: (str) -> None
|
|
if os.path.exists("/sbin/usplash_write"):
|
|
logging.debug("Running usplash_write")
|
|
subprocess.call(["/sbin/usplash_write", "TEXT", msg])
|
|
subprocess.call(["/sbin/usplash_write", "PULSATE"])
|
|
|
|
|
|
def do_plymouth(msg):
|
|
# type: (str) -> None
|
|
if os.path.exists("/bin/plymouth"):
|
|
logging.debug("Running plymouth --text")
|
|
subprocess.call(["/bin/plymouth", "message", "--text", msg])
|
|
|
|
|
|
def log_msg(msg, level=logging.WARN):
|
|
# type: (str, int) -> None
|
|
""" helper that will print msg to usplash, plymouth, console """
|
|
logging.log(level, msg)
|
|
do_plymouth(msg)
|
|
do_usplash(msg)
|
|
|
|
|
|
def log_progress():
|
|
# type: () -> None
|
|
""" helper to log the install progress (if any) """
|
|
# wait a some seconds and try again
|
|
msg = _("Unattended-upgrade in progress during shutdown, "
|
|
"please don't turn off the computer")
|
|
# progress info
|
|
progress = "/var/run/unattended-upgrades.progress"
|
|
if os.path.exists(progress):
|
|
msg += "\n" + open(progress).read()
|
|
# log it
|
|
log_msg(msg)
|
|
|
|
|
|
def signal_stop_unattended_upgrade():
|
|
""" send SIGTERM to running unattended-upgrade if there is any """
|
|
pidfile = "/var/run/unattended-upgrades.pid"
|
|
if os.path.exists(pidfile):
|
|
pid = int(open(pidfile).read())
|
|
logging.debug("found running unattended-upgrades pid %s" % pid)
|
|
os.kill(pid, signal.SIGTERM)
|
|
|
|
|
|
def exit_log_result(success):
|
|
if success:
|
|
log_msg(_("All upgrades installed"), logging.INFO)
|
|
sys.exit(0)
|
|
else:
|
|
log_msg(_("Unattended-upgrades stopped. There may be upgrades"
|
|
" left to be installed in the next run."), logging.INFO)
|
|
sys.exit(1)
|
|
|
|
|
|
class UnattendedUpgradesShutdown():
|
|
|
|
def __init__(self, options):
|
|
# type: (Options) -> None
|
|
self.options = options
|
|
self.max_delay = options.delay * 60
|
|
self.iter_timer_set = False
|
|
self.apt_pkg_reinit_done = None
|
|
self.shutdown_pending = False
|
|
self.on_shutdown_mode = None
|
|
self.on_shutdown_mode_uu_proc = None
|
|
self.start_time = None
|
|
self.lock_was_taken = False
|
|
self.signal_sent = False
|
|
self.stop_signal_received = Event()
|
|
try:
|
|
hasattr(GLib, "MainLoop")
|
|
DBusGMainLoop(set_as_default=True)
|
|
except NameError:
|
|
pass
|
|
try:
|
|
self.inhibit_lock = self.get_inhibit_shutdown_lock()
|
|
except dbus.exceptions.DBusException:
|
|
logging.warning("Could not get delay inhibitor lock")
|
|
self.inhibit_lock = None
|
|
self.logind_proxy = None
|
|
self.wait_period = min(3, self.get_inhibit_max_delay() / 3)
|
|
self.preparing_for_shutdown = False
|
|
|
|
def get_logind_proxy(self):
|
|
""" Get logind dbus proxy object """
|
|
if not self.logind_proxy:
|
|
bus = dbus.SystemBus()
|
|
if self.inhibit_lock is None:
|
|
# try to get inhibit_lock or throw exception quickly when
|
|
# logind is down
|
|
self.inhibit_lock = self.get_inhibit_shutdown_lock()
|
|
self.logind_proxy = bus.get_object(
|
|
'org.freedesktop.login1', '/org/freedesktop/login1')
|
|
return self.logind_proxy
|
|
|
|
def get_inhibit_shutdown_lock(self):
|
|
""" Take delay inhibitor lock """
|
|
bus = dbus.SystemBus()
|
|
return bus.call_blocking(
|
|
'org.freedesktop.login1', '/org/freedesktop/login1',
|
|
'org.freedesktop.login1.Manager', 'Inhibit', 'ssss',
|
|
('shutdown', 'Unattended Upgrades Shutdown',
|
|
_('Stop ongoing upgrades or perform upgrades before shutdown'),
|
|
'delay'), timeout=2.0)
|
|
|
|
def get_inhibit_max_delay(self):
|
|
try:
|
|
logind_proxy = self.get_logind_proxy()
|
|
getter_interface = dbus.Interface(
|
|
logind_proxy,
|
|
dbus_interface='org.freedesktop.DBus.Properties')
|
|
return (getter_interface.Get(
|
|
"org.freedesktop.login1.Manager", "InhibitDelayMaxUSec")
|
|
/ (1000 * 1000))
|
|
except dbus.exceptions.DBusException:
|
|
return 3
|
|
|
|
def is_preparing_for_shutdown(self):
|
|
if not self.shutdown_pending:
|
|
try:
|
|
logind_proxy = self.get_logind_proxy()
|
|
getter_interface = dbus.Interface(
|
|
logind_proxy,
|
|
dbus_interface='org.freedesktop.DBus.Properties')
|
|
self.shutdown_pending = getter_interface.Get(
|
|
"org.freedesktop.login1.Manager", "PreparingForShutdown")
|
|
except dbus.exceptions.DBusException:
|
|
return False
|
|
return self.shutdown_pending
|
|
|
|
def start_iterations(self):
|
|
if not self.iter_timer_set:
|
|
try:
|
|
GLib.timeout_add(self.wait_period * 1000, self.iter)
|
|
# schedule first iteration immediately
|
|
GLib.timeout_add(0, lambda: self.iter() and False)
|
|
except NameError:
|
|
pass
|
|
|
|
def run_polling(self, signal_handler):
|
|
logging.warning(
|
|
_("Unable to monitor PrepareForShutdown() signal, polling "
|
|
"instead."))
|
|
logging.warning(
|
|
_("To enable monitoring the PrepareForShutdown() signal "
|
|
"instead of polling please install the python3-gi package"))
|
|
|
|
signal.signal(signal.SIGTERM, signal_handler)
|
|
signal.signal(signal.SIGHUP, signal_handler)
|
|
|
|
# poll for PrepareForShutdown then run final iterations
|
|
if self.options.wait_for_signal:
|
|
logging.debug("Waiting for signal to start operation ")
|
|
while (not self.stop_signal_received.is_set()
|
|
and not self.is_preparing_for_shutdown()):
|
|
self.stop_signal_received.wait(self.wait_period)
|
|
else:
|
|
logging.debug("Skip waiting for signals, starting operation "
|
|
"now")
|
|
while not self.iter():
|
|
# TODO iter on sigterm and sighup, too
|
|
time.sleep(self.wait_period)
|
|
|
|
def run(self):
|
|
""" delay shutdown and wait for PrepareForShutdown or other signals"""
|
|
|
|
# set signal handlers
|
|
def signal_handler(signum, frame):
|
|
# type: (object) -> None
|
|
logging.warning(
|
|
"SIGTERM or SIGHUP received, stopping unattended-upgrades"
|
|
"only if it is running")
|
|
self.stop_signal_received.set()
|
|
self.start_iterations()
|
|
|
|
# fall back to polling without GLib
|
|
try:
|
|
hasattr(GLib, "MainLoop")
|
|
except NameError:
|
|
self.run_polling(signal_handler)
|
|
return
|
|
|
|
for sig in (signal.SIGTERM, signal.SIGHUP):
|
|
GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, sig,
|
|
signal_handler, None, None)
|
|
if self.options.wait_for_signal:
|
|
def prepare_for_shutdown_handler(active):
|
|
""" Handle PrepareForShutdown() """
|
|
if not active:
|
|
logging.warning("PrepareForShutdown(false) received, "
|
|
"this should not happen")
|
|
# PrepareForShutdown arrived, starting final iterations
|
|
self.start_iterations()
|
|
try:
|
|
self.get_logind_proxy().connect_to_signal(
|
|
"PrepareForShutdown", prepare_for_shutdown_handler)
|
|
except dbus.exceptions.DBusException:
|
|
logging.warning(
|
|
_("Unable to monitor PrepareForShutdown() signal, polling "
|
|
"instead."))
|
|
logging.warning(
|
|
_("Maybe systemd-logind service is not running."))
|
|
self.run_polling(signal_handler)
|
|
return
|
|
|
|
logging.debug("Waiting for signal to start operation ")
|
|
else:
|
|
# starting final iterations immediately
|
|
logging.debug("Skip waiting for signals, starting operation "
|
|
"now")
|
|
self.start_iterations()
|
|
GLib.MainLoop().run()
|
|
|
|
def try_iter_on_shutdown(self):
|
|
# check if we need to run unattended-upgrades on shutdown and if
|
|
# so, run it
|
|
try:
|
|
if self.apt_pkg_reinit_done is None:
|
|
logging.debug("Initializing apt_pkg configuration")
|
|
apt_pkg.init_config()
|
|
self.apt_pkg_reinit_done = True
|
|
except apt_pkg.Error as error:
|
|
# apt may be in a transient state due to unattended-upgrades
|
|
# running, thus assuming non shutdown mode is reasonable
|
|
logging.error(_("Apt returned an error thus shutdown mode is "
|
|
"disabled"))
|
|
logging.error(_("error message: '%s'"), error)
|
|
self.apt_pkg_reinit_done = False
|
|
|
|
if self.on_shutdown_mode is None:
|
|
self.on_shutdown_mode = (
|
|
not self.options.stop_only
|
|
and not self.stop_signal_received.is_set()
|
|
and self.apt_pkg_reinit_done
|
|
and apt_pkg.config.find_b(
|
|
"Unattended-Upgrade::InstallOnShutdown", False))
|
|
if self.on_shutdown_mode:
|
|
env = copy.copy(os.environ)
|
|
env["UNATTENDED_UPGRADES_FORCE_INSTALL_ON_SHUTDOWN"] = "1"
|
|
logging.debug("starting unattended-upgrades in shutdown mode")
|
|
self.on_shutdown_mode_uu_proc = subprocess.Popen(
|
|
["unattended-upgrade"], env=env)
|
|
log_msg(_("Running unattended-upgrades in shutdown mode"))
|
|
# run u-u, but switch to stopping when receiving stop signal
|
|
# because it means shutdown progressed despite holding the lock
|
|
|
|
if self.on_shutdown_mode:
|
|
log_progress()
|
|
if self.on_shutdown_mode_uu_proc.poll() is not None:
|
|
# unattended-upgrades stopped on its own
|
|
exit_log_result(True)
|
|
else:
|
|
return True
|
|
return False
|
|
|
|
def iter(self):
|
|
if self.start_time is None:
|
|
self.start_time = time.time()
|
|
logging.debug("Starting countdown of %s minutes",
|
|
self.max_delay / 60)
|
|
else:
|
|
if (time.time() - self.start_time) > self.max_delay:
|
|
logging.warning(_(
|
|
"Giving up on lockfile after %s minutes of delay"),
|
|
self.max_delay / 60)
|
|
sys.exit(1)
|
|
|
|
if not self.stop_signal_received.is_set():
|
|
if self.try_iter_on_shutdown():
|
|
return True
|
|
|
|
# run monitoring and keep "UI" updated
|
|
res = apt_pkg.get_lock(self.options.lock_file)
|
|
logging.debug("get_lock returned %i" % res)
|
|
# exit here if there is no lock
|
|
if res > 0:
|
|
logging.debug("lock not taken")
|
|
if self.lock_was_taken:
|
|
exit_log_result(self.signal_sent)
|
|
else:
|
|
sys.exit(0)
|
|
self.lock_was_taken = True
|
|
signal_stop_unattended_upgrade()
|
|
self.signal_sent = True
|
|
# show log
|
|
log_progress()
|
|
return True
|
|
|
|
|
|
def main():
|
|
|
|
# setup gettext
|
|
localesApp = "unattended-upgrades"
|
|
localesDir = "/usr/share/locale"
|
|
gettext.bindtextdomain(localesApp, localesDir)
|
|
gettext.textdomain(localesApp)
|
|
|
|
apt_pkg.init_config()
|
|
|
|
parser = OptionParser()
|
|
parser.add_option("", "--debug",
|
|
action="store_true", dest="debug", default=False,
|
|
help="print debug messages")
|
|
parser.add_option("", "--delay", default=25, type="int",
|
|
help="delay in minutes to wait for unattended-upgrades")
|
|
parser.add_option("", "--lock-file",
|
|
default="/var/run/unattended-upgrades.lock",
|
|
help="lock file location")
|
|
parser.add_option("", "--stop-only",
|
|
action="store_true", dest="stop_only", default=False,
|
|
help="only stop running unattended-upgrades, don't "
|
|
"start it even when "
|
|
"Unattended-Upgrade::InstallOnShutdown is true")
|
|
parser.add_option("", "--wait-for-signal",
|
|
action="store_true", dest="wait_for_signal",
|
|
default=False,
|
|
help="wait for TERM signal before starting operation")
|
|
(options, args) = parser.parse_args()
|
|
|
|
# setup logging
|
|
level = logging.INFO
|
|
if options.debug:
|
|
level = logging.DEBUG
|
|
|
|
# use a normal logfile instead of syslog too as on shutdown its too
|
|
# easy to get syslog killed
|
|
logdir = apt_pkg.config.find_dir(
|
|
"Unattended-Upgrade::LogDir", "/var/log/unattended-upgrades/")
|
|
if not os.path.exists(logdir):
|
|
os.makedirs(logdir)
|
|
logfile = os.path.join(logdir, "unattended-upgrades-shutdown.log")
|
|
logging.basicConfig(filename=logfile,
|
|
level=level,
|
|
format="%(asctime)s %(levelname)s - %(message)s")
|
|
|
|
UnattendedUpgradesShutdown(options).run()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|