Handle updates to the wrapper script.

remoting/tools/me2me_virtual_host.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Virtual Me2Me implementation.  This script runs and manages the processes
 # required for a Virtual Me2Me desktop, which are: X server, X desktop
 # session, and Host process.
 # This script is intended to run continuously as a background daemon
 # process, running under an ordinary (non-root) user account.
@@ skipping 616 matching lines @@
   os.dup2(log_fd, sys.stderr.fileno())
 
   # Close the temporary file-descriptors.
   os.close(devnull_fd)
   os.close(log_fd)
 
 
 def cleanup():
   logging.info("Cleanup.")
 
+  global g_pidfile
   if g_pidfile:
     try:
       g_pidfile.delete_file()
+      g_pidfile = None
     except Exception, e:
       logging.error("Unexpected error deleting PID file: " + str(e))
 
+  global g_desktops
   for desktop in g_desktops:
     if desktop.x_proc:
       logging.info("Terminating Xvfb")
       desktop.x_proc.terminate()
+  g_desktops = []
 
 
 def reload_config():
   for desktop in g_desktops:
     if desktop.host_proc:
       # Terminating the Host will cause the main loop to spawn another
       # instance, which will read any changes made to the Host config file.
       desktop.host_proc.terminate()
 
 
 def signal_handler(signum, stackframe):
   if signum == signal.SIGUSR1:
     logging.info("SIGUSR1 caught, reloading configuration.")
     reload_config()
   else:
     # Exit cleanly so the atexit handler, cleanup(), gets called.
     raise SystemExit
 
 
+def relaunch_self():
+  cleanup()
+  os.execvp(sys.argv[0], sys.argv)
+
+
 def main():
   DEFAULT_SIZE = "1280x800"
   parser = optparse.OptionParser(
       "Usage: %prog [options] [ -- [ X server options ] ]")
   parser.add_option("-s", "--size", dest="size", action="append",
                     help="dimensions of virtual desktop (default: %s). "
                     "This can be specified multiple times to make multiple "
                     "screen resolutions available (if the Xvfb server "
                     "supports this)" % DEFAULT_SIZE)
   parser.add_option("-f", "--foreground", dest="foreground", default=False,
@@ skipping 190 matching lines @@
 
   desktop = Desktop(sizes)
 
   # Remember the time when the last session was launched, in order to enforce
   # a minimum time between launches.  This avoids spinning in case of a
   # misconfigured system, or other error that prevents a session from starting
   # properly.
   last_launch_time = 0
 
   while True:
-    # If the session process stops running (e.g. because the user logged out),
-    # the X server should be reset and the session restarted, to provide a
-    # completely clean new session.
+    # If the session process or X server stops running (e.g. because the user
+    # logged out), kill the other. This will trigger the next conditional block
+    # as soon as the os.wait() call (below) returns.
     if desktop.session_proc is None and desktop.x_proc is not None:
       logging.info("Terminating X server")
       desktop.x_proc.terminate()
+    elif desktop.x_proc is None and desktop.session_proc is not None:
+      logging.info("Terminating X session")
+      desktop.session_proc.terminate()
+    elif desktop.x_proc is None and desktop.session_proc is None:
+      # Neither X server nor X session are running.
+      elapsed = time.time() - last_launch_time
+      if elapsed < 60:
+        logging.error("The session lasted less than 1 minute.  Waiting " +
+                      "before starting new session.")
+        time.sleep(60 - elapsed)
 
-    if desktop.x_proc is None:
-      if desktop.session_proc is not None:
-        # The X session would probably die soon if the X server is not
-        # running (because of the loss of the X connection).  Terminate it
-        # anyway, to be sure.
-        logging.info("Terminating X session")
-        desktop.session_proc.terminate()
-      else:
-        # Neither X server nor X session are running.
-        elapsed = time.time() - last_launch_time
-        if elapsed < 60:
-          logging.error("The session lasted less than 1 minute.  Waiting " +
-                        "before starting new session.")
-          time.sleep(60 - elapsed)
-
-        logging.info("Launching X server and X session")
+      if last_launch_time == 0:
+        # Neither process has been started yet. Do so now.
+        logging.info("Launching X server and X session.")
         last_launch_time = time.time()
         desktop.launch_x_server(args)
         desktop.launch_x_session()
+      else:
+        # Both processes have terminated. Since the user's desktop is already
+        # gone at this point, there's no state to lose and now is a good time
+        # to pick up any updates to this script that might have been installed.
+        logging.info("Relaunching self")
+        relaunch_self()
 
     if desktop.host_proc is None:
       logging.info("Launching host process")
       desktop.launch_host(host_config)
 
     try:
       pid, status = os.wait()
     except OSError, e:
       if e.errno == errno.EINTR:
         # Retry on EINTR, which can happen if a signal such as SIGUSR1 is
@@ skipping 43 matching lines @@
         return 0
       elif os.WEXITSTATUS(status) == 5:
         logging.info("Host domain is blocked by policy - exiting.")
         os.remove(host.config_file)
         return 0
       # Nothing to do for Mac-only status 6 (login screen unsupported)
 
 if __name__ == "__main__":
   logging.basicConfig(level=logging.DEBUG)
   sys.exit(main())