Fix DaemonControllerLinux::SetConfigAndStart() to reload config automatically.

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 100 matching lines @@
     return self.data[key]
 
   def __setitem__(self, key, value):
     self.data[key] = value
     self.changed = True
 
   def clear_auth(self):
     del self.data["xmpp_login"]
     del self.data["chromoting_auth_token"]
     del self.data["xmpp_auth_token"]
+    del self.data["oauth_refresh_token"]
 
   def clear_host_info(self):
     del self.data["host_id"]
     del self.data["host_name"]
     del self.data["host_secret_hash"]
     del self.data["private_key"]
 
 class Authentication:
   """Manage authentication tokens for Chromoting/xmpp"""
 
   def __init__(self):
-    pass
+    self.login = None
+    self.chromoting_auth_token = None
+    self.xmpp_auth_token = None
+    self.oauth_refresh_token = None
 
   def generate_tokens(self):
     """Prompt for username/password and use them to generate new authentication
     tokens.
 
     Raises:
       Exception: Failed to get new authentication tokens.
     """
     print "Email:",
     self.login = raw_input()
     password = getpass.getpass("App-specific password: ")
 
     chromoting_auth = gaia_auth.GaiaAuthenticator('chromoting')
     self.chromoting_auth_token = chromoting_auth.authenticate(self.login,
                                                               password)
 
     xmpp_authenticator = gaia_auth.GaiaAuthenticator('chromiumsync')
     self.xmpp_auth_token = xmpp_authenticator.authenticate(self.login,
                                                            password)
 
+  def has_chromoting_credentials(self):
+    """Returns True if we have credentials for the directory"""
+    return self.chromoting_auth_token != None
+
+  def has_xmpp_credentials(self):
+    """Returns True if we have credentials to authenticate XMPP connection"""
+    # XMPP connection can be authenticated using either OAuth or XMPP token.
+    return self.oauth_refresh_token != None or self.xmpp_auth_token != None
+
   def load_config(self, config):
+    """Loads the config and returns false if the config is invalid. After
+    config is loaded caller must use has_xmpp_credentials() and
+    has_chromoting_credentials() to check that the credentials it needs are
+    present in the config."""
+
+    # Host can use different types of auth tokens depending on how the config
+    # was generated. E.g. if the config was created by the webapp it will have
+    # only oauth token. We still consider config to be valid in this case.
+    self.chromoting_auth_token = config.get("chromoting_auth_token")
+    self.oauth_refresh_token = config.get("oauth_refresh_token")
+    self.xmpp_auth_token = config.get("xmpp_auth_token")
+
     try:
       self.login = config["xmpp_login"]
-      self.chromoting_auth_token = config["chromoting_auth_token"]
-      self.xmpp_auth_token = config["xmpp_auth_token"]
     except KeyError:
       return False
     return True
 
   def save_config(self, config):
     config["xmpp_login"] = self.login
-    config["chromoting_auth_token"] = self.chromoting_auth_token
-    config["xmpp_auth_token"] = self.xmpp_auth_token
+    if self.chromoting_auth_token:
+      config["chromoting_auth_token"] = self.chromoting_auth_token
+    if self.xmpp_auth_token:
+      config["xmpp_auth_token"] = self.xmpp_auth_token
+
 
 class Host:
   """This manages the configuration for a host.
 
   Callers should instantiate a Host object (passing in a filename where the
   config will be kept), then should call either of the methods:
 
   * register(auth): Create a new Host configuration and register it
   with the Directory Service (the "auth" parameter is used to
   authenticate with the Service).
@@ skipping 478 matching lines @@
                     help="stop the daemon currently running")
   parser.add_option("-p", "--new-pin", dest="new_pin", default=False,
                     action="store_true",
                     help="set new PIN before starting the host")
   parser.add_option("", "--check-running", dest="check_running", default=False,
                     action="store_true",
                     help="return 0 if the daemon is running, or 1 otherwise")
   parser.add_option("", "--silent", dest="silent", default=False,
                     action="store_true",
                     help="Start the host without trying to configure it.")
+  parser.add_option("", "--reload", dest="reload", default=False,
+                    action="store_true",
+                    help="Signal currently running host to reload the config.")
   (options, args) = parser.parse_args()
 
   host_hash = hashlib.md5(socket.gethostname()).hexdigest()
   pid_filename = os.path.join(CONFIG_DIR, "host#%s.pid" % host_hash)
 
   if options.check_running:
     running, pid = PidFile(pid_filename).check()
     return 0 if (running and pid != 0) else 1
 
   if options.stop:
     running, pid = PidFile(pid_filename).check()
     if not running:
       print "The daemon currently is not running"
     else:
       print "Killing process %s" % pid
       os.kill(pid, signal.SIGTERM)
     return 0
 
+  if options.reload:
+    running, pid = PidFile(pid_filename).check()
+    if not running:
+      return 1
+    os.kill(pid, signal.SIGUSR1)
+    return 0
+
   if not options.size:
     options.size = [DEFAULT_SIZE]
 
   sizes = []
   for size in options.size:
     size_components = size.split("x")
     if len(size_components) != 2:
       parser.error("Incorrect size format '%s', should be WIDTHxHEIGHT" % size)
 
     try:
@@ skipping 44 matching lines @@
       # If we were able to read auth.json then copy its content to the host
       # config.
       if auth_config_loaded:
         auth.save_config(host_config)
         host_config.save()
 
   host = Host(auth)
   host_config_loaded = host.load_config(host_config)
 
   if options.silent:
+    # Just validate the config when run with --silent.
     if not host_config_loaded or not auth_config_loaded:
       logging.error("Failed to load host configuration.")
       return 1
+    if not auth.has_xmpp_credentials():
+      logging.error("Auth tokens are not configured.")
+      return 1
   else:
-    need_auth_tokens = not auth_config_loaded
+    need_auth_tokens = (
+        not auth_config_loaded or not auth.has_chromoting_credentials())
     need_register_host = not host_config_loaded
     # Outside the loop so user doesn't get asked twice.
     if need_register_host:
       host.ask_pin()
     elif options.new_pin or not host.is_pin_set():
       host.ask_pin()
       host.save_config(host_config)
       running, pid = PidFile(pid_filename).check()
       if running and pid != 0:
         os.kill(pid, signal.SIGUSR1)
@@ skipping 152 matching lines @@
         host_config.save()
         return 0
       elif os.WEXITSTATUS(status) == 5:
         logging.info("Host domain is blocked by policy - exiting.")
         os.remove(host.config_file)
         return 0
 
 if __name__ == "__main__":
   logging.basicConfig(level=logging.DEBUG)
   sys.exit(main())