Add resource locking in gclient

gclient_utils.py

 # 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.
 
 """Generic utils."""
 
 import codecs
 import cStringIO
 import datetime
 import logging
@@ skipping 766 matching lines @@
   # On cygwin, creating a lock throwing randomly when nearing ~100 locks.
   # As a workaround, use a single lock. Yep you read it right. Single lock for
   # all the 100 objects.
   lock = threading.Lock()
 
   def __init__(self, name):
     # A unique string representing this work item.
     self._name = name
     self.outbuf = cStringIO.StringIO()
     self.start = self.finish = None
+    self.resources = []  # List of resources this work item requires.
 
   def run(self, work_queue):
     """work_queue is passed as keyword argument so it should be
     the last parameters of the function when you override it."""
     pass
 
   @property
   def name(self):
     return self._name
 
@@ skipping 65 matching lines @@
           str(task.finish - task.start).partition('.')[0])
     else:
       elapsed = ''
     return """
 %s%s%s
 ----------------------------------------
 %s
 ----------------------------------------""" % (
     task.name, comment, elapsed, task.outbuf.getvalue().strip())
 
+  def _is_conflict(self, job):
+    """Checks to see if a job will conflict with another running job."""
+    for running_job in self.running:
+      for used_resource in running_job.item.resources:
+        logging.debug('Checking resource %s' % used_resource)
+        if used_resource in job.resources:
+          return True
+    return False
+
   def flush(self, *args, **kwargs):
     """Runs all enqueued items until all are executed."""
     kwargs['work_queue'] = self
     self.last_subproc_output = self.last_join = datetime.datetime.now()
     self.ready_cond.acquire()
     try:
       while True:
         # Check for task to run first, then wait.
         while True:
           if not self.exceptions.empty():
             # Systematically flush the queue when an exception logged.
             self.queued = []
           self._flush_terminated_threads()
           if (not self.queued and not self.running or
               self.jobs == len(self.running)):
             logging.debug('No more worker threads or can\'t queue anything.')
             break
 
           # Check for new tasks to start.
           for i in xrange(len(self.queued)):
             # Verify its requirements.
             if (self.ignore_requirements or
                 not (set(self.queued[i].requirements) - set(self.ran))):
-              # Start one work item: all its requirements are satisfied.
-              self._run_one_task(self.queued.pop(i), args, kwargs)
-              break
+              if not self._is_conflict(self.queued[i]):
+                # Start one work item: all its requirements are satisfied.
+                self._run_one_task(self.queued.pop(i), args, kwargs)
+                break
           else:
             # Couldn't find an item that could run. Break out the outher loop.
             break
 
         if not self.queued and not self.running:
           # We're done.
           break
         # We need to poll here otherwise Ctrl-C isn't processed.
         try:
           self.ready_cond.wait(10)
@@ skipping 304 matching lines @@
     # Just incase we have some ~/blah paths.
     target = os.path.abspath(os.path.expanduser(target))
     if os.path.isfile(target) and os.access(target, os.X_OK):
       return target
     if sys.platform.startswith('win'):
       for suffix in ('.bat', '.cmd', '.exe'):
         alt_target = target + suffix
         if os.path.isfile(alt_target) and os.access(alt_target, os.X_OK):
           return alt_target
   return None