Merge lp:~smoser/curtin/trunk.lp1604962 into lp:~curtin-dev/curtin/trunk

[Scott Moser]

[Scott Moser (smoser)]

marked as a work in progress, but this is to fix bug 1604962.

Unmerged revisions

427. By Scott Moser on 2016-09-22

adding code i was playing with.

The intent of this would be for curtin to do something like the main
here. Instead of invoking the shell reboot function, it would
search for a parent that it liked (such as one named cloud-init).
If there was no good looking parent, then it would use itself.

So basically:
 - select a process P to wait until it is gone.
 - fork
 - exit from main process
 - second process polls for process P to have left the building
 - second process (conditionally) invokes the reboot.

=== added file 'curtin/power_state.py'
--- curtin/power_state.py	1970-01-01 00:00:00 +0000
+++ curtin/power_state.py	2016-09-22 20:52:31 +0000
@@ -0,0 +1,179 @@
+#   Copyright (C) 2016 Canonical Ltd.
+#
+#   Author: Scott Moser <[e-mail]>
+#
+#   Curtin is free software: you can redistribute it and/or modify it under
+#   the terms of the GNU Affero General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   Curtin 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 Affero General Public License for
+#   more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with Curtin.  If not, see <http://www.gnu.org/licenses/>.
+from curtin import util
+from curtin.log import LOG
+
+import errno
+import functools
+import os
+import re
+import sys
+import time
+
+EXIT_FAIL = 33
+
+
+def get_pid_info(pid=None):
+    # get_pid_info(return a dictionary with information about pid)
+    if pid is None or pid == "self":
+        pid = os.getpid()
+    path = "/proc/%s" % pid
+    content = util.load_file(path + "/status")
+    info = {}
+    for line in content.splitlines():
+        key, _, val = line.partition(":")
+        info[key.lower()] = val.strip()
+    info['cmdline'] = util.load_file(path + "/cmdline")[:-1].split('\0')
+    info['pid'] = int(pid)
+    return info
+
+def get_pedigree_info(pid=None):
+    if pid is None:
+        pid = os.getpid()
+    tree = []
+    while True:
+        cur = get_pid_info(pid)
+        ppid = int(cur['ppid'])
+        tree.append({'pid': cur['pid'], 'ppid': ppid,
+                     'cmdline': cur['cmdline']})
+        if ppid == 0:
+            break
+        pid = ppid
+    return tree
+
+
+def myreboot(*args, **kwargs):
+    print("args=%s" % ' '.join(args))
+    print("kwargs=%s" % str(kwargs))
+
+
+def run_after_pid_gone(pid, cmdline, timeout, func, args, kwargs,
+                       condition=True):
+    # wait until pid, with /proc/pid/cmdline contents of pidcmdline
+    # is no longer alive.  After it is gone, or timeout has passed
+    # execute func(args)
+    naptime = 0.25
+    msg = None
+    end_time = time.time() + timeout
+
+    def fatal(msg):
+        LOG.fatal(msg)
+        sys.exit(EXIT_FAIL)
+
+    known_errnos = (errno.ENOENT, errno.ESRCH)
+
+    while True:
+        if time.time() > end_time:
+            msg = "timeout reached before %d ended" % pid
+            break
+
+        try:
+            cur_cmdline = get_pid_info(pid)['cmdline']
+            if cur_cmdline != cmdline:
+                msg = "cmdline changed for %s [now: %s]" % (pid, cur_cmdline)
+                break
+
+        except IOError as ioerr:
+            if ioerr.errno in known_errnos:
+                msg = "pid info for %d failed [%d]" % (pid, ioerr.errno)
+            else:
+                fatal("IOError during wait: %s" % ioerr)
+            break
+
+        except Exception as e:
+            fatal("Unexpected Exception: %s" % e)
+
+        time.sleep(naptime)
+
+    if not msg:
+        fatal("Unexpected error in run_after_pid_gone")
+
+    LOG.debug(msg)
+
+    try:
+        if isinstance(condition, bool):
+            LOG.debug("Static Condition: %s" % condition)
+            result = condition
+        else:
+            result = condition()
+            LOG.debug("Calling condition returned %s" % condition)
+
+        if not result:
+            return
+
+    except Exception as e:
+        fatal("Unexpected Exception when checking condition: %s" % e)
+
+    func(*args, **kwargs)
+
+
+def fork_cb(child_cb, *args, **kwargs):
+    fid = os.fork()
+    if fid == 0:
+        try:
+            child_cb(*args, **kwargs)
+            sys.exit(0)
+        except Exception:
+            LOG.fatal("Failed forking and calling callback %s", child_cb)
+            sys.exit(1)
+    else:
+        LOG.debug("Forked child pid '%s' who will run callback %s",
+                  fid, child_cb)
+
+
+def find_in_pedigree(match, pedigree=None):
+    if pedigree is None:
+        pedigree = get_pedigree_info()
+
+    match = re.compile(match)
+    print("searching for match to %s in pedigree" % match)
+    for i, v in enumerate(reversed(pedigree)):
+        print(i * " " + "{pid}: {cmdline}".format(**v))
+        if re.search(match, v['cmdline'][0]):
+            return v
+    return None
+
+
+def main():
+    match = sys.argv[1]
+    if len(sys.argv) > 2:
+        pid = sys.argv[2]
+    else:
+        pid = "self"
+
+    print("searching for parent of '%s' matching %s" % (pid, match))
+    pedigree = get_pedigree_info(pid)
+    result = find_in_pedigree(match, pedigree)
+    if result is None:
+        result = pedigree[0]
+        print("No match. using self: %s" % result)
+    else:
+        print("Found match: %s" % result)
+
+    def not_blocked():
+        return not os.path.exists("/run/block-curtin-poweroff")
+
+    fork_cb(run_after_pid_gone, result['pid'], result['cmdline'],
+            30, myreboot, ('arg1', 'arg2'), {'kw1': 'kv1'},
+            condition=not_blocked)
+
+
+
+if __name__ == '__main__':
+    main()
+
+# vi: ts=4 expandtab syntax=python