Simplify Linux host startup script.

remoting/host/linux/linux_me2me_host.py

 #!/usr/bin/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 113 matching lines @@
 
 # Thresholds for switching from fast- to slow-restart and for giving up
 # trying to restart entirely.
 SHORT_BACKOFF_THRESHOLD = 5
 MAX_LAUNCH_FAILURES = SHORT_BACKOFF_THRESHOLD + 10
 
 # Number of seconds to save session output to the log.
 SESSION_OUTPUT_TIME_LIMIT_SECONDS = 30
 
 # Globals needed by the atexit cleanup() handler.
-g_desktops = []
+g_desktop = None
 g_host_hash = hashlib.md5(socket.gethostname()).hexdigest()
 
 def gen_xorg_config(sizes):
   return (
       # This causes X to load the default GLX module, even if a proprietary one
       # is installed in a different directory.
       'Section "Files"\n'
       '  ModulePath "/usr/lib/xorg/modules"\n'
       'EndSection\n'
       '\n'
@@ skipping 256 matching lines @@
     self.host_proc = None
     self.child_env = None
     self.sizes = sizes
     self.xorg_conf = None
     self.pulseaudio_pipe = None
     self.server_supports_exact_resize = False
     self.server_supports_randr = False
     self.randr_add_sizes = False
     self.host_ready = False
     self.ssh_auth_sockname = None
-    g_desktops.append(self)
+    global g_desktop
+    assert(g_desktop is None)
+    g_desktop = self
 
   @staticmethod
   def get_unused_display_number():
     """Return a candidate display number for which there is currently no
     X Server lock file"""
     display = FIRST_X_DISPLAY_NUMBER
     while os.path.exists(X_LOCK_FILE_TEMPLATE % display):
       display += 1
     return display
 
@@ skipping 322 matching lines @@
     if self.ssh_auth_sockname:
       args.append("--ssh-auth-sockname=%s" % self.ssh_auth_sockname)
 
     args.extend(extra_start_host_args)
 
     # Have the host process use SIGUSR1 to signal a successful start.
     def sigusr1_handler(signum, frame):
       _ = signum, frame
       logging.info("Host ready to receive connections.")
       self.host_ready = True
-      if (ParentProcessLogger.instance() and
-          False not in [desktop.host_ready for desktop in g_desktops]):
+      if (ParentProcessLogger.instance() and g_desktop is not None and
+          g_desktop.host_ready):
         ParentProcessLogger.instance().release_parent(True)
 
     signal.signal(signal.SIGUSR1, sigusr1_handler)
     args.append("--signal-parent")
 
     logging.info(args)
     self.host_proc = subprocess.Popen(args, env=self.child_env,
                                       stdin=subprocess.PIPE)
     if not self.host_proc.pid:
       raise Exception("Could not start Chrome Remote Desktop host")
@@ skipping 290 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_desktops
-  for desktop in g_desktops:
-    for proc, name in [(desktop.x_proc, "X server"),
-                       (desktop.session_proc, "session"),
-                       (desktop.host_proc, "host")]:
+  global g_desktop
+  if g_desktop is not None:
+    for proc, name in [(g_desktop.x_proc, "X server"),
+                       (g_desktop.session_proc, "session"),
+                       (g_desktop.host_proc, "host")]:
       if proc is not None:
         logging.info("Terminating " + name)
         try:
           psutil_proc = psutil.Process(proc.pid)
           psutil_proc.terminate()
 
           # Use a short timeout, to avoid delaying service shutdown if the
           # process refuses to die for some reason.
           psutil_proc.wait(timeout=10)
         except psutil.TimeoutExpired:
           logging.error("Timed out - sending SIGKILL")
           psutil_proc.kill()
         except psutil.Error:
           logging.error("Error terminating process")
-    if desktop.xorg_conf is not None:
-      os.remove(desktop.xorg_conf)
+    if g_desktop.xorg_conf is not None:
+      os.remove(g_desktop.xorg_conf)
 
-  g_desktops = []
+  g_desktop = None
   if ParentProcessLogger.instance():
     ParentProcessLogger.instance().release_parent(False)
 
 class SignalHandler:
   """Reload the config file on SIGHUP. Since we pass the configuration to the
   host processes via stdin, they can't reload it, so terminate them. They will
   be relaunched automatically with the new config."""
 
   def __init__(self, host_config):
     self.host_config = host_config
 
   def __call__(self, signum, _stackframe):
     if signum == signal.SIGHUP:
       logging.info("SIGHUP caught, restarting host.")
       try:
         self.host_config.load()
       except (IOError, ValueError) as e:
         logging.error("Failed to load config: " + str(e))
-      for desktop in g_desktops:
-        if desktop.host_proc:
-          desktop.host_proc.send_signal(signal.SIGTERM)
+      if g_desktop is not None and g_desktop.host_proc:
+        g_desktop.host_proc.send_signal(signal.SIGTERM)
     else:
       # Exit cleanly so the atexit handler, cleanup(), gets called.
       raise SystemExit
 
 
 class RelaunchInhibitor:
   """Helper class for inhibiting launch of a child process before a timeout has
   elapsed.
 
   A managed process can be in one of these states:
@@ skipping 501 matching lines @@
         else:
           logging.info("Host exited with status %s." % os.WEXITSTATUS(status))
       elif os.WIFSIGNALED(status):
         logging.info("Host terminated by signal %s." % os.WTERMSIG(status))
 
 
 if __name__ == "__main__":
   logging.basicConfig(level=logging.DEBUG,
                       format="%(asctime)s:%(levelname)s:%(message)s")
   sys.exit(main())