'emails' can be unicode when in production.

verification/try_server.py

 # coding=utf8
 # Copyright (c) 2011 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.
 """Sends patches to the Try server and reads back results.
 """
 
 import datetime
 import logging
 import urllib2
@@ skipping 83 matching lines @@
     self.bad_revisions = None
 
   def update_all(self):
     """Grabs the status of all try jobs for all builders on try server's
     cache.
 
     Does one request per builder since it's quite heavy weight.
     """
     # TODO(maruel): Use listening StatusPush instead of hammering the try
     # server.
-    logging.info('Fetching all try jobs status')
     for builder in self.builders:
       try:
         new_jobs = self._urlreadasjson('builders/%s/builds/_all' % builder)
         logging.debug('Received %d builds from %s' % (len(new_jobs), builder))
         self.jobs[builder].update(new_jobs)
         # Only keep the last 1000.
         if len(self.jobs[builder]) > 1000:
           keys = sorted(self.jobs[builder].keys())
           for key in keys[:-1000]:
             del self.jobs[builder][key]
       except urllib2.HTTPError, e:
         if e.code != 503:
           raise
         # The try server is rebooting. We'll get more data once the try server
         # is back.
 
   def get_job(self, job, incremental):
     """Gets the build status for a try job."""
-    if incremental:
+    if incremental or unicode(job.build) not in self.jobs[job.builder]:
       url = 'builders/%s/builds/%s' % (job.builder, job.build)
-      self.jobs[job.builder][unicode(job.build)] = self._urlreadasjson(str(url))
+      try:
+        self.jobs[job.builder][unicode(job.build)] = self._urlreadasjson(
+            str(url))
+      except urllib2.HTTPError:
+        # The try job is way too old.
+        return None
     return self.jobs[job.builder][unicode(job.build)]
 
   def find_job(self, job, previous_jobs, reason):
     """Finds a build status dict corresponding to a job."""
     for build_number, build in self.jobs[job.builder].iteritems():
       def get_rev():
         return build.get(u'sourceStamp', {}).get(u'changes', [{}])[0].get(
             u'revision', None)
 
       if (build.get(u'reason', None) == reason and
           int(build_number) not in previous_jobs and
           unicode(get_rev()) == unicode(job.revision)):
         if build:
           # Note the build number to remember it started.
           job.build = build_number
         return build
 
   def update_known_revisions(self):
     # Look for any revision that passed all jobs, patch or not. That is not
     # exactly a valid check but much more useful in practice.
     if self.good_revisions is None:
       self.good_revisions = set()
       self.bad_revisions = set()
-    successes = [
-        set(job[u'sourceStamp'][u'changes'][0][u'revision']
-            for job in jobs.itervalues()
-            if job.get(u'results') in (SUCCESS, WARNINGS, SKIPPED))
-        for jobs in self.jobs.itervalues()]
+    successes = []
+    for jobs in self.jobs.itervalues():
+      successes.append(set())
+      for job in jobs.itervalues():
+        if (job.get(u'results', None) in (SUCCESS, WARNINGS, SKIPPED) and
+            len(job.get(u'sourceStamp', {}).get(u'changes', [])) >= 1):
+          successes[-1].add(job[u'sourceStamp'][u'changes'][0][u'revision'])
     good_revisions = reduce(lambda x, y: x & y, successes)
     new_good_revisions = good_revisions - self.good_revisions
     if new_good_revisions:
       logging.info(
           'New good revisions: %s' % ', '.join(map(str, new_good_revisions)))
     self.good_revisions |= new_good_revisions
 
     # Look for any revision that failed on a try job without patch. Mark it as
     # bad. That has bad side effects with regard to flaky tests.
     failures = [
@@ skipping 100 matching lines @@
         '--bot', ','.join(self.builders),
         '--revision', str(revision),
         '--name', job_name,
         '--user', self.commit_user.split('@', 1)[0]]
     cmd.extend(extra_args or [])
     cmd.extend(self.extra_flags)
     if self.tests:
       cmd.extend(('--testfilter', ','.join(self.tests)))
     if isinstance(emails, (list, tuple)):
       emails = ','.join(emails)
+    if isinstance(emails, unicode):
+      emails = str(emails)
     if isinstance(emails, str):
       cmd.extend(('--email', emails))
     else:
-      assert emails is None
+      assert emails is None, repr(emails)
     trychange.TryChange(
         cmd,
         file_list=[],
         swallow_exception=True)
 
   def _can_update_incrementally(self, queue):
     """Determines if the slow code path must be used.
 
     It's slow on the try server, not here.
     """
     if self.status.good_revisions is None:
+      logging.info('Fetching all try jobs status because of good_revisions')
       return False
     # Fetching the build status for all try jobs is expensive, so we try to
     # fetch the status just for the jobs we care about. We need the full set
     # only when we have newly pending commits and we don't know their try job
     # build numbers. TODO(maruel): revisit when reitveld gives us better APIs
     # to get the build numbers from rietveld instead from the try server.
-    for _, jobs in self.loop(queue, TryJobs):
+    for pending, jobs in self.loop(queue, TryJobs):
       if not jobs.try_jobs or jobs.get_state() != base.PROCESSING:
         continue
       if any(True for job in jobs.try_jobs if job.build is None):
         # We need to regenerate the whole data anyway.
+        logging.info(
+            'Fetching all try jobs status because of %s' %
+            pending.pending_name())
         return False
     return True
 
   def _find_job(self, pending, jobs, job):
     """Searches on the try server if the try job for |job| has started."""
     reason = u'\'%s: %s\' try job' % (
         self.commit_user.split('@', 1)[0], pending.pending_name())
     # Search for try jobs already sent for this issue. This happens if a
     # the commit bit was set, the try job fails because of a sick slave
     # and the user checks it again.
@@ skipping 20 matching lines @@
             job.builder,
             self.status.build_status_url(job)))
         jobs.error_message = msg
       else:
         msg = (u'Try job status for %s on %s: %s\n%s' % (
             pending.pending_name(),
             job.builder,
             job.result,
             self.status.build_status_url(job)))
       logging.info(msg)