def testProcessCommandEvent_ignoreOutOfDateEvent(
self, mock_notify, mock_command_event_type_count):
"""Should complete command state for InvocationCompleted events."""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
tasks = command_manager.GetActiveTasks(self.command)
command_task_store.LeaseTask(tasks[0].task_id)
command_event_test_util.CreateCommandAttempt(
self.command, "0", common.CommandState.UNKNOWN, task=tasks[0])
invocation_completed_event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, "0", "InvocationCompleted",
task=tasks[0], time=TIMESTAMP_INT + 60)
invocation_started_event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, "0", "InvocationStarted",
task=tasks[0], time=TIMESTAMP_INT + 30)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.QUEUED, queried_command.state)
command_event_handler.ProcessCommandEvent(invocation_completed_event)
queried_command = command_manager.GetCommand(request_id, command_id)
command_attempt = command_manager.GetCommandAttempts(
request_id, command_id)[0]
self.assertEqual(
TIMESTAMP + datetime.timedelta(seconds=60),
command_attempt.last_event_time)
self.assertEqual(common.CommandState.COMPLETED, queried_command.state)
# The second event is ignored.
command_event_handler.ProcessCommandEvent(invocation_started_event)
queried_command = command_manager.GetCommand(request_id, command_id)
command_attempt = command_manager.GetCommandAttempts(
request_id, command_id)[0]
self.assertEqual(
TIMESTAMP + datetime.timedelta(seconds=60),
command_attempt.last_event_time)
self.assertEqual(common.CommandState.COMPLETED, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 0)
attempts = command_manager.GetCommandAttempts(
request_id, command_id)
self.assertEqual(1, len(attempts))
self.assertEqual("summary", attempts[0].summary)
self.assertEqual(1000, attempts[0].total_test_count)
self.assertEqual(100, attempts[0].failed_test_count)
mock_notify.assert_called_with(request_id)
# Metrics should still be logged for out of order events
started_metric_fields = {
metric.METRIC_FIELD_HOSTNAME: "hostname",
metric.METRIC_FIELD_TYPE: "InvocationStarted"
}
completed_metric_fields = {
metric.METRIC_FIELD_HOSTNAME: "hostname",
metric.METRIC_FIELD_TYPE: "InvocationCompleted"
}
mock_command_event_type_count.Increment.assert_has_calls(
[mock.call(completed_metric_fields),
mock.call(started_metric_fields)])
def testProcessCommandEvent_multiDevice(
self, mock_notify, mock_command_event_type_count):
"""Should populate multiple devices."""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
command_task_store.LeaseTask(tasks[0].task_id)
command_event_test_util.CreateCommandAttempt(
self.command, "0", common.CommandState.UNKNOWN, task=tasks[0])
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertNotEqual(common.CommandState.RUNNING, queried_command.state)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, "0", "InvocationStarted",
task=tasks[0], device_serials=["d1", "d2"])
command_event_handler.ProcessCommandEvent(event)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.RUNNING, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0].attempt_index, 0)
self.assertEqual(tasks[0].leasable, False)
attempts = command_manager.GetCommandAttempts(request_id, command_id)
self.assertEqual(1, len(attempts))
self.assertEqual(["d1", "d2"], attempts[0].device_serials)
mock_notify.assert_called_with(request_id)
expected_metric_fields = {
metric.METRIC_FIELD_HOSTNAME: "hostname",
metric.METRIC_FIELD_TYPE: "InvocationStarted"
}
mock_command_event_type_count.Increment.assert_called_once_with(
expected_metric_fields)
def testProcessCommandEvent_TFShutdown(
self, mock_notify, mock_command_event_type_count):
"""Mark command events that were terminated by TF shutdown as CANCELED."""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
error = "RunInterruptedException: Tradefed is shutting down."
for i in range(3):
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
command_task_store.LeaseTask(tasks[0].task_id)
command_event_test_util.CreateCommandAttempt(
self.command, str(i), common.CommandState.UNKNOWN, task=tasks[0])
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, str(i), "InvocationCompleted",
task=tasks[0], data={"error": error})
command_event_handler.ProcessCommandEvent(event)
# After three cancelled attempts, the command should still be queued.
queried_command = self.command.key.get()
self.assertEqual(common.CommandState.QUEUED, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
attempts = command_manager.GetCommandAttempts(request_id, command_id)
self.assertEqual(3, len(attempts))
mock_notify.assert_called_with(request_id)
expected_metric_fields = {
metric.METRIC_FIELD_HOSTNAME: "hostname",
metric.METRIC_FIELD_TYPE: "InvocationCompleted"
}
mock_command_event_type_count.Increment.assert_has_calls(
[mock.call(expected_metric_fields)] * 3)
def testProcessCommandEvent_invocationCompleted_multipleRunsWithErrors(
self, mock_notify):
"""Should complete command state for InvocationCompleted events.
This tests a case when a run count is greater than
command_manager.MAX_TASK_COUNT.
Args:
mock_notify: mock function to notify request state changes.
"""
run_count = 100
_, request_id, _, command_id = self.command.key.flat()
self.command.run_count = run_count
self.command.put()
command_manager.ScheduleTasks([self.command])
max_error_count = (
command_manager.MAX_ERROR_COUNT_BASE +
int(run_count * command_manager.MAX_ERROR_COUNT_RATIO))
for i in range(max_error_count):
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(
len(tasks), min(run_count - i, command_manager.MAX_TASK_COUNT))
next_leasable_task = next((t for t in tasks if t.leasable), None)
command_task_store.LeaseTask(next_leasable_task.task_id)
command_event_test_util.CreateCommandAttempt(
self.command, str(i), common.CommandState.UNKNOWN,
task=next_leasable_task)
# It should be marked as error at the max error count attempts.
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertNotEqual(common.CommandState.ERROR, queried_command.state)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, str(i), "InvocationCompleted",
task=next_leasable_task, error="error")
command_event_handler.ProcessCommandEvent(event)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.ERROR, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 0)
command_attempts = command_manager.GetCommandAttempts(
request_id, command_id)
self.assertEqual(len(command_attempts), max_error_count)
run_attempt_pairs = [
(attempt.run_index, attempt.attempt_index)
for attempt in command_attempts]
self.assertEqual(len(set(run_attempt_pairs)), len(command_attempts))
mock_notify.assert_called_with(request_id)
def testProcessCommandEvent_withRequestSync(self, mock_store_event,
mock_event_legacy_count):
_, request_id, _, command_id = self.command.key.flat()
sync_key = ndb.Key(
datastore_entities.RequestSyncStatus,
request_id,
namespace=common.NAMESPACE)
sync_status = datastore_entities.RequestSyncStatus(
key=sync_key, request_id=request_id)
sync_status.put()
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, "0000000", "InvocationCompleted")
command_event_handler.ProcessCommandEvent(event)
mock_store_event.assert_called_once_with(event)
mock_event_legacy_count.assert_not_called()
def testProcessCommandEvent_invocationCompleted_multipleRuns_20(
self, mock_notify):
"""Should complete command state for InvocationCompleted events.
This tests a case when a run count is greater than
command_manager.MAX_TASK_COUNT.
Args:
mock_notify: mock function to notify request state changes.
"""
run_count = 100
_, request_id, _, command_id = self.command.key.flat()
self.command.run_count = run_count
self.command.put()
command_manager.ScheduleTasks([self.command])
for i in range(run_count):
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(
len(tasks), min(run_count - i, command_manager.MAX_TASK_COUNT))
next_leasable_task = next((t for t in tasks if t.leasable), None)
command_task_store.LeaseTask(next_leasable_task.task_id)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertNotEqual(common.CommandState.COMPLETED, queried_command.state)
command_event_test_util.CreateCommandAttempt(
self.command, str(i), common.CommandState.UNKNOWN,
task=next_leasable_task)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, str(i), "InvocationCompleted",
task=next_leasable_task)
command_event_handler.ProcessCommandEvent(event)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.COMPLETED, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 0)
command_attempts = command_manager.GetCommandAttempts(
request_id, command_id)
self.assertEqual(len(command_attempts), run_count)
self.assertSetEqual(
set(attempt.run_index for attempt in command_attempts),
set(range(run_count)))
mock_notify.assert_called_with(request_id)
def testProcessCommandEvent_allocationFailed(self,
mock_command_event_type_count,
mock_event_legacy_count):
"""Should reschedule tasks that send AllocationFailed events."""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
# Command should stay queued even after MAX_CANCELED_COUNT_BASE different
# attempts result in an AllocationFailed error.
num_attempts = command_manager.MAX_CANCELED_COUNT_BASE
for i in range(num_attempts):
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
command_task_store.LeaseTask(tasks[0].task_id)
command_event_test_util.CreateCommandAttempt(
self.command, str(i), common.CommandState.UNKNOWN, task=tasks[0])
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertNotEqual(common.CommandState.ERROR, queried_command.state)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, str(i), "AllocationFailed", task=tasks[0])
command_event_handler.ProcessCommandEvent(event)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.CANCELED, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 0)
command_attempts = command_manager.GetCommandAttempts(
request_id, command_id)
self.assertEqual(
len(command_attempts), command_manager.MAX_CANCELED_COUNT_BASE)
self.assertSetEqual(
set(attempt.attempt_index for attempt in command_attempts),
set(range(command_manager.MAX_CANCELED_COUNT_BASE)))
expected_metric_fields = {
metric.METRIC_FIELD_HOSTNAME: "hostname",
metric.METRIC_FIELD_TYPE: "AllocationFailed"
}
mock_command_event_type_count.Increment.assert_has_calls(
[mock.call(expected_metric_fields)] * num_attempts)
mock_event_legacy_count.Increment.assert_has_calls([mock.call({})] *
num_attempts)
def testProcessCommandEvent_unknownEvent(self, mock_notify):
"""Should update command state for unknown events."""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
command_task_store.LeaseTask(tasks[0].task_id)
command_event_test_util.CreateCommandAttempt(
self.command, "0", common.CommandState.UNKNOWN, task=tasks[0])
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.QUEUED, queried_command.state)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, "0", "SomeRandomInexistentType", task=tasks[0])
command_event_handler.ProcessCommandEvent(event)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.QUEUED, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
mock_notify.not_called()
def testProcessCommandEvent_InvocationStarted(
self, mock_notify, mock_command_event_type_count):
"""Should update command state for InvocationStarted events.
State should become RUNNING if it isn't already.
Args:
mock_notify: mock function to notify request state changes.
mock_command_event_type_count: mock command event type count metric
"""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
command_task_store.LeaseTask(tasks[0].task_id)
command_event_test_util.CreateCommandAttempt(
self.command, "0", common.CommandState.UNKNOWN, task=tasks[0])
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertNotEqual(common.CommandState.RUNNING, queried_command.state)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, "0", "InvocationStarted", task=tasks[0])
command_event_handler.ProcessCommandEvent(event)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.RUNNING, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0].attempt_index, 0)
self.assertEqual(tasks[0].leasable, False)
attempts = command_manager.GetCommandAttempts(request_id, command_id)
self.assertEqual(1, len(attempts))
self.assertEqual(["0123456789ABCDEF"], attempts[0].device_serials)
mock_notify.assert_called_with(request_id)
expected_metric_fields = {
metric.METRIC_FIELD_HOSTNAME: "hostname",
metric.METRIC_FIELD_TYPE: "InvocationStarted"
}
mock_command_event_type_count.Increment.assert_called_once_with(
expected_metric_fields)
def testProcessCommandEvent_invocationCompleted(
self, mock_notify, mock_command_event_type_count):
"""Should complete command state for InvocationCompleted events.
Args:
mock_notify: mock function to notify request state changes.
mock_command_event_type_count: mock command event type count metric
"""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
command_task_store.LeaseTask(tasks[0].task_id)
command_event_test_util.CreateCommandAttempt(
self.command, "0", common.CommandState.UNKNOWN, task=tasks[0])
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertNotEqual(common.CommandState.COMPLETED, queried_command.state)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, "0", "InvocationCompleted", task=tasks[0])
command_event_handler.ProcessCommandEvent(event)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.COMPLETED, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 0)
attempts = command_manager.GetCommandAttempts(request_id, command_id)
self.assertEqual(1, len(attempts))
self.assertEqual("summary", attempts[0].summary)
self.assertEqual(1000, attempts[0].total_test_count)
self.assertEqual(100, attempts[0].failed_test_count)
self.assertEqual(10, attempts[0].failed_test_run_count)
mock_notify.assert_called_with(request_id)
expected_metric_fields = {
metric.METRIC_FIELD_HOSTNAME: "hostname",
metric.METRIC_FIELD_TYPE: "InvocationCompleted"
}
mock_command_event_type_count.Increment.assert_called_once_with(
expected_metric_fields)
def testProcessCommandEvent_fetchFailed(
self, mock_notify, mock_command_event_type_count):
"""Should error commands from FetchFailed events."""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
# It should be marked as error at the MAX_ERROR_COUNT_BASE attempt.
for i in range(command_manager.MAX_ERROR_COUNT_BASE):
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0].attempt_index, i)
command_task_store.LeaseTask(tasks[0].task_id)
command_event_test_util.CreateCommandAttempt(
self.command, str(i), common.CommandState.UNKNOWN, task=tasks[0])
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertNotEqual(common.CommandState.ERROR, queried_command.state)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, str(i), "FetchFailed", task=tasks[0])
command_event_handler.ProcessCommandEvent(event)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.ERROR, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 0)
command_attempts = command_manager.GetCommandAttempts(
request_id, command_id)
self.assertEqual(
len(command_attempts), command_manager.MAX_ERROR_COUNT_BASE)
self.assertSetEqual(
set(attempt.attempt_index for attempt in command_attempts),
set(range(command_manager.MAX_ERROR_COUNT_BASE)))
mock_notify.assert_called_with(request_id)
expected_metric_fields = {
metric.METRIC_FIELD_HOSTNAME: "hostname",
metric.METRIC_FIELD_TYPE: "FetchFailed"
}
mock_command_event_type_count.Increment.assert_has_calls(
[mock.call(expected_metric_fields)
] * command_manager.MAX_ERROR_COUNT_BASE)
def testProcessCommandEvent_fatalEvent(
self, mock_notify, mock_command_event_type_count):
"""Should not reschedule a configuration error, request should error out.
Args:
mock_notify: mock function to notify request state changes.
mock_command_event_type_count: mock command event type count metric
"""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 1)
command_task_store.LeaseTask(tasks[0].task_id)
command_event_test_util.CreateCommandAttempt(
self.command, "0", common.CommandState.UNKNOWN, task=tasks[0])
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertNotEqual(common.CommandState.FATAL, queried_command.state)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, "0", "ConfigurationError",
data={"error_status": "CUSTOMER_ISSUE"},
task=tasks[0])
command_event_handler.ProcessCommandEvent(event)
queried_command = command_manager.GetCommand(request_id, command_id)
self.assertEqual(common.CommandState.FATAL, queried_command.state)
tasks = command_manager.GetActiveTasks(self.command)
self.assertEqual(len(tasks), 0)
attempts = command_manager.GetCommandAttempts(request_id, command_id)
self.assertEqual(1, len(attempts))
mock_notify.assert_called_with(request_id)
expected_metric_fields = {
metric.METRIC_FIELD_HOSTNAME: "hostname",
metric.METRIC_FIELD_TYPE: "ConfigurationError"
}
mock_command_event_type_count.Increment.assert_called_once_with(
expected_metric_fields)
def testProcessCommandEvent_TooMuchContentionGetsRetried(self, mock_notify):
"""Should error commands from FetchFailed events."""
_, request_id, _, command_id = self.command.key.flat()
command_manager.ScheduleTasks([self.command])
tasks = command_manager.GetActiveTasks(self.command)
event = command_event_test_util.CreateTestCommandEvent(
request_id, command_id, 123, "FetchFailed", task=tasks[0])
mock_notify.side_effect = Exception(
'<_MultiThreadedRendezvous of RPC that terminated with: '
'status = StatusCode.ABORTED details = "too much content'
'ion on these datastore entities. please try again. enti'
'ty groups: [(app=p~ee-cloud-datastore, Asset, "NOAA/GOE'
'S/17/FDCC/2020195084117700000")]" debug_error_string = '
'"{"created":"@1594629864.343436240","description":"Erro'
'r received from peer ipv6:[2607:f8b0:4001:c01::5f]:443"'
',"file":"third_party/grpc/src/core/lib/surface/call.cc"'
',"file_line":1062,"grpc_message":"too much contention o'
'n these datastore entities. please try again. entity gr'
'oups: [(app=p~ee-cloud-datastore, Asset, "NOAA/GOES/17/'
'FDCC/2020195084117700000")]","grpc_status":10}" >')
with self.assertRaises(common.TooMuchContentionError):
command_event_handler.ProcessCommandEvent(event)
self.assertEqual(4, mock_notify.call_count)
