Add CIPD pin reporting to swarming.

appengine/swarming/server/task_scheduler_test.py

 #!/usr/bin/env python
 # Copyright 2014 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 datetime
 import inspect
 import logging
 import os
 import random
@@ skipping 251 matching lines @@
         bot_dimensions, 'localhost', 'abc', None)
     self.assertEqual(request, actual_request)
     self.assertEqual('localhost', run_result.bot_id)
     self.assertEqual(None, task_to_run.TaskToRun.query().get().queue_number)
     # It's important to terminate the task with success.
     self.assertEqual(
         task_result.State.COMPLETED,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='Foo1',
             output_chunk_start=0,
             exit_code=0,
             duration=0.1,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
     return unicode(run_result.task_id)
@@ skipping 18 matching lines @@
     self.assertEqual(None, task_to_run.TaskToRun.query().get().queue_number)
     actual_request_2, run_result_2 = task_scheduler.bot_reap_task(
         bot_dimensions, 'localhost', 'abc', None)
     self.assertEqual(None, actual_request_2)
     result_summary_duped, run_results_duped = get_results(request.key)
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': now or self.now,
       'costs_usd': [],
       'cost_saved_usd': 0.1,
       'created_ts': new_ts,
       'deduped_from': deduped_from,
       'duration': 0.1,
       'exit_code': 0,
       'failure': False,
       'id': task_id,
@@ skipping 140 matching lines @@
         bot_dimensions, 'localhost', 'abc', None)
     self.assertEqual(request, actual_request)
     self.assertEqual('localhost', run_result.bot_id)
     self.assertEqual(None, task_to_run.TaskToRun.query().get().queue_number)
     # It's important to terminate the task with success.
     self.assertEqual(
         task_result.State.COMPLETED,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='Foo1',
             output_chunk_start=0,
             exit_code=0,
             duration=0.1,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
 
@@ skipping 28 matching lines @@
     _result_summary = task_scheduler.schedule_request(request)
 
     # The TaskRequest was enqueued, the TaskResultSummary was created but no
     # TaskRunResult exist yet since the task was not scheduled on any bot.
     result_summary, run_results = get_results(request.key)
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': None,
       'bot_id': None,
       'bot_version': None,
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'costs_usd': [],
       'cost_saved_usd': None,
       'created_ts': created_ts,
       'deduped_from': None,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 25 matching lines @@
     reaped_request, run_result = task_scheduler.bot_reap_task(
         bot_dimensions, 'localhost', 'abc', None)
     self.assertEqual(request, reaped_request)
     self.assertTrue(run_result)
     result_summary, run_results = get_results(request.key)
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'costs_usd': [0.],
       'cost_saved_usd': None,
       'created_ts': created_ts,  # Time the TaskRequest was created.
       'deduped_from': None,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 15 matching lines @@
       'try_number': 1,
       'user': u'Jesus',
     }
     self.assertEqual(expected, result_summary.to_dict())
     expected = [
       {
         'abandoned_ts': None,
         'bot_dimensions': bot_dimensions,
         'bot_id': u'localhost',
         'bot_version': u'abc',
+        'cipd_pins': None,
         'children_task_ids': [],
         'completed_ts': None,
         'cost_usd': 0.,
         'duration': None,
         'exit_code': None,
         'failure': False,
         'id': '1d69b9f088008811',
         'internal_failure': False,
         'modified_ts': reaped_ts,
         'outputs_ref': None,
@@ skipping 20 matching lines @@
           items_hot='bb'),
         isolated_upload=task_result.OperationStats(
           duration=0.1,
           items_cold='aa',
           items_hot='bb'))
     self.assertEqual(
         task_result.State.COMPLETED,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='Foo1',
             output_chunk_start=0,
             exit_code=0,
             duration=3.,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=outputs_ref,
             performance_stats=performance_stats))
     # Simulate an unexpected retry, e.g. the response of the previous RPC never
     # got the the client even if it succeedded.
     self.assertEqual(
         task_result.State.COMPLETED,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='Foo1',
             output_chunk_start=0,
             exit_code=0,
             duration=3.,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=outputs_ref,
             performance_stats=performance_stats))
     result_summary, run_results = get_results(request.key)
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': done_ts,
       'costs_usd': [0.1],
       'cost_saved_usd': None,
       'created_ts': created_ts,
       'deduped_from': None,
       'duration': 3.0,
       'exit_code': 0,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 19 matching lines @@
       'try_number': 1,
       'user': u'Jesus',
     }
     self.assertEqual(expected, result_summary.to_dict())
     expected = [
       {
         'abandoned_ts': None,
         'bot_dimensions': bot_dimensions,
         'bot_id': u'localhost',
         'bot_version': u'abc',
+        'cipd_pins': None,
         'children_task_ids': [],
         'completed_ts': done_ts,
         'cost_usd': 0.1,
         'duration': 3.0,
         'exit_code': 0,
         'failure': False,
         'id': '1d69b9f088008811',
         'internal_failure': False,
         'modified_ts': done_ts,
         'outputs_ref': {
@@ skipping 19 matching lines @@
     _result_summary = task_scheduler.schedule_request(request)
     bot_dimensions = {'OS': 'Windows-3.1.1', u'pool': u'default'}
     reaped_request, run_result = task_scheduler.bot_reap_task(
         bot_dimensions, 'localhost', 'abc', None)
     self.assertEqual(request, reaped_request)
     self.assertEqual(
         task_result.State.COMPLETED,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='Foo1',
             output_chunk_start=0,
             exit_code=1,
             duration=0.1,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
     result_summary, run_results = get_results(request.key)
 
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': self.now,
       'costs_usd': [0.1],
       'cost_saved_usd': None,
       'created_ts': self.now,
       'deduped_from': None,
       'duration': 0.1,
       'exit_code': 1,
       'failure': True,
       'id': '1d69b9f088008810',
@@ skipping 16 matching lines @@
       'user': u'Jesus',
     }
     self.assertEqual(expected, result_summary.to_dict())
 
     expected = [
       {
         'abandoned_ts': None,
         'bot_dimensions': bot_dimensions,
         'bot_id': u'localhost',
         'bot_version': u'abc',
+        'cipd_pins': None,
         'children_task_ids': [],
         'completed_ts': self.now,
         'cost_usd': 0.1,
         'duration': 0.1,
         'exit_code': 1,
         'failure': True,
         'id': '1d69b9f088008811',
         'internal_failure': False,
         'modified_ts': self.now,
         'outputs_ref': None,
@@ skipping 14 matching lines @@
     task_request.init_new_request(request, True)
     self.assertTrue(task_scheduler.schedule_request(request))
 
   def test_bot_update_task(self):
     run_result = _quick_reap()
     self.assertEqual(
         task_result.State.RUNNING,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='hi',
             output_chunk_start=0,
             exit_code=None,
             duration=None,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
     self.assertEqual(
         task_result.State.COMPLETED,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='hey',
             output_chunk_start=2,
             exit_code=0,
             duration=0.1,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
     self.assertEqual('hihey', run_result.key.get().get_output())
 
   def test_bot_update_task_new_overwrite(self):
     run_result = _quick_reap()
     self.assertEqual(
         task_result.State.RUNNING,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='hi',
             output_chunk_start=0,
             exit_code=None,
             duration=None,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
     self.assertEqual(
         task_result.State.RUNNING,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='hey',
             output_chunk_start=1,
             exit_code=None,
             duration=None,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
     self.assertEqual('hhey', run_result.key.get().get_output())
 
   def test_bot_update_exception(self):
     run_result = _quick_reap()
     def r(*_):
       raise datastore_utils.CommitError('Sorry!')
 
     self.mock(ndb, 'put_multi', r)
     self.assertEqual(
         None,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='hi',
             output_chunk_start=0,
             exit_code=0,
             duration=0.1,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
 
@@ skipping 15 matching lines @@
         bot_dimensions, 'localhost', 'abc', None)
     self.assertEqual('localhost', run_result.bot_id)
 
     # Attempt to terminate the task with success, but make PubSub call fail.
     self.mock_pub_sub(publish_successful=False)
     self.assertEqual(
         None,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='Foo1',
             output_chunk_start=0,
             exit_code=0,
             duration=0.1,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
 
     # Bot retries bot_update, now PubSub works and notification is sent.
     pub_sub_calls = self.mock_pub_sub(publish_successful=True)
     self.assertEqual(
         task_result.State.COMPLETED,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='Foo1',
             output_chunk_start=0,
             exit_code=0,
             duration=0.1,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
     self.assertEqual(1, len(pub_sub_calls)) # notification is sent
 
   def _bot_update_timeouts(self, hard, io):
     self.mock(random, 'getrandbits', lambda _: 0x88)
     request = _gen_request(
         properties={
           'dimensions': {u'OS': u'Windows-3.1.1', u'pool': u'default'},
         })
     task_request.init_new_request(request, True)
     result_summary = task_scheduler.schedule_request(request)
     bot_dimensions = {'OS': 'Windows-3.1.1', u'pool': u'default'}
     reaped_request, run_result = task_scheduler.bot_reap_task(
         bot_dimensions, 'localhost', 'abc', None)
     self.assertEqual(
         task_result.State.TIMED_OUT,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost',
+            cipd_pins=None,
             output='hi',
             output_chunk_start=0,
             exit_code=0,
             duration=0.1,
             hard_timeout=hard,
             io_timeout=io,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': self.now,
       'costs_usd': [0.1],
       'cost_saved_usd': None,
       'created_ts': self.now,
       'deduped_from': None,
       'duration': 0.1,
       'exit_code': 0,
       'failure': True,
       'id': '1d69b9f088008810',
@@ skipping 15 matching lines @@
       'try_number': 1,
       'user': u'Jesus',
     }
     self.assertEqual(expected, result_summary.key.get().to_dict())
 
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': self.now,
       'cost_usd': 0.1,
       'duration': 0.1,
       'exit_code': 0,
       'failure': True,
       'id': '1d69b9f088008811',
       'internal_failure': False,
       'modified_ts': self.now,
       'outputs_ref': None,
@@ skipping 22 matching lines @@
     reaped_request, run_result = task_scheduler.bot_reap_task(
         {'OS': 'Windows-3.1.1', u'pool': u'default'}, 'localhost', 'abc', None)
 
     self.assertEqual(
         None, task_scheduler.bot_kill_task(run_result.key, 'localhost'))
     expected = {
       'abandoned_ts': self.now,
       'bot_dimensions': dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'costs_usd': [0.],
       'cost_saved_usd': None,
       'created_ts': self.now,
       'deduped_from': None,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 14 matching lines @@
       ],
       'try_number': 1,
       'user': u'Jesus',
     }
     self.assertEqual(expected, result_summary.key.get().to_dict())
     expected = {
       'abandoned_ts': self.now,
       'bot_dimensions': dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'cost_usd': 0.,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008811',
       'internal_failure': True,
       'modified_ts': self.now,
       'outputs_ref': None,
@@ skipping 68 matching lines @@
     abandoned_ts = self.mock_now(self.now, request.expiration_secs+1)
     self.assertEqual(
         ['1d69b9f088008810'],
         task_scheduler.cron_abort_expired_task_to_run('f.local'))
     self.assertEqual([], task_result.TaskRunResult.query().fetch())
     expected = {
       'abandoned_ts': abandoned_ts,
       'bot_dimensions': None,
       'bot_id': None,
       'bot_version': None,
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'costs_usd': [],
       'cost_saved_usd': None,
       'created_ts': self.now,
       'deduped_from': None,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 53 matching lines @@
     abandoned_ts = self.mock_now(self.now, request.expiration_secs+1)
     self.assertEqual(
         ['1d69b9f088008810'],
         task_scheduler.cron_abort_expired_task_to_run('f.local'))
     self.assertEqual(1, len(task_result.TaskRunResult.query().fetch()))
     expected = {
       'abandoned_ts': abandoned_ts,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'costs_usd': [0.],
       'cost_saved_usd': None,
       'created_ts': self.now,
       'deduped_from': None,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 47 matching lines @@
     self.assertEqual(task_result.State.RUNNING, run_result.state)
     now_1 = self.mock_now(self.now + task_result.BOT_PING_TOLERANCE, 1)
     self.assertEqual(([], 1, 0), task_scheduler.cron_handle_bot_died('f.local'))
 
     # Refresh and compare:
     expected = {
       'abandoned_ts': now_1,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'cost_usd': 0.,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008811',
       'internal_failure': True,
       'modified_ts': now_1,
       'outputs_ref': None,
       'server_versions': [u'v1a'],
       'started_ts': self.now,
       'state': task_result.State.BOT_DIED,
       'try_number': 1,
     }
     self.assertEqual(expected, run_result.key.get().to_dict())
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'costs_usd': [0.],
       'cost_saved_usd': None,
       'created_ts': self.now,
       'deduped_from': None,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 24 matching lines @@
     now_2 = self.mock_now(self.now + task_result.BOT_PING_TOLERANCE, 2)
     _request, run_result = task_scheduler.bot_reap_task(
         bot_dimensions, 'localhost-second', 'abc', None)
     logging.info('%s', [t.to_dict() for t in task_to_run.TaskToRun.query()])
     self.assertEqual(2, run_result.try_number)
     self.assertEqual(
         task_result.State.COMPLETED,
         task_scheduler.bot_update_task(
             run_result_key=run_result.key,
             bot_id='localhost-second',
+            cipd_pins=None,
             output='Foo1',
             output_chunk_start=0,
             exit_code=0,
             duration=0.1,
             hard_timeout=False,
             io_timeout=False,
             cost_usd=0.1,
             outputs_ref=None,
             performance_stats=None))
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost-second',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': now_2,
       'costs_usd': [0., 0.1],
       'cost_saved_usd': None,
       'created_ts': self.now,
       'deduped_from': None,
       'duration': 0.1,
       'exit_code': 0,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 45 matching lines @@
     self.assertEqual(task_result.State.RUNNING, run_result.state)
     now_1 = self.mock_now(self.now + task_result.BOT_PING_TOLERANCE, 1)
     self.assertEqual(([], 1, 0), task_scheduler.cron_handle_bot_died('f.local'))
 
     # Refresh and compare:
     expected = {
       'abandoned_ts': now_1,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'cost_usd': 0.,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008811',
       'internal_failure': True,
       'modified_ts': now_1,
       'outputs_ref': None,
       'server_versions': [u'v1a'],
       'started_ts': self.now,
       'state': task_result.State.BOT_DIED,
       'try_number': 1,
     }
     self.assertEqual(expected, run_result.key.get().to_dict())
     expected = {
       'abandoned_ts': None,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'costs_usd': [0.],
       'cost_saved_usd': None,
       'created_ts': self.now,
       'deduped_from': None,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 56 matching lines @@
     now_2 = self.mock_now(self.now + 2 * task_result.BOT_PING_TOLERANCE, 3)
     self.assertEqual(
         (['1d69b9f088008812'], 0, 0),
         task_scheduler.cron_handle_bot_died('f.local'))
     self.assertEqual(([], 0, 0), task_scheduler.cron_handle_bot_died('f.local'))
     expected = {
       'abandoned_ts': now_2,
       'bot_dimensions': bot_dimensions,
       'bot_id': u'localhost-second',
       'bot_version': u'abc',
+      'cipd_pins': None,
       'children_task_ids': [],
       'completed_ts': None,
       'costs_usd': [0., 0.],
       'cost_saved_usd': None,
       'created_ts': self.now,
       'deduped_from': None,
       'duration': None,
       'exit_code': None,
       'failure': False,
       'id': '1d69b9f088008810',
@@ skipping 43 matching lines @@
         (['1d69b9f088008811'], 0, 0),
         task_scheduler.cron_handle_bot_died('f.local'))
 
 
 if __name__ == '__main__':
   if '-v' in sys.argv:
     unittest.TestCase.maxDiff = None
   logging.basicConfig(
       level=logging.DEBUG if '-v' in sys.argv else logging.CRITICAL)
   unittest.main()