Pass Me2Me config via stdin.

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 270 matching lines @@
     logging.info("Launching X session: %s" % XSESSION_COMMAND)
     self.session_proc = subprocess.Popen(XSESSION_COMMAND,
                                          stdin=open(os.devnull, "r"),
                                          cwd=HOME_DIR,
                                          env=self.child_env)
     if not self.session_proc.pid:
       raise Exception("Could not start X session")
 
   def launch_host(self, host_config):
     # Start remoting host
-    args = [locate_executable(HOST_BINARY_NAME),
-            "--host-config=%s" % (host_config.path)]
-    self.host_proc = subprocess.Popen(args, env=self.child_env)
+    args = [locate_executable(HOST_BINARY_NAME), "--host-config=/dev/stdin"]
+    self.host_proc = subprocess.Popen(args, env=self.child_env,
+                                      stdin=subprocess.PIPE)
     logging.info(args)
     if not self.host_proc.pid:
       raise Exception("Could not start Chrome Remote Desktop host")
+    self.host_proc.stdin.write(json.dumps(host_config.data))
+    self.host_proc.stdin.close()
 
 
 class PidFile:
   """Class to allow creating and deleting a file which holds the PID of the
   running process.  This is used to detect if a process is already running, and
   inform the user of the PID.  On process termination, the PID file is
   deleted.
 
   Note that PID files are not truly atomic or reliable, see
   http://mywiki.wooledge.org/ProcessManagement for more discussion on this.
@@ skipping 201 matching lines @@
       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:
-      desktop.host_proc.send_signal(signal.SIGHUP)
+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 signal_handler(signum, _stackframe):
-  if signum == signal.SIGHUP:
-    logging.info("SIGHUP caught, reloading configuration.")
-    reload_config()
-  else:
-    # Exit cleanly so the atexit handler, cleanup(), gets called.
-    raise SystemExit
+  def __call__(self, signum, _stackframe):
+    if signum == signal.SIGHUP:
+      logging.info("SIGHUP caught, restarting host.")
+      self.reload_config()
+    else:
+      # Exit cleanly so the atexit handler, cleanup(), gets called.
+      raise SystemExit
+
+  def reload_config(self):

[Sergey Ulanov, 2012/09/04 22:01:48]

This method is not used outside of this class, so it should be private. call it
_reload_config()?

[Jamie, 2012/09/05 21:15:38]

I just got rid of the function. There was no real need for it to be factored
out.

+    self.host_config.load()
+    for desktop in g_desktops:
+      if desktop.host_proc:
+        desktop.host_proc.send_signal(signal.SIGTERM)
 
 
 def relaunch_self():
   cleanup()
   os.execvp(sys.argv[0], sys.argv)
 
 
 def main():
   DEFAULT_SIZE = "1280x800"
   EPILOG = """This script is not intended for use by end-users.  To configure
@@ skipping 94 matching lines @@
     return 1
 
   if "--session=ubuntu-2d" in XSESSION_COMMAND:
     print >> sys.stderr, (
       "The Unity 2D desktop session will be used.\n"
       "If you encounter problems with this choice of desktop, please install\n"
       "the gnome-session-fallback package, and restart this script.\n")
 
   atexit.register(cleanup)
 
+  config_filename = os.path.join(CONFIG_DIR, "host#%s.json" % host_hash)
+  host_config = Config(config_filename)
+
   for s in [signal.SIGHUP, signal.SIGINT, signal.SIGTERM, signal.SIGUSR1]:
-    signal.signal(s, signal_handler)
+    signal.signal(s, SignalHandler(host_config))
 
-  # Ensure full path to config directory exists.
-  if not os.path.exists(CONFIG_DIR):
-    os.makedirs(CONFIG_DIR, mode=0700)
-
-  host_config = Config(os.path.join(CONFIG_DIR, "host#%s.json" % host_hash))
-  host_config.load()
+  if (not host_config.load()):
+    print >> sys.stderr, "Failed to load " + config_filename

[Lambros, 2012/09/05 16:35:54]

logging.error() is preferred for printing error messages.  We should eventually
fix other instances to be more consistent.  Now I'm thinking about it, we really
should be using logging.fatal() whenever the error is serious enough to exit the
program.  For this CL, I think "logging.error()" is OK for now, but do whatever
you think's best.

+    return 1
 
   auth = Authentication()
   auth_config_valid = auth.copy_from(host_config)
   host = Host()
   host_config_valid = host.copy_from(host_config)
   if not host_config_valid or not auth_config_valid:
     logging.error("Failed to load host configuration.")
     return 1
 
   global g_pidfile
@@ skipping 113 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())