def _set_task_status(self, state): update = TaskStatus(state=state, timestamp_ms=int(self._clock.time() * 1000), runner_pid=os.getpid(), runner_uid=os.getuid()) runner_ckpt = RunnerCkpt(task_status=update) self._dispatcher.dispatch(self._state, runner_ckpt, self._recovery)
def _write_process_update(self, **kw): """Write a process update to the coordinator's checkpoint stream.""" process_status = ProcessStatus(**kw) process_status.seq = self._seq process_status.process = self.name() self._ckpt_write(RunnerCkpt(process_status=process_status)) self._seq += 1
def write_header(root, sandbox, task_id): log_dir = os.path.join(sandbox, '.logs') path = TaskPath(root=root, task_id=task_id, log_dir=log_dir) header = RunnerHeader(task_id=task_id, sandbox=sandbox, log_dir=log_dir) ckpt = TaskRunnerHelper.open_checkpoint(path.getpath('runner_checkpoint')) ckpt.write(RunnerCkpt(runner_header=header)) ckpt.close()
def _initialize_ckpt_header(self): """ Initializes the RunnerHeader for this checkpoint stream if it has not already been constructed. """ if self._state.header is None: try: uid = pwd.getpwnam(self._user).pw_uid except KeyError: # This will cause failures downstream, but they will at least be correctly # reflected in the process state. log.error('Unknown user %s.' % self._user) uid = None header = RunnerHeader( task_id=self._task_id, launch_time_ms=int(self._launch_time * 1000), sandbox=self._sandbox, log_dir=self._log_dir, hostname=self._hostname, user=self._user, uid=uid, ports=self._portmap) runner_ckpt = RunnerCkpt(runner_header=header) self._dispatcher.dispatch(self._state, runner_ckpt)
def test_garbage_collector(safe_rmtree, safe_delete): with temporary_dir() as sandbox, temporary_dir( ) as checkpoint_root, temporary_dir() as log_dir: path = TaskPath(root=checkpoint_root, task_id='test', log_dir=log_dir) touch(os.path.join(sandbox, 'test_file1')) touch(os.path.join(sandbox, 'test_file2')) safe_mkdir( os.path.dirname(path.given(state='finished').getpath('task_path'))) safe_mkdir(os.path.dirname(path.getpath('runner_checkpoint'))) touch(path.given(state='finished').getpath('task_path')) header = RunnerHeader(task_id='test', sandbox=sandbox, log_dir=log_dir) ckpt = TaskRunnerHelper.open_checkpoint( path.getpath('runner_checkpoint')) ckpt.write(RunnerCkpt(runner_header=header)) ckpt.close() gc = TaskGarbageCollector(checkpoint_root, task_id='test') assert gc._state.header.log_dir == log_dir assert gc._state.header.sandbox == sandbox # erase metadata gc.erase_metadata() safe_delete.assert_has_calls([ call(path.given(state='finished').getpath('task_path')), call(path.getpath('runner_checkpoint')) ], any_order=True) safe_rmtree.assert_has_calls([call(path.getpath('checkpoint_path'))]) safe_delete.reset_mock() safe_rmtree.reset_mock() # erase logs gc.erase_logs() safe_rmtree.assert_has_calls([call(log_dir)]) safe_delete.reset_mock() safe_rmtree.reset_mock() # erase sandbox gc.erase_data() safe_delete.assert_has_calls([ call(os.path.join(sandbox, 'test_file1')), call(os.path.join(sandbox, 'test_file2')) ], any_order=True) safe_rmtree.assert_has_calls([call(sandbox)])
def _initialize_ckpt_header(self): """ Initializes the RunnerHeader for this checkpoint stream if it has not already been constructed. """ if self._state.header is None: header = RunnerHeader(task_id=self._task_id, launch_time_ms=int(self._launch_time * 1000), sandbox=self._sandbox, log_dir=self._log_dir, hostname=socket.gethostname(), user=self._user, ports=self._portmap) runner_ckpt = RunnerCkpt(runner_header=header) self._dispatcher.dispatch(self._state, runner_ckpt)
def _set_process_status(self, process_name, process_state, **kw): if 'sequence_number' in kw: sequence_number = kw.pop('sequence_number') log.debug('_set_process_status(%s <= %s, seq=%s[force])' % (process_name, ProcessState._VALUES_TO_NAMES.get(process_state), sequence_number)) else: current_run = self._current_process_run(process_name) if not current_run: assert process_state == ProcessState.WAITING sequence_number = 0 else: sequence_number = current_run.seq + 1 log.debug('_set_process_status(%s <= %s, seq=%s[auto])' % (process_name, ProcessState._VALUES_TO_NAMES.get(process_state), sequence_number)) runner_ckpt = RunnerCkpt(process_status=ProcessStatus( process=process_name, state=process_state, seq=sequence_number, **kw)) self._dispatcher.dispatch(self._state, runner_ckpt, self._recovery)
def on_initialization(self, header): log.debug('_on_initialization: %s' % header) ThermosTaskValidator.assert_valid_task(self._runner.task) ThermosTaskValidator.assert_valid_ports(self._runner.task, header.ports) self._checkpoint(RunnerCkpt(runner_header=header))
def on_task_transition(self, state, task_update): log.debug('_on_task_transition: %s' % task_update) self._checkpoint(RunnerCkpt(task_status=task_update))
def on_process_transition(self, state, process_update): log.debug('_on_process_transition: %s' % process_update) self._checkpoint(RunnerCkpt(process_status=process_update))
def write_process_status(status): ckpt.write(RunnerCkpt(process_status=status))
def write_task_state(state): update = TaskStatus(state=state, timestamp_ms=int(clock.time() * 1000), runner_pid=os.getpid(), runner_uid=os.getuid()) ckpt.write(RunnerCkpt(task_status=update))