task_runner: always use run_isolated

appengine/swarming/swarming_bot/bot_code/task_runner_test.py

 #!/usr/bin/env python
 # coding=utf-8
 # Copyright 2013 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 import base64
 import json
 import logging
 import os
+import re
 import signal
-import shutil
 import sys
 import tempfile
 import time
 import unittest
 
 import test_env_bot_code
 test_env_bot_code.setup_test_env()
 
 # Creates a server mock for functions in net.py.
 import net_utils
@@ skipping 91 matching lines @@
         },
         kwargs)
     return check_first
 
 
 class TestTaskRunner(TestTaskRunnerBase):
   def setUp(self):
     super(TestTaskRunner, self).setUp()
     self.mock(time, 'time', lambda: 1000000000.)
 
-  def get_check_final(self, exit_code=0, output='hi\n', outputs_ref=None):
+  def get_check_final(self, exit_code=0, output_re=r'^hi\n$', outputs_ref=None):
     def check_final(kwargs):
-      # It makes the diffing easier.
+      # Ignore these values.
+      kwargs['data'].pop('bot_overhead', None)
+      kwargs['data'].pop('duration', None)
+
+      output = ''
       if 'output' in kwargs['data']:
-        kwargs['data']['output'] = base64.b64decode(kwargs['data']['output'])
+        output = base64.b64decode(kwargs['data'].pop('output'))
+      self.assertTrue(re.match(output_re, output))
+
       expected = {
         'data': {
           'cost_usd': 10.,
-          'duration': 0.,
           'exit_code': exit_code,
           'hard_timeout': False,
           'id': 'localhost',
           'io_timeout': False,
-          'output': output,
           'output_chunk_start': 0,
           'task_id': 23,
         },
       }
       if outputs_ref:
         expected['data']['outputs_ref'] = outputs_ref
       self.assertEqual(expected, kwargs)
     return check_final
 
   def _run_command(self, task_details):
@@ skipping 173 matching lines @@
     expected = {
       u'exit_code': 1,
       u'hard_timeout': False,
       u'io_timeout': False,
       u'must_signal_internal_failure': None,
       u'version': task_runner.OUT_VERSION,
     }
     self.assertEqual(expected, self._run_command(task_details))
 
   def test_run_command_os_error(self):
-    # This runs the command for real.
-    # OS specific error, fix expectation for other OSes.
-    output = (
-      'Command "executable_that_shouldnt_be_on_your_system '
-      'thus_raising_OSError" failed to start.\n'
-      'Error: [Error 2] The system cannot find the file specified'
-      ) if sys.platform == 'win32' else (
-      'Command "executable_that_shouldnt_be_on_your_system '
-      'thus_raising_OSError" failed to start.\n'
-      'Error: [Errno 2] No such file or directory')
-    self.requests(cost_usd=10., exit_code=1, output=output)
+    self.requests(
+        cost_usd=10.,
+        exit_code=1,
+        output_re=(
+            # This is a beginning of run_isolate.py's output if binary is not
+            # found.
+            r'^<The executable does not exist or a dependent library is '
+            r'missing>'))
     task_details = task_runner.TaskDetails(
         {
           'bot_id': 'localhost',
           'command': [
             'executable_that_shouldnt_be_on_your_system',
             'thus_raising_OSError',
           ],
           'env': {},
           'extra_args': [],
           'grace_period': 30.,
           'hard_timeout': 6,
           'io_timeout': 6,
           'isolated': None,
           'task_id': 23,
         })
     expected = {
       u'exit_code': 1,
       u'hard_timeout': False,
       u'io_timeout': False,
       u'must_signal_internal_failure': None,
       u'version': task_runner.OUT_VERSION,
     }
     self.assertEqual(expected, self._run_command(task_details))
 
   def test_run_command_large(self):
     # Method should have "self" as first argument - pylint: disable=E0213
     class Popen(object):
       """Mocks the process so we can control how data is returned."""
-      def __init__(self2, cmd, cwd, env, stdout, stderr, stdin, detached):
-        self.assertEqual(task_details.command, cmd)
+      def __init__(self2, _cmd, cwd, env, stdout, stderr, stdin, detached):
         self.assertEqual(self.work_dir, cwd)
         expected_env = os.environ.copy()
         expected_env['foo'] = 'bar'
         self.assertEqual(expected_env, env)
         self.assertEqual(subprocess42.PIPE, stdout)
         self.assertEqual(subprocess42.STDOUT, stderr)
         self.assertEqual(subprocess42.PIPE, stdin)
         self.assertEqual(True, detached)
         self2._out = [
           'hi!\n',
@@ skipping 179 matching lines @@
     '  except IOError:\n'
     '    pass;\n'
     'print(\'bye\');\n'
     'time.sleep(100)') % (
         'signal.SIGBREAK' if sys.platform == 'win32' else 'signal.SIGTERM')
 
   SCRIPT_HANG = 'import time; print(\'hi\'); time.sleep(100)'
 
   def get_check_final(
       self, hard_timeout=False, io_timeout=False, exit_code=None,
-      output='hi\n'):
+      output_re='^hi\n$'):
     def check_final(kwargs):
+      kwargs['data'].pop('bot_overhead', None)
       if hard_timeout or io_timeout:
         self.assertLess(self.SHORT_TIME_OUT, kwargs['data'].pop('cost_usd'))
         self.assertLess(self.SHORT_TIME_OUT, kwargs['data'].pop('duration'))
       else:
         self.assertLess(0., kwargs['data'].pop('cost_usd'))
         self.assertLess(0., kwargs['data'].pop('duration'))
-      # It makes the diffing easier.
-      kwargs['data']['output'] = base64.b64decode(kwargs['data']['output'])
+
+      output = ''
+      if 'output' in kwargs['data']:
+        output = base64.b64decode(kwargs['data'].pop('output'))
+      self.assertTrue(re.match(output_re, output))
+
       self.assertEqual(
           {
             'data': {
               'exit_code': exit_code,
               'hard_timeout': hard_timeout,
               'id': 'localhost',
               'io_timeout': io_timeout,
-              'output': output,
               'output_chunk_start': 0,
               'task_id': 23,
             },
           },
           kwargs)
     return check_final
 
   def _load_and_run(self, manifest):
     # Dot not mock time since this test class is testing timeouts.
     server = 'https://localhost:1'
@@ skipping 17 matching lines @@
     self.requests(hard_timeout=True, exit_code=sig)
     task_details = self.get_task_details(
         self.SCRIPT_HANG, hard_timeout=self.SHORT_TIME_OUT)
     expected = {
       u'exit_code': sig,
       u'hard_timeout': True,
       u'io_timeout': False,
       u'must_signal_internal_failure': None,
       u'version': task_runner.OUT_VERSION,
     }
-    self.assertEqual(expected, self._run_command(task_details))
+    actual = self._run_command(task_details)
+    actual.pop('bot_overhead', None)
+    self.assertEqual(expected, actual)
 
   def test_io(self):
     # Actually 0xc000013a
     sig = -1073741510 if sys.platform == 'win32' else -signal.SIGTERM
     self.requests(io_timeout=True, exit_code=sig)
     task_details = self.get_task_details(
         self.SCRIPT_HANG, io_timeout=self.SHORT_TIME_OUT)
     expected = {
       u'exit_code': sig,
       u'hard_timeout': False,
       u'io_timeout': True,
       u'must_signal_internal_failure': None,
       u'version': task_runner.OUT_VERSION,
     }
     self.assertEqual(expected, self._run_command(task_details))
 
   def test_hard_signal(self):
     self.requests(
         hard_timeout=True,
         exit_code=0,
-        output='hi\ngot signal %d\nbye\n' % task_runner.SIG_BREAK_OR_TERM)
+        output_re='^hi\ngot signal %d\nbye\n$' % task_runner.SIG_BREAK_OR_TERM)
     task_details = self.get_task_details(
         self.SCRIPT_SIGNAL, hard_timeout=self.SHORT_TIME_OUT)
     # Returns 0 because the process cleaned up itself.
     expected = {
       u'exit_code': 0,
       u'hard_timeout': True,
       u'io_timeout': False,
       u'must_signal_internal_failure': None,
       u'version': task_runner.OUT_VERSION,
     }
     self.assertEqual(expected, self._run_command(task_details))
 
   def test_io_signal(self):
     self.requests(
         io_timeout=True, exit_code=0,
-        output='hi\ngot signal %d\nbye\n' % task_runner.SIG_BREAK_OR_TERM)
+        output_re='^hi\ngot signal %d\nbye\n$' % task_runner.SIG_BREAK_OR_TERM)
     task_details = self.get_task_details(
         self.SCRIPT_SIGNAL, io_timeout=self.SHORT_TIME_OUT)
     # Returns 0 because the process cleaned up itself.
     expected = {
       u'exit_code': 0,
       u'hard_timeout': False,
       u'io_timeout': True,
       u'must_signal_internal_failure': None,
       u'version': task_runner.OUT_VERSION,
     }
@@ skipping 28 matching lines @@
       u'io_timeout': True,
       u'must_signal_internal_failure': None,
       u'version': task_runner.OUT_VERSION,
     }
     self.assertEqual(expected, self._run_command(task_details))
 
   def test_hard_signal_no_grace(self):
     exit_code = 1 if sys.platform == 'win32' else -signal.SIGKILL
     self.requests(
         hard_timeout=True, exit_code=exit_code,
-        output='hi\ngot signal %d\nbye\n' % task_runner.SIG_BREAK_OR_TERM)
+        output_re='^hi\ngot signal %d\nbye\n$' % task_runner.SIG_BREAK_OR_TERM)
     task_details = self.get_task_details(
         self.SCRIPT_SIGNAL_HANG, hard_timeout=self.SHORT_TIME_OUT,
         grace_period=self.SHORT_TIME_OUT)
     # Returns 0 because the process cleaned up itself.
     expected = {
       u'exit_code': exit_code,
       u'hard_timeout': True,
       u'io_timeout': False,
       u'must_signal_internal_failure': None,
       u'version': task_runner.OUT_VERSION,
     }
     self.assertEqual(expected, self._run_command(task_details))
 
   def test_io_signal_no_grace(self):
     exit_code = 1 if sys.platform == 'win32' else -signal.SIGKILL
     self.requests(
         io_timeout=True, exit_code=exit_code,
-        output='hi\ngot signal %d\nbye\n' % task_runner.SIG_BREAK_OR_TERM)
+        output_re='^hi\ngot signal %d\nbye\n$' % task_runner.SIG_BREAK_OR_TERM)
     task_details = self.get_task_details(
         self.SCRIPT_SIGNAL_HANG, io_timeout=self.SHORT_TIME_OUT,
         grace_period=self.SHORT_TIME_OUT)
     # Returns 0 because the process cleaned up itself.
     expected = {
       u'exit_code': exit_code,
       u'hard_timeout': False,
       u'io_timeout': True,
       u'must_signal_internal_failure': None,
       u'version': task_runner.OUT_VERSION,
@@ skipping 291 matching lines @@
     while os.path.isfile(signal_file):
       time.sleep(0.01)
     # Send SIGTERM to task_runner itself. Ensure the right thing happen.
     # Note that on Windows, this is actually sending a SIGBREAK since there's no
     # such thing as SIGTERM.
     proc.send_signal(signal.SIGTERM)
     proc.wait()
     task_runner_log = os.path.join(self.root_dir, 'logs', 'task_runner.log')
     with open(task_runner_log, 'rb') as f:
       logging.info('task_runner.log:\n---\n%s---', f.read())
-    expected = {
-      u'exit_code': 0,
-      u'hard_timeout': False,
-      u'io_timeout': False,
-      u'must_signal_internal_failure': None,
-      u'version': task_runner.OUT_VERSION,
-    }
     self.assertEqual([], self._server.get_events())
     tasks = self._server.get_tasks()
     for task in tasks.itervalues():
       for event in task:
         event.pop('cost_usd')
         event.pop('duration', None)
         event.pop('bot_overhead', None)
     expected = {
       '23': [
         {
           u'id': u'localhost',
           u'task_id': 23,
         },
         {
           u'exit_code': exit_code,
           u'hard_timeout': False,
           u'id': u'localhost',
           u'io_timeout': False,
           u'task_id': 23,
         },
       ],
     }
     self.assertEqual(expected, tasks)
     expected = {
       'swarming_bot.1.zip',
       '4e019f31778ba7191f965469dc673280386bbd60-cacert.pem',
       'work',
       'logs',
+      'isolated',
       # TODO(maruel): Move inside work.
       'task_runner_in.json',
       'task_runner_out.json',
     }
     self.assertEqual(expected, set(os.listdir(self.root_dir)))
     expected = {
       u'exit_code': exit_code,
       u'hard_timeout': False,
       u'io_timeout': False,
       u'must_signal_internal_failure':
           u'task_runner received signal %d' % task_runner.SIG_BREAK_OR_TERM,
       u'version': 3,
     }
     with open(task_result_file, 'rb') as f:
       self.assertEqual(expected, json.load(f))
     self.assertEqual(0, proc.returncode)
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   if '-v' in sys.argv:
     unittest.TestCase.maxDiff = None
   logging_utils.prepare_logging(None)
   logging_utils.set_console_level(
       logging.DEBUG if '-v' in sys.argv else logging.CRITICAL+1)
   # Fix litteral text expectation.
   os.environ['LANG'] = 'en_US.UTF-8'
   os.environ['LANGUAGE'] = 'en_US.UTF-8'
   unittest.main()