Merge remote branch 'cros/upstream' into master

server/hosts/logfile_monitor.py

 import logging, os, sys, subprocess, tempfile, traceback
 import time
 
 from autotest_lib.client.common_lib import utils
 from autotest_lib.server import utils as server_utils
 from autotest_lib.server.hosts import abstract_ssh, monitors
 
 MONITORDIR = monitors.__path__[0]
 SUPPORTED_PYTHON_VERS = ('2.4', '2.5', '2.6')
 DEFAULT_PYTHON = '/usr/bin/python'
 
 
 class Error(Exception):
     pass
 
 
 class InvalidPatternsPathError(Error):
     """An invalid patterns_path was specified."""
 
 
 class InvalidConfigurationError(Error):
     """An invalid configuration was specified."""
 
 
 class FollowFilesLaunchError(Error):
     """Error occurred launching followfiles remotely."""
 
 
-def run_cmd_on_host(hostname, cmd, stdin, stdout, stderr):
-    base_cmd = abstract_ssh.make_ssh_command()
-    full_cmd = "%s %s \"%s\"" % (base_cmd, hostname,
-                                 server_utils.sh_escape(cmd))
-
-    return subprocess.Popen(full_cmd, stdin=stdin, stdout=stdout,
-                            stderr=stderr, shell=True)
-
-
 def list_remote_pythons(host):
     """List out installed pythons on host."""
     result = host.run('ls /usr/bin/python[0-9]*')
     return result.stdout.splitlines()
 
 
 def select_supported_python(installed_pythons):
     """Select a supported python from a list"""
     for python in installed_pythons:
         if python[-3:] in SUPPORTED_PYTHON_VERS:
@@ skipping 17 matching lines @@
     supported_python = select_supported_python(installed_pythons)
     if not supported_python:
         if DEFAULT_PYTHON in installed_pythons:
             logging.info('No versioned Python binary found, '
                          'defaulting to: %s', DEFAULT_PYTHON)
             supported_python = DEFAULT_PYTHON
         else:
             raise FollowFilesLaunchError('No supported Python on host.')
 
     remote_monitordir = copy_monitordir(host)
-    remote_script_path = os.path.join(
-        remote_monitordir, 'followfiles.py')
+    remote_script_path = os.path.join(remote_monitordir, 'followfiles.py')
 
     followfiles_cmd = '%s %s --lastlines_dirpath=%s %s' % (
         supported_python, remote_script_path,
         lastlines_dirpath, ' '.join(follow_paths))
 
-    devnull_r = open(os.devnull, 'r')
-    devnull_w = open(os.devnull, 'w')
-    remote_followfiles_proc = run_cmd_on_host(
-        host.hostname, followfiles_cmd, stdout=subprocess.PIPE,
-        stdin=devnull_r, stderr=devnull_w)
+    remote_ff_proc = subprocess.Popen(host._make_ssh_cmd(followfiles_cmd),
+                                      stdin=open(os.devnull, 'r'),
+                                      stdout=subprocess.PIPE, shell=True)
+
+
     # Give it enough time to crash if it's going to (it shouldn't).
     time.sleep(5)
-    doa = remote_followfiles_proc.poll()
+    doa = remote_ff_proc.poll()
     if doa:
         raise FollowFilesLaunchError('ssh command crashed.')
 
-    return remote_followfiles_proc
+    return remote_ff_proc
 
 
 def resolve_patterns_path(patterns_path):
     """Resolve patterns_path to existing absolute local path or raise.
 
     As a convenience we allow users to specify a non-absolute patterns_path.
     However these need to be resolved before allowing them to be passed down
     to console.py.
 
     For now we expect non-absolute ones to be in self.monitordir.
@@ skipping 188 matching lines @@
       pattern_paths: list; Local alert pattern definition files.
     """
     if not follow_paths or (pattern_paths and not follow_paths):
         raise InvalidConfigurationError
 
     return type(
         'LogfileMonitorMixin%d' % id(follow_paths),
         (LogfileMonitorMixin,),
         {'follow_paths': follow_paths,
          'pattern_paths': pattern_paths or ()})