Create IVerifierStatus and add IVerifierStatus.ignored().

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', 'description',
+      'issue', 'patchset', 'rietveld_server', 'description',
       'files',
       # Only a cache, these values can be regenerated.
       'owner', 'reviewers', 'base_url',
       # Only used after a patch was committed. Keeping here for completeness.
       'revision',
   ]
 
   def __init__(self, issue, owner, reviewers, patchset, base_url, description,
       messages, 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 = description
     self.messages = messages
     self.revision = None
-    self.processed = False
     self.files = []
 
   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.
 
     It makes it possible to regenerate the try_jobs array if ever needed."""
@@ skipping 55 matching lines @@
     patchset with commit+ flag set.
     """
     return json.loads(self.rietveld.get(
         '/search?format=json&commit=True&closed=False&keys_only=True')
         )['results']
 
   def process_new_pending_commit(self):
     """Starts verification on newly found pending commits."""
     for pending in self.queue.pending_commits[:]:
       try:
-        if pending.verifications or pending.processed:
+        if len(pending.verifications) == len(self.verifiers) or pending.done():

[Dirk Pranke, 2011/01/04 22:10:42]

Should this check maybe be part of pending.done() (or a different method on
pending, e.g., verified())?

[M-A Ruel, 2011/01/11 21:07:40]

That's a good question.

Since pending doesn't know the number of verifiers, it's hard to have a member
function verify that so I don't know what could be done instead in a code
efficient way.

           continue
         logging.info('Processing issue %s' % pending.issue)
-        pending.processed = True
 
         if not self._validity_checks(pending):
           # 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, revision)
+            if pending.done():
+              break
         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):
     """Updates the status for each pending commit verifier."""
     for verifier in self.verifiers:
       try:
         verifier.update_status(self.queue.pending_commits)
       except base.DiscardPending, e:
         # It's not efficient since it takes a full loop for each pending commit
         # to discard.
         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 scan_results(self):
     """Scans pending commits that can be committed or discarded."""
     for pending in self.queue.pending_commits[:]:
-      if pending.failed():
+      if pending.ignored():
+        self._discard_pending(pending, None)
+      elif pending.failed():
         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\n\nReview URL: %s/%s' % (
               pending.description,
               pending.rietveld_server,
               pending.issue)
@@ skipping 76 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)