def __init__(self, data):
with self._lock:
self.jid = simulation_db.job_id(data)
pkdc('{}: created', self.jid)
if self.jid in self._job:
pkdlog(
'{}: Collision tid={} celery_state={}',
jid,
self.async_result,
self.async_result and self.async_result.state,
)
raise Collision(self.jid)
self.cmd, self.run_dir = simulation_db.prepare_simulation(data)
self._job[self.jid] = self
self.data = data
self._job[self.jid] = self
self.async_result = self._start_job()
pkdc(
'{}: started tid={} dir={} queue={} len_jobs={}',
self.jid,
self.async_result.task_id,
self.run_dir,
self.celery_queue,
len(self._job),
)
def api_runCancel():
data = _parse_data_input()
jid = simulation_db.job_id(data)
if feature_config.cfg.runner_daemon:
jhash = template_common.report_parameters_hash(data)
run_dir = simulation_db.simulation_run_dir(data)
runner_client.cancel_report_job(run_dir, jhash)
# Always true from the client's perspective
return http_reply.gen_json({'state': 'canceled'})
else:
# TODO(robnagler) need to have a way of listing jobs
# Don't bother with cache_hit check. We don't have any way of canceling
# if the parameters don't match so for now, always kill.
#TODO(robnagler) mutex required
if runner.job_is_processing(jid):
run_dir = simulation_db.simulation_run_dir(data)
# Write first, since results are write once, and we want to
# indicate the cancel instead of the termination error that
# will happen as a result of the kill.
simulation_db.write_result({'state': 'canceled'}, run_dir=run_dir)
runner.job_kill(jid)
# TODO(robnagler) should really be inside the template (t.cancel_simulation()?)
# the last frame file may not be finished, remove it
t = sirepo.template.import_module(data)
if hasattr(t, 'remove_last_frame'):
t.remove_last_frame(run_dir)
# Always true from the client's perspective
return http_reply.gen_json({'state': 'canceled'})
def __init__(self, data):
with self._lock:
self.jid = simulation_db.job_id(data)
pkdc('{}: created', self.jid)
if self.jid in self._job:
self = self._job[self.jid]
pkdlog(
'{}: Collision tid={} celery_state={}',
self.jid,
self.async_result,
self.async_result and self.async_result.state,
)
raise Collision(self.jid)
self.cmd, self.run_dir = simulation_db.prepare_simulation(data)
self._job[self.jid] = self
self.data = data
self._job[self.jid] = self
self.async_result = self._start_job()
pkdc(
'{}: started tid={} dir={} queue={} len_jobs={}',
self.jid,
self.async_result.task_id,
self.run_dir,
self.celery_queue,
len(self._job),
)
def __init__(self, data):
with self._lock:
self.jid = simulation_db.job_id(data)
if self.jid in self._job:
raise Collision(self.jid)
self.in_kill = None
self.cmd, self.run_dir = simulation_db.prepare_simulation(data)
self._job[self.jid] = self
self.pid = None
# This command may blow up
self.pid = self._start_job()
def __init__(self, data):
with self._lock:
self.jid = simulation_db.job_id(data)
if self.jid in self._job:
raise Collision(self.jid)
self.in_kill = None
self.cmd, self.run_dir = simulation_db.prepare_simulation(data)
self._job[self.jid] = self
self.pid = None
# This command may blow up
self.pid = self._start_job()
def job_start(data):
with _job_map_lock:
jid = simulation_db.job_id(data)
if jid in _job_map:
#TODO(robnagler) assumes external check of is_processing,
# which server._simulation_run_status does do, but this
# could be cleaner. Really want a reliable daemon thread
# to manage all this.
raise Collision(jid)
job = _job_class(jid, data)
_job_map[jid] = job
job.start()
def api_runSimulation():
data = _parse_data_input(validate=True)
res = _simulation_run_status(data, quiet=True)
if ((not res['state'] in _RUN_STATES and
(res['state'] != 'completed' or data.get('forceRun', False)))
or res.get('parametersChanged', True)):
try:
_start_simulation(data)
except runner.Collision:
pkdlog('{}: runner.Collision, ignoring start',
simulation_db.job_id(data))
res = _simulation_run_status(data)
return _json_response(res)
def app_run_simulation():
data = _parse_data_input(validate=True)
res = _simulation_run_status(data, quiet=True)
if (
(
not res['state'] in _RUN_STATES
and (res['state'] != 'completed' or data.get('forceRun', False))
) or res.get('parametersChanged', True)
):
try:
_start_simulation(data)
except runner.Collision:
pkdlog('{}: runner.Collision, ignoring start', simulation_db.job_id(data))
res = _simulation_run_status(data)
return _json_response(res)
def app_run_cancel():
data = _parse_data_input()
jid = simulation_db.job_id(data)
# TODO(robnagler) need to have a way of listing jobs
# Don't bother with cache_hit check. We don't have any way of canceling
# if the parameters don't match so for now, always kill.
#TODO(robnagler) mutex required
if cfg.job_queue.is_processing(jid):
run_dir = simulation_db.simulation_run_dir(data)
# Write first, since results are write once, and we want to
# indicate the cancel instead of the termination error that
# will happen as a result of the kill.
simulation_db.write_result({'state': 'canceled'}, run_dir=run_dir)
cfg.job_queue.kill(jid)
# TODO(robnagler) should really be inside the template (t.cancel_simulation()?)
# the last frame file may not be finished, remove it
t = sirepo.template.import_module(data)
t.remove_last_frame(run_dir)
# Always true from the client's perspective
return _json_response({'state': 'canceled'})
def api_runCancel():
data = _parse_data_input()
jid = simulation_db.job_id(data)
# TODO(robnagler) need to have a way of listing jobs
# Don't bother with cache_hit check. We don't have any way of canceling
# if the parameters don't match so for now, always kill.
#TODO(robnagler) mutex required
if cfg.job_queue.is_processing(jid):
run_dir = simulation_db.simulation_run_dir(data)
# Write first, since results are write once, and we want to
# indicate the cancel instead of the termination error that
# will happen as a result of the kill.
simulation_db.write_result({'state': 'canceled'}, run_dir=run_dir)
cfg.job_queue.kill(jid)
# TODO(robnagler) should really be inside the template (t.cancel_simulation()?)
# the last frame file may not be finished, remove it
t = sirepo.template.import_module(data)
t.remove_last_frame(run_dir)
# Always true from the client's perspective
return _json_response({'state': 'canceled'})
def api_runSimulation():
from pykern import pkjson
data = _parse_data_input(validate=True)
# if flag is set
# - check status
# - if status is bad, rewrite the run dir (XX race condition, to fix later)
# - then request it be started
if feature_config.cfg.runner_daemon:
jhash = template_common.report_parameters_hash(data)
run_dir = simulation_db.simulation_run_dir(data)
status = runner_client.report_job_status(run_dir, jhash)
already_good_status = [
runner_client.JobStatus.RUNNING, runner_client.JobStatus.COMPLETED
]
if status not in already_good_status:
data['simulationStatus'] = {
'startTime': int(time.time()),
'state': 'pending',
}
tmp_dir = run_dir + '-' + jhash + '-' + uuid.uuid4(
) + srdb.TMP_DIR_SUFFIX
cmd, _ = simulation_db.prepare_simulation(data, tmp_dir=tmp_dir)
runner_client.start_report_job(run_dir, jhash, cfg.backend, cmd,
tmp_dir)
res = _simulation_run_status_runner_daemon(data, quiet=True)
return http_reply.gen_json(res)
else:
res = _simulation_run_status(data, quiet=True)
if ((not res['state'] in _RUN_STATES and
(res['state'] != 'completed' or data.get('forceRun', False)))
or res.get('parametersChanged', True)):
try:
_start_simulation(data)
except runner.Collision:
pkdlog('{}: runner.Collision, ignoring start',
simulation_db.job_id(data))
res = _simulation_run_status(data)
return http_reply.gen_json(res)