Remove test keys from images we test with in the test harness.

bin/au_test_harness/parallel_test_job.py

 # Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Module containing methods/classes related to running parallel test jobs."""
 
 import sys
 import threading
 import time
 
@@ skipping 36 matching lines @@
       # From threading.py to avoid a refcycle.
       del self._target, self._args
 
   def GetOutput(self):
     """Returns the output of the method run."""
     assert self._completed, 'GetOutput called before thread was run.'
     return self._output
 
   def _Cleanup(self):
     """Releases semaphores for a waiting caller."""
-    cros_lib.Info('Completed job %s' % self)
     self._starting_semaphore.release()
     self._ending_semaphore.release()
 
   def __str__(self):
     return '%s(%s)' % (self._target, self._args)
 
 
 def RunParallelJobs(number_of_simultaneous_jobs, jobs, jobs_args,
                     print_status):
   """Runs set number of specified jobs in parallel.
@@ skipping 14 matching lines @@
   join_semaphore = threading.Semaphore(0)
   assert len(jobs) == len(jobs_args), 'Length of args array is wrong.'
 
   # Create the parallel jobs.
   for job, args in map(_TwoTupleize, jobs, jobs_args):
     thread = ParallelJob(job_start_semaphore, join_semaphore, target=job,
                          args=args)
     threads.append(thread)
 
   # Cache sudo access.
-  cros_lib.RunCommand(['sudo', 'echo', 'Starting test harness'],
+  cros_lib.RunCommand(['sudo', 'echo', 'Caching sudo credentials'],
                       print_cmd=False, redirect_stdout=True,
                       redirect_stderr=True)
 
   # We use a semaphore to ensure we don't run more jobs than required.
   # After each thread finishes, it releases (increments semaphore).
   # Acquire blocks of num jobs reached and continues when a thread finishes.
   for next_thread in threads:
     job_start_semaphore.acquire(blocking=True)
-    cros_lib.Info('Starting job %s' % next_thread)
     next_thread.start()
 
   # Wait on the rest of the threads to finish.
-  cros_lib.Info('Waiting for threads to complete.')
   for thread in threads:
     while not join_semaphore.acquire(blocking=False):
       time.sleep(5)
       if print_status:
         print >> sys.stderr, '.',
 
   return [thread.GetOutput() for thread in threads]