def test_send_progress_does_not_trim_unknown_field(self):
driver = tu.FakeMesosExecutorDriver()
task_id = tu.get_random_task_id()
max_message_length = 30
poll_interval_ms = 10
send_progress_message = self.send_progress_message_helper(
driver, max_message_length)
progress_updater = cp.ProgressUpdater(task_id, max_message_length,
poll_interval_ms,
send_progress_message)
progress_data_0 = {
'progress-message':
b' pm',
'progress-sequence':
1,
'unknown':
'Unknown field has a really long lorem ipsum dolor sit amet exceed limit text'
}
progress_updater.send_progress_update(progress_data_0)
self.assertEqual(1, len(driver.messages))
actual_encoded_message_0 = driver.messages[0]
expected_message_0 = {
'progress-message':
'pm',
'progress-sequence':
1,
'task-id':
task_id,
'unknown':
'Unknown field has a really long lorem ipsum dolor sit amet exceed limit text'
}
tu.assert_message(self, expected_message_0, actual_encoded_message_0)
def test_send_progress_update_trims_progress_message(self):
driver = tu.FakeMesosExecutorDriver()
task_id = tu.get_random_task_id()
max_message_length = 30
poll_interval_ms = 10
send_progress_message = self.send_progress_message_helper(
driver, max_message_length)
progress_updater = cp.ProgressUpdater(task_id, max_message_length,
poll_interval_ms,
send_progress_message)
progress_data_0 = {
'progress-message':
b' Progress message-0 is really long lorem ipsum dolor sit amet text',
'progress-sequence': 1
}
progress_updater.send_progress_update(progress_data_0)
self.assertEqual(1, len(driver.messages))
actual_encoded_message_0 = driver.messages[0]
expected_message_0 = {
'progress-message': 'Progress message-0 is reall...',
'progress-sequence': 1,
'task-id': task_id
}
tu.assert_message(self, expected_message_0, actual_encoded_message_0)
def test_send_message(self):
driver = tu.FakeMesosExecutorDriver()
task_id = tu.get_random_task_id()
expected_message = {'task-id': task_id, 'message': 'test-message'}
result = ce.send_message(driver, tu.fake_os_error_handler,
expected_message)
self.assertTrue(result)
self.assertEqual(1, len(driver.messages))
actual_encoded_message = driver.messages[0]
tu.assert_message(self, expected_message, actual_encoded_message)
def manage_task_runner(self,
command,
assertions_fn,
stop_signal=None,
task_id=None,
config=None,
driver=None):
if driver is None:
driver = tu.FakeMesosExecutorDriver()
if stop_signal is None:
stop_signal = Event()
if task_id is None:
task_id = tu.get_random_task_id()
task = {
'task_id': {
'value': task_id
},
'data':
pm.encode_data(json.dumps({
'command': command
}).encode('utf8'))
}
stdout_name = tu.ensure_directory('build/stdout.{}'.format(task_id))
stderr_name = tu.ensure_directory('build/stderr.{}'.format(task_id))
tu.redirect_stdout_to_file(stdout_name)
tu.redirect_stderr_to_file(stderr_name)
completed_signal = Event()
if config is None:
sandbox_directory = '/location/to/task/sandbox/{}'.format(task_id)
config = cc.ExecutorConfig(
max_message_length=300,
progress_output_name=stdout_name,
progress_regex_string=
'\^\^\^\^JOB-PROGRESS:\s+([0-9]*\.?[0-9]+)($|\s+.*)',
progress_sample_interval_ms=100,
sandbox_directory=sandbox_directory)
else:
sandbox_directory = config.sandbox_directory
try:
ce.manage_task(driver, task, stop_signal, completed_signal, config)
self.assertTrue(completed_signal.isSet())
assertions_fn(driver, task_id, sandbox_directory)
finally:
tu.cleanup_output(stdout_name, stderr_name)
def test_create_status_running(self):
driver = tu.FakeMesosExecutorDriver()
task_id = tu.get_random_task_id()
status_updater = ce.StatusUpdater(driver, task_id)
actual_status = status_updater.create_status(cook.TASK_RUNNING)
expected_status = {
'task_id': {
'value': task_id
},
'state': cook.TASK_RUNNING
}
tu.assert_status(self, expected_status, actual_status)
def test_send_progress_update(self):
driver = tu.FakeMesosExecutorDriver()
task_id = tu.get_random_task_id()
max_message_length = 30
poll_interval_ms = 100
send_progress_message = self.send_progress_message_helper(
driver, max_message_length)
progress_updater = cp.ProgressUpdater(task_id, max_message_length,
poll_interval_ms,
send_progress_message)
progress_data_0 = {
'progress-message': b' Progress message-0',
'progress-sequence': 1
}
progress_updater.send_progress_update(progress_data_0)
self.assertEqual(1, len(driver.messages))
actual_encoded_message_0 = driver.messages[0]
expected_message_0 = {
'progress-message': 'Progress message-0',
'progress-sequence': 1,
'task-id': task_id
}
tu.assert_message(self, expected_message_0, actual_encoded_message_0)
progress_data_1 = {
'progress-message': b' Progress message-1',
'progress-sequence': 2
}
progress_updater.send_progress_update(progress_data_1)
self.assertEqual(1, len(driver.messages))
time.sleep(poll_interval_ms / 1000.0)
progress_data_2 = {
'progress-message': b' Progress message-2',
'progress-sequence': 3
}
progress_updater.send_progress_update(progress_data_2)
self.assertEqual(2, len(driver.messages))
actual_encoded_message_2 = driver.messages[1]
expected_message_2 = {
'progress-message': 'Progress message-2',
'progress-sequence': 3,
'task-id': task_id
}
tu.assert_message(self, expected_message_2, actual_encoded_message_2)
def test_executor_exit_env_variable(self, mock_exit):
os.environ['EXECUTOR_TEST_EXIT'] = '5'
try:
config = cc.ExecutorConfig()
stop_signal = Event()
executor = ce.CookExecutor(stop_signal, config)
driver = tu.FakeMesosExecutorDriver()
executor_info = {'executor_id': {'value': 'test'}}
framework_info = {'id': 'framework'}
agent_info = {'id': {'value': 'agent'}}
executor.registered(driver, executor_info, framework_info,
agent_info)
mock_exit.assert_called_with(5)
finally:
del os.environ['EXECUTOR_TEST_EXIT']
def test_os_error_handler_no_permission(self):
driver = tu.FakeMesosExecutorDriver()
task_id = tu.get_random_task_id()
status_updater = ce.StatusUpdater(driver, task_id)
stop_signal = Event()
os_error = OSError(errno.EPERM, 'No Permission')
ce.os_error_handler(stop_signal, status_updater, os_error)
self.assertTrue(stop_signal.isSet())
expected_statuses = [{
'task_id': {
'value': task_id
},
'state': cook.TASK_FAILED
}]
tu.assert_statuses(self, expected_statuses, driver.statuses)
def test_os_error_handler_no_memory(self):
driver = tu.FakeMesosExecutorDriver()
task_id = tu.get_random_task_id()
status_updater = ce.StatusUpdater(driver, task_id)
stop_signal = Event()
os_error = OSError(errno.ENOMEM, 'No Memory')
ce.os_error_handler(stop_signal, status_updater, os_error)
self.assertTrue(stop_signal.isSet())
expected_statuses = [{
'task_id': {
'value': task_id
},
'reason': cook.REASON_CONTAINER_LIMITATION_MEMORY,
'state': cook.TASK_FAILED
}]
tu.assert_statuses(self, expected_statuses, driver.statuses)
def test_update_status(self):
driver = tu.FakeMesosExecutorDriver()
task_id = tu.get_random_task_id()
status_updater = ce.StatusUpdater(driver, task_id)
task_state = "TEST_TASK_STATE"
self.assertTrue(status_updater.update_status(cook.TASK_STARTING))
self.assertTrue(status_updater.update_status(task_state))
self.assertTrue(
status_updater.update_status(cook.TASK_RUNNING, reason='Running'))
self.assertTrue(
status_updater.update_status(cook.TASK_FAILED,
reason='Termination'))
self.assertFalse(status_updater.update_status(cook.TASK_FINISHED))
expected_statuses = [{
'task_id': {
'value': task_id
},
'state': cook.TASK_STARTING
}, {
'task_id': {
'value': task_id
},
'state': task_state
}, {
'task_id': {
'value': task_id
},
'reason': 'Running',
'state': cook.TASK_RUNNING
}, {
'task_id': {
'value': task_id
},
'reason': 'Termination',
'state': cook.TASK_FAILED
}]
tu.assert_statuses(self, expected_statuses, driver.statuses)
def test_executor_launch_task_and_disconnect(self):
task_id = tu.get_random_task_id()
stdout_name = tu.ensure_directory('build/stdout.{}'.format(task_id))
stderr_name = tu.ensure_directory('build/stderr.{}'.format(task_id))
output_name = tu.ensure_directory('build/output.' + str(task_id))
tu.redirect_stdout_to_file(stdout_name)
tu.redirect_stderr_to_file(stderr_name)
try:
config = cc.ExecutorConfig()
stop_signal = Event()
executor = ce.CookExecutor(stop_signal, config)
driver = tu.FakeMesosExecutorDriver()
command = 'echo "Start" >> {}; sleep 100; echo "Done." >> {}; '.format(
output_name, output_name)
task = {
'task_id': {
'value': task_id
},
'data':
pm.encode_data(
json.dumps({
'command': command
}).encode('utf8'))
}
executor.launchTask(driver, task)
# let the process run for up to 10 seconds
for _ in range(1000):
time.sleep(0.01)
if os.path.isfile(output_name):
with open(output_name) as f:
content = f.read()
if 'Start' in content:
break
executor.disconnected(driver)
self.assertTrue(executor.disconnect_signal.isSet())
self.assertTrue(executor.stop_signal.isSet())
executor.await_completion()
logging.info('Task completed')
if os.path.isfile(output_name):
with open(output_name) as f:
file_contents = f.read()
self.assertTrue('Start' in file_contents)
self.assertTrue('Done' not in file_contents)
else:
self.fail('{} does not exist.'.format(stderr_name))
expected_statuses = [{
'task_id': {
'value': task_id
},
'state': cook.TASK_STARTING
}, {
'task_id': {
'value': task_id
},
'state': cook.TASK_RUNNING
}, {
'task_id': {
'value': task_id
},
'state': cook.TASK_KILLED
}]
tu.assert_statuses(self, expected_statuses, driver.statuses)
expected_message_0 = {
'sandbox-directory': '',
'task-id': task_id,
'type': 'directory'
}
expected_message_1 = {'exit-code': -15, 'task-id': task_id}
tu.assert_messages(self, [expected_message_0, expected_message_1],
[], driver.messages)
finally:
tu.cleanup_output(stdout_name, stderr_name)
tu.cleanup_file(output_name)