Fix a truckload of bugs as I'm trying it the commit-queue out on real changes.

pending_manager.py

 # coding=utf8
 # Copyright (c) 2010 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.
 """Commit queue manager class.
 
 Security implications:
 
 The following hypothesis are made:
 - Commit queue:
@@ skipping 26 matching lines @@
   breakpad.SendStack(e,
       ''.join(traceback.format_tb(sys.exc_info()[2])),
       maxlen=2000)
 
 
 class PendingCommit(base.Verified):
   """Represents a pending commit that is being processed."""
   persistent = base.Verified.persistent + [
       # Important since they tell if we need to revalidate and send try jobs
       # again or not if any of these value changes.
-      'issue', 'patchset', 'rietveld_server', 'processed',
+      'issue', 'patchset', 'rietveld_server', 'processed', 'description',
       # Only a cache, these values can be regenerated.
       'owner', 'reviewers', 'base_url',
       # Only used after a patch was committed. Keeping here for completeness.
-      'description', 'revision',
+      'revision',
   ]
 
-  def __init__(self, issue, owner, reviewers, patchset, base_url,
+  def __init__(self, issue, owner, reviewers, patchset, base_url, description,
       rietveld_server):
     super(PendingCommit, self).__init__()
     self.issue = issue
     self.owner = owner
     self.reviewers = reviewers
     self.patchset = patchset
     self.base_url = base_url
     self.rietveld_server = rietveld_server
-    self.description = None
+    self.description = description
     self.revision = None
     self.processed = False
 
   def patch_url(self):
     return ('%s/download/issue%d_%d.diff' %
         (self.rietveld_server,  self.issue, self.patchset))
 
   def pending_name(self):
     """The name that should be used for try jobs.
 
@@ skipping 37 matching lines @@
         if issue_id not in known_issues:
           issue_data = self.rietveld.get_issue_properties(issue_id)
           if issue_data.get('patchsets', None):
             self.queue.pending_commits.append(
                 PendingCommit(
                     issue_data['issue'],
                     issue_data['owner_email'],
                     issue_data['reviewers'],
                     issue_data['patchsets'][-1],
                     issue_data['base_url'],
+                    issue_data['description'].replace('\r', ''),
                     self.rietveld.url))
     except Exception, e:
       # Swallow every exception in that code and move on. Make sure to send a
       # stack trace though.
       send_stack(e)
 
   def _fetch_pending_issues(self):
     """Returns the list of issue number for reviews on Rietveld with their last
     patchset with commit+ flag set.
     """
@@ skipping 14 matching lines @@
           # Silently ignore.
           continue
 
         # The patch is fine to try.
         revision = self.checkout.prepare()
         self._apply_patch(pending, revision)
         previous_cwd = os.getcwd()
         try:
           os.chdir(self.checkout.project_path)
           for verifier in self.verifiers:
-            verifier.verify(pending, 'HEAD')
+            verifier.verify(pending, revision)
         finally:
           os.chdir(previous_cwd)
       except base.DiscardPending, e:
         self._discard_pending(e.pending, e.message)
       except Exception, e:
         # Swallow every exception in that code and move on. Make sure to send a
         # stack trace though.
         send_stack(e)
 
   def update_status(self):
@@ skipping 17 matching lines @@
         self._discard_pending(pending, 'Patch verification failed')
       elif pending.succeeded():
         # The item is removed right away.
         self.queue.pending_commits.remove(pending)
         try:
           self._last_minute_checks(pending)
           commit_message = '%s\nReview URL: %s%s' % (
               pending.description,
               pending.rietveld_server,
               pending.issue)
-          pending.revision = self.checkout.commit(commit_message, pending.user)
+          pending.revision = self.checkout.commit(commit_message, pending.owner)
           self._close_issue(pending)
         except base.DiscardPending, e:
           self._discard_pending(e.pending, e.message)
         except Exception, e:
           send_stack(e)
           self._discard_pending(pending, 'Commit queue had an internal error')
 
   def _validity_checks(self, pending):
     """Returns True if this pending is worth looking at."""
     if not any(re.match(r, pending.base_url) for r in self.project_bases):
       # Not a repository managed by this instance, silently ignore.
       logging.info('%s not in whitelist' % pending.base_url)
       return False
 
-    if any(re.match(r, pending.owner) for r in self.author_white_list):
+    if not any(re.match(r, pending.owner) for r in self.author_white_list):
       # Can't commit because the owner is not on the whitelist.
       logging.info('%s not in whitelist' % pending.owner)
       return False
 
     # Need at least one reviewer matching at least one regexp in
     # self.reviewers that is not also the owner of the issue.
     def match_reviewer(reviewer):
       return any(re.match(reviewer_regexp, reviewer)
                   for reviewer_regexp in self.reviewers)
 
     if not any(match_reviewer(reviewer) for reviewer in pending.reviewers
                 if not reviewer == pending.owner):
       return False
     return True
 
 
   def _last_minute_checks(self, pending):
     """Does last minute checks before committing a pending patch.
 
     Also prepares the patch to be committed. Throws if the patch should be
     discarded.
     """
     revision = self.checkout.prepare()
     self._apply_patch(pending, revision)
     # Do a last minute verifications just before committing.
     pending_data = self.rietveld.get_issue_properties(pending.issue)
-    pending.description = pending_data['description'].replace('\r', '')
+    if pending.description != pending_data['description'].replace('\r', ''):
+      raise base.DiscardPending(pending,
+          'Commit queue failed due to updated description.')
     pending.reviewers = pending_data['reviewers']
     if pending.patchset != pending_data['patchsets'][-1]:
       raise base.DiscardPending(pending,
           'Commit queue failed due to new patchset.')
     if pending_data['closed'] == 'true':
       raise base.DiscardPending(pending, None)
     if not self._validity_checks(pending):
       raise base.DiscardPending(pending,
           'This patch fails to pass validity checks to be automatically '
           'committed.')
     TODO('Search for \'lgtm\' in the comments')
 
   def _close_issue(self, pending):
     """Closes a issue on Rietveld after a commit succeeded."""
-    viewvc_url = self.checkout.get_setting('VIEW_VC')
+    viewvc_url = self.checkout.get_settings('VIEW_VC')
     description = pending.description
     if viewvc_url:
       description += '\nCommitted: %s%s' % (viewvc_url, pending.revision)
     self.rietveld.close_issue(pending.issue)
     self.rietveld.update_description(pending.issue, description)
 
   def _discard_pending(self, pending, message):
     """Discards a pending commit. Attach an optional message to the review."""
     self.rietveld.set_flag(pending.issue, pending.patchset, 'commit', 'False')
     if message:
@@ skipping 15 matching lines @@
           'Patch failed to apply against %s.' % revision)
 
   def load(self, filename):
     """Loads the commit queue state from a JSON file."""
     self.queue = model.load_from_json_file(filename)
     self.queue.pending_commits = self.queue.pending_commits or []
 
   def save(self, filename):
     """Save the commit queue state in a simple JSON file."""
     model.save_to_json_file(filename, self.queue)