Wait for CRD daemon process to be killed before returning.

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 484 matching lines @@
 
     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()
 
 
-def get_daemon_pid():
+def get_daemon_proc():
   """Checks if there is already an instance of this script running, and returns
-  its PID.
+  a psutil.Process instance for it.
 
   Returns:
-    The process ID of the existing daemon process, or 0 if the daemon is not
-    running.
+    A Process instance for the existing daemon process, or None if the daemon
+    is not running.
   """
+
   uid = os.getuid()
   this_pid = os.getpid()
 
   # Support new & old psutil API. This is the right way to check, according to
   # http://grodola.blogspot.com/2014/01/psutil-20-porting.html
   if psutil.version_info >= (2, 0):
     psget = lambda x: x()
   else:
     psget = lambda x: x
 
   for process in psutil.process_iter():
     # Skip any processes that raise an exception, as processes may terminate
     # during iteration over the list.
     try:
       # Skip other users' processes.
       if psget(process.uids).real != uid:
         continue
 
       # Skip the process for this instance.
       if process.pid == this_pid:
         continue
 
       # |cmdline| will be [python-interpreter, script-file, other arguments...]
       cmdline = psget(process.cmdline)
       if len(cmdline) < 2:
         continue
       if cmdline[0] == sys.executable and cmdline[1] == sys.argv[0]:
-        return process.pid
+        return process
     except (psutil.NoSuchProcess, psutil.AccessDenied):
       continue
 
-  return 0
+  return None
 
 
 def choose_x_session():
   """Chooses the most appropriate X session command for this system.
 
   Returns:
     A string containing the command to run, or a list of strings containing
     the executable program and its arguments, which is suitable for passing as
     the first parameter of subprocess.Popen().  If a suitable session cannot
     be found, returns None.
@@ skipping 417 matching lines @@
                     help="Prints version of the host.")
   (options, args) = parser.parse_args()
 
   # Determine the filename of the host configuration and PID files.
   if not options.config:
     options.config = os.path.join(CONFIG_DIR, "host#%s.json" % g_host_hash)
 
   # Check for a modal command-line option (start, stop, etc.)
 
   if options.get_status:
-    pid = get_daemon_pid()
-    if pid != 0:
+    proc = get_daemon_proc()
+    if proc is not None:

[Sergey Ulanov, 2014/06/18 00:23:58]

nit: why not 'proc != None'?
Or I would prefer 'if proc:'

Same for all changes below

[Lambros, 2014/06/18 00:44:57]

I'm following the advice from the Google Python style guide here:
http://google-styleguide.googlecode.com/svn/trunk/pyguide.html?showone=True/F...

which says:
"Never use == or != to compare singletons like None. Use is or is not."

[Sergey Ulanov, 2014/06/18 08:01:27]

I didn't know about this. Still, the guide says the following:
  Use the "implicit" false if at all possible, e.g., if foo: rather than if foo
!= []:. 

And I think that rule takes priority over not using != for None. So it's still
better to write this expression as "if proc:"

       print "STARTED"
     elif is_supported_platform():
       print "STOPPED"
     else:
       print "NOT_IMPLEMENTED"
     return 0
 
   # TODO(sergeyu): Remove --check-running once NPAPI plugin and NM host are
   # updated to always use get-status flag instead.
   if options.check_running:
-    pid = get_daemon_pid()
-    return 0 if pid != 0 else 1
+    proc = get_daemon_proc()
+    return 1 if proc is None else 0
 
   if options.stop:
-    pid = get_daemon_pid()
-    if pid == 0:
+    proc = get_daemon_proc()
+    if proc is None:
       print "The daemon is not currently running"
     else:
-      print "Killing process %s" % pid
-      os.kill(pid, signal.SIGTERM)
+      print "Killing process %s" % proc.pid
+      proc.terminate()
+      try:
+        proc.wait(timeout=30)
+      except psutil.TimeoutExpired:
+        print "Timed out trying to kill daemon process"
+        return 1
     return 0
 
   if options.reload:
-    pid = get_daemon_pid()
-    if pid == 0:
+    proc = get_daemon_proc()
+    if proc is None:
       return 1
-    os.kill(pid, signal.SIGHUP)
+    proc.send_signal(signal.SIGHUP)
     return 0
 
   if options.add_user:
     user = getpass.getuser()
     try:
       if user in grp.getgrnam(CHROME_REMOTING_GROUP_NAME).gr_mem:
         logging.info("User '%s' is already a member of '%s'." %
                      (user, CHROME_REMOTING_GROUP_NAME))
         return 0
     except KeyError:
@@ skipping 71 matching lines @@
   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
 
   # Determine whether a desktop is already active for the specified host
   # host configuration.
-  pid = get_daemon_pid()
-  if pid != 0:
+  proc = get_daemon_proc()
+  if proc is not None:
     # Debian policy requires that services should "start" cleanly and return 0
     # if they are already running.
     print "Service already running."
     return 0
 
   # Detach a separate "daemon" process to run the session, unless specifically
   # requested to run in the foreground.
   if not options.foreground:
     daemonize()
 
@@ skipping 120 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())