Merge remote branch 'origin/upstream' into tempbranch

frontend/planner/models.py

 from django.db import models as dbmodels
 import common
 from autotest_lib.frontend.afe import models as afe_models
 from autotest_lib.frontend.afe import model_logic, rpc_utils
 from autotest_lib.frontend.tko import models as tko_models
 from autotest_lib.frontend.planner import model_attributes
 from autotest_lib.client.common_lib import utils
 
 
 class Plan(dbmodels.Model, model_logic.ModelExtensions):
     """A test plan
 
     Required:
         name: Plan name, unique
         complete: True if the plan is completed
         dirty: True if the plan has been changed since the execution engine has
                last seen it
         initialized: True if the plan has started
 
     Optional:
         label_override: A label to apply to each Autotest job.
-        support: The global support object to apply to this plan
+        support: The global support script to apply to this plan
     """
     name = dbmodels.CharField(max_length=255, unique=True)
     label_override = dbmodels.CharField(max_length=255, null=True, blank=True)
     support = dbmodels.TextField(blank=True)
     complete = dbmodels.BooleanField(default=False)
     dirty = dbmodels.BooleanField(default=False)
     initialized = dbmodels.BooleanField(default=False)
 
     owners = dbmodels.ManyToManyField(afe_models.User,
                                       db_table='planner_plan_owners')
@@ skipping 87 matching lines @@
     @classmethod
     def _compute_hash(cls, **kwargs):
         return utils.hash('sha1', kwargs['contents']).hexdigest()
 
 
     def __unicode__(self):
         return u'Control file id %s (SHA1: %s)' % (self.id, self.control_hash)
 
 
 class TestConfig(ModelWithPlan, model_logic.ModelExtensions):
-    """A planned test
+    """A configuration for a planned test
 
     Required:
         alias: The name to give this test within the plan. Unique with plan id
         test_control_file: The control file to run
         is_server: True if this control file is a server-side test
         execution_order: An integer describing when this test should be run in
                          the test plan
         estimated_runtime: Time in hours that the test is expected to run. Will
                            be automatically generated (on the frontend) for
                            tests in Autotest.
+        skipped_hosts: Hosts that are going to skip this test.
     """
     alias = dbmodels.CharField(max_length=255)
     control_file = dbmodels.ForeignKey(ControlFile)
     is_server = dbmodels.BooleanField(default=True)
     execution_order = dbmodels.IntegerField(blank=True)
     estimated_runtime = dbmodels.IntegerField()
+    skipped_hosts = dbmodels.ManyToManyField(
+            afe_models.Host, db_table='planner_test_configs_skipped_hosts')
 
     class Meta:
         db_table = 'planner_test_configs'
         ordering = ('execution_order',)
         unique_together = (('plan', 'alias'),)
 
 
     def _get_details_unicode(self):
         return 'Planned test config - Control file id %s' % self.control_file.id
 
 
 class Job(ModelWithPlan, model_logic.ModelExtensions):
     """Represents an Autotest job initiated for a test plan
 
     Required:
         test: The TestConfig associated with this Job
         afe_job: The Autotest job
     """
     test_config = dbmodels.ForeignKey(TestConfig)
     afe_job = dbmodels.ForeignKey(afe_models.Job)
+    requires_rerun = dbmodels.BooleanField(default=False)
 
     class Meta:
         db_table = 'planner_test_jobs'
 
 
     def _get_details_unicode(self):
         return 'AFE job %s' % self.afe_job.id
 
 
 class Bug(dbmodels.Model):
@@ skipping 35 matching lines @@
     test_job = dbmodels.ForeignKey(Job)
     tko_test = dbmodels.ForeignKey(tko_models.Test)
     host = dbmodels.ForeignKey(Host)
     status = dbmodels.CharField(
             max_length=16,
             choices=model_attributes.TestRunStatus.choices(),
             default=model_attributes.TestRunStatus.ACTIVE)
     finalized = dbmodels.BooleanField(default=False)
     seen = dbmodels.BooleanField(default=False)
     triaged = dbmodels.BooleanField(default=False)
+    invalidated = dbmodels.BooleanField(default=False)
 
     bugs = dbmodels.ManyToManyField(Bug, null=True,
                                     db_table='planner_test_run_bugs')
 
     class Meta:
         db_table = 'planner_test_runs'
         unique_together = (('plan', 'test_job', 'tko_test', 'host'),)
 
 
     def _get_details_unicode(self):
@@ skipping 150 matching lines @@
     bugs = dbmodels.ManyToManyField(Bug, null=True,
                                     db_table='planner_autoprocess_bugs')
     reason_override = dbmodels.CharField(max_length=255, null=True, blank=True)
 
     class Meta:
         db_table = 'planner_autoprocess'
 
 
     def _get_details_unicode(self):
         return 'Autoprocessing condition: %s' % self.condition