Removing the isolate.py functionality and requiring tasks to be created from an archive hash rather…

testing/legion/task_controller.py

 # Copyright 2015 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.
 
 """Defines the task controller library."""
 
 import argparse
 import datetime
 import logging
 import os
@@ skipping 31 matching lines @@
   task.Create()
   task.WaitForConnection()
   proc = task.rpc.subprocess.Popen(['ls'])
   print task.rpc.subprocess.GetStdout(proc)
   task.Release()
   """
 
   _task_count = 0
   _tasks = []
 
-  def __init__(self, isolate_file, config_vars, dimensions, priority=100,
+  def __init__(self, isolated_hash, dimensions, priority=100,
                idle_timeout_secs=common_lib.DEFAULT_TIMEOUT_SECS,
                connection_timeout_secs=common_lib.DEFAULT_TIMEOUT_SECS,
-               verbosity='ERROR', name=None):
-    assert isinstance(config_vars, dict)
+               verbosity='ERROR', name=None, run_id=None):
     assert isinstance(dimensions, dict)
     type(self)._tasks.append(self)
     type(self)._task_count += 1
     self.verbosity = verbosity
     self._name = name or 'Task%d' % type(self)._task_count
     self._priority = priority
-    self._isolate_file = isolate_file
-    self._isolated_file = isolate_file + 'd'
+    self._isolated_hash = isolated_hash
     self._idle_timeout_secs = idle_timeout_secs
-    self._config_vars = config_vars
     self._dimensions = dimensions
     self._connect_event = threading.Event()
     self._connected = False
     self._ip_address = None
     self._otp = self._CreateOTP()
     self._rpc = None
 
+    run_id = run_id or datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
+    self._task_name = '%s/%s/%s' % (
+        os.path.splitext(sys.argv[0])[0], self._name, run_id)
+
     parser = argparse.ArgumentParser()
     parser.add_argument('--isolate-server')
     parser.add_argument('--swarming-server')
     parser.add_argument('--task-connection-timeout-secs',
                         default=common_lib.DEFAULT_TIMEOUT_SECS)
     args, _ = parser.parse_known_args()
 
     self._isolate_server = args.isolate_server
     self._swarming_server = args.swarming_server
     self._connection_timeout_secs = (connection_timeout_secs or
@@ skipping 46 matching lines @@
     test_name = os.path.basename(sys.argv[0])
     creation_time = datetime.datetime.utcnow()
     otp = 'task:%s controller:%s test:%s creation:%s' % (
         self._name, controller_name, test_name, creation_time)
     return otp
 
   def Create(self):
     """Creates the task machine."""
     logging.info('Creating %s', self.name)
     self._connect_event.clear()
-    self._ExecuteIsolate()
     self._ExecuteSwarming()
 
   def WaitForConnection(self):
     """Waits for the task machine to connect.
 
     Raises:
       ConnectionTimeoutError if the task doesn't connect in time.
     """
     logging.info('Waiting for %s to connect with a timeout of %d seconds',
                  self._name, self._connection_timeout_secs)
     self._connect_event.wait(self._connection_timeout_secs)
     if not self._connect_event.is_set():
       raise ConnectionTimeoutError('%s failed to connect' % self.name)
 
   def Release(self):
     """Quits the task's RPC server so it can release the machine."""
     if self._rpc is not None and self._connected:
       logging.info('Releasing %s', self._name)
       try:
         self._rpc.Quit()
       except (socket.error, xmlrpclib.Fault):
         logging.error('Unable to connect to %s to call Quit', self.name)
       self._rpc = None
       self._connected = False
 
-  def _ExecuteIsolate(self):
-    """Executes isolate.py."""
-    cmd = [
-        'python',
-        ISOLATE_PY,
-        'archive',
-        '--isolate', self._isolate_file,
-        '--isolated', self._isolated_file,
-        ]
-
-    if self._isolate_server:
-      cmd.extend(['--isolate-server', self._isolate_server])
-    for key, value in self._config_vars.iteritems():
-      cmd.extend(['--config-var', key, value])
-
-    self._ExecuteProcess(cmd)
-
   def _ExecuteSwarming(self):
     """Executes swarming.py."""
     cmd = [
         'python',
         SWARMING_PY,
         'trigger',
-        self._isolated_file,
+        self._isolated_hash,
         '--priority', str(self._priority),
+        '--task-name', self._task_name,
         ]
 
     if self._isolate_server:
       cmd.extend(['--isolate-server', self._isolate_server])
     if self._swarming_server:
       cmd.extend(['--swarming', self._swarming_server])
     for key, value in self._dimensions.iteritems():
       cmd.extend(['--dimension', key, value])
 
     cmd.extend([
@@ skipping 14 matching lines @@
     if p.returncode != 0:
       raise Error(stderr)
 
   def OnConnect(self, ip_address):
     """Receives task ip address on connection."""
     self._ip_address = ip_address
     self._connected = True
     self._rpc = common_lib.ConnectToServer(self._ip_address)
     logging.info('%s connected from %s', self._name, ip_address)
     self._connect_event.set()