Merge remote branch 'cros/upstream' into tempbranch

server/frontend.py

 # Copyright Martin J. Bligh, Google Inc 2008
 # Released under the GPL v2
 
 """
 This class allows you to communicate with the frontend to submit jobs etc
 It is designed for writing more sophisiticated server-side control files that
 can recursively add and manage other jobs.
 
 We turn the JSON dictionaries into real objects that are more idiomatic
 
@@ skipping 245 matching lines @@
             host_hash[host.hostname] = host
         for status in job_statuses:
             if status.host:
                 status.host = host_hash[status.host.hostname]
         # filter job statuses that have either host or meta_host
         return [status for status in job_statuses if (status.host or
                                                       status.meta_host)]
 
 
     def create_job_by_test(self, tests, kernel=None, use_container=False,
-                           **dargs):
+                           kernel_cmdline=None, **dargs):
         """
         Given a test name, fetch the appropriate control file from the server
         and submit it.
 
+        @param kernel: A comma separated list of kernel versions to boot.
+        @param kernel_cmdline: The command line used to boot all kernels listed
+                in the kernel parameter.
+
         Returns a list of job objects
         """
         assert ('hosts' in dargs or
                 'atomic_group_name' in dargs and 'synch_count' in dargs)
         if kernel:
             kernel_list =  re.split('[\s,]+', kernel.strip())
-            kernel_info = [{'version': version} for version in kernel_list]
+            kernel_info = []
+            for version in kernel_list:
+                kernel_dict = {'version': version}
+                if kernel_cmdline is not None:
+                    kernel_dict['cmdline'] = kernel_cmdline
+                kernel_info.append(kernel_dict)
         else:
             kernel_info = None
         control_file = self.generate_control_file(
                 tests=tests, kernel=kernel_info, use_container=use_container,
                 do_push_packages=True)
         if control_file.is_server:
             dargs['control_type'] = 'Server'
         else:
             dargs['control_type'] = 'Client'
         dargs['dependencies'] = dargs.get('dependencies', []) + \
@@ skipping 10 matching lines @@
     def create_job(self, control_file, name=' ', priority='Medium',
                 control_type='Client', **dargs):
         id = self.run('create_job', name=name, priority=priority,
                  control_file=control_file, control_type=control_type, **dargs)
         return self.get_jobs(id=id)[0]
 
 
     def run_test_suites(self, pairings, kernel, kernel_label=None,
                         priority='Medium', wait=True, poll_interval=10,
                         email_from=None, email_to=None, timeout=168,
-                        max_runtime_hrs=168):
+                        max_runtime_hrs=168, kernel_cmdline=None):
         """
         Run a list of test suites on a particular kernel.
 
         Poll for them to complete, and return whether they worked or not.
 
         @param pairings: List of MachineTestPairing objects to invoke.
         @param kernel: Name of the kernel to run.
         @param kernel_label: Label (string) of the kernel to run such as
                     '<kernel-version> : <config> : <date>'
                     If any pairing object has its job_label attribute set it
                     will override this value for that particular job.
+        @param kernel_cmdline: The command line to boot the kernel(s) with.
         @param wait: boolean - Wait for the results to come back?
         @param poll_interval: Interval between polling for job results (in mins)
         @param email_from: Send notification email upon completion from here.
         @param email_from: Send notification email upon completion to here.
         """
         jobs = []
         for pairing in pairings:
             try:
                 new_job = self.invoke_test(pairing, kernel, kernel_label,
                                            priority, timeout=timeout,
+                                           kernel_cmdline=kernel_cmdline,
                                            max_runtime_hrs=max_runtime_hrs)
                 if not new_job:
                     continue
                 jobs.append(new_job)
             except Exception, e:
                 traceback.print_exc()
         if not wait or not jobs:
             return
         tko = TKO()
         while True:
@@ skipping 107 matching lines @@
         """
         if not platforms:
             return True        # No filtering of platforms
         for platform in platforms:
             if re.search(platform, host.platform):
                 return True
         return False
 
 
     def invoke_test(self, pairing, kernel, kernel_label, priority='Medium',
-                    **dargs):
+                    kernel_cmdline=None, **dargs):
         """
         Given a pairing of a control file to a machine label, find all machines
         with that label, and submit that control file to them.
 
         @param kernel_label: Label (string) of the kernel to run such as
                 '<kernel-version> : <config> : <date>'
                 If any pairing object has its job_label attribute set it
                 will override this value for that particular job.
 
         @returns A list of job objects.
@@ skipping 11 matching lines @@
         if pairing.atomic_group_sched:
             dargs['synch_count'] = pairing.synch_count
             dargs['atomic_group_name'] = pairing.machine_label
         else:
             dargs['hosts'] = host_list
         new_job = self.create_job_by_test(name=job_name,
                                           dependencies=[pairing.machine_label],
                                           tests=[pairing.control_file],
                                           priority=priority,
                                           kernel=kernel,
+                                          kernel_cmdline=kernel_cmdline,
                                           use_container=pairing.container,
                                           **dargs)
         if new_job:
             if pairing.testname:
                 new_job.testname = pairing.testname
             print 'Invoked test %s : %s' % (new_job.id, job_name)
         return new_job
 
 
     def _job_test_results(self, tko, job, debug, tests=[]):
@@ skipping 393 matching lines @@
         self.container = container
         self.atomic_group_sched = atomic_group_sched
         self.synch_count = synch_count
         self.testname = testname
         self.job_label = job_label
 
 
     def __repr__(self):
         return '%s %s %s %s' % (self.machine_label, self.control_file,
                                 self.platforms, self.container)