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 111 matching lines @@
   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.chromoting_auth_token = None
+    self.login = None
+    self.xmpp_auth_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_token(self):
+    return self.chromoting_auth_token != None
+
+  def has_xmpp_token(self):
+    # 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):
+    # Only some of the auth tokens may be present in the config. We still
+    # consider config to be valid in this case.

[Jamie, 2012/08/13 23:44:31]

I'm not a Python expert--I take it .get doesn't throw but the []-operator does?

[Lambros, 2012/08/14 01:07:44]

That is correct, get(key) returns None if the key isn't in the dictionary.

Please could you expand the comment to explain why we want to consider the
config to be valid (even if the oauth or xmpp_auth token is missing)?

[Sergey Ulanov, 2012/08/14 18:00:37]

Done.

+    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
 
 class Host:
@@ skipping 486 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="Reload the config.")

[Lambros, 2012/08/14 01:07:44]

Clarify: "Reload the config of the currently-running host."

   (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_token():
+      logging.error("Auth tokens are not configured.")

[Jamie, 2012/08/13 23:44:31]

In a previous comment, you state that we can use either xmpp or oauth. Here
you're failing if there's no xmpp token. Is this correct?

[Lambros, 2012/08/14 01:07:44]

+1 It's not clear to me what's going on here.  The Authentication.load_config()
method was originally written to return True or False, based on whether the
config had sufficient keys to run the host, or whether we needed the user to
type in credentials.  If we keep that original meaning, we shouldn't need extra
checks here.

[Sergey Ulanov, 2012/08/14 18:00:37]

The host needs tokens to authenticate XMPP connection, but doesn't need auth
token for the directory API. When the config is generated by the webapp it
doesn't have chromoting_auth_token so previously load_config() would fail even
though host would still work with it. I updated documentation for load_config()
to make it clear what's meaning of the result.

[Sergey Ulanov, 2012/08/14 18:00:37]

has_xmpp_token() returns true if we have any types of auth tokens that can be
used to authenticate XMPP connection. It can be either GTalk auth token that
this script gets via ClientAuth (stored in the config as xmpp_auth_token) or
oauth refresh token (stored as oauth_refresh_token).
I see how it can be confusing. Renamed the method to has_xmpp_credentials() and
added comments

+      return 1
   else:
-    need_auth_tokens = not auth_config_loaded
+    need_auth_tokens = not auth_config_loaded or not auth.has_chromoting_token()
     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())