def post(self):
key_id = self.request.get('task_id', '')
try:
key = task_pack.unpack_result_summary_key(key_id)
except ValueError:
self.abort_with_error(400, error='Invalid key')
redirect_to = self.request.get('redirect_to', '')
task_scheduler.cancel_task(key)
if redirect_to == 'listing':
self.redirect('/user/tasks')
else:
self.redirect('/user/task/%s' % key_id)
def post(self):
key_id = self.request.get("task_id", "")
try:
key = task_pack.unpack_result_summary_key(key_id)
except ValueError:
self.abort_with_error(400, error="Invalid key")
redirect_to = self.request.get("redirect_to", "")
task_scheduler.cancel_task(key)
if redirect_to == "listing":
self.redirect("/user/tasks")
else:
self.redirect("/user/task/%s" % key_id)
def post(self):
key_id = self.request.get('task_id', '')
try:
key = task_pack.unpack_result_summary_key(key_id)
except ValueError:
self.abort_with_error(400, error='Invalid key')
redirect_to = self.request.get('redirect_to', '')
task_scheduler.cancel_task(key)
if redirect_to == 'listing':
self.redirect('/user/tasks')
else:
self.redirect('/user/task/%s' % key_id)
def post(self):
payload = json.loads(self.request.body)
logging.info('Cancelling tasks with ids: %s', payload['tasks'])
kill_running = payload['kill_running']
# TODO(maruel): Parallelize.
for task_id in payload['tasks']:
if not task_id:
logging.error('Cannot cancel a blank task')
continue
request_key, result_key = task_pack.get_request_and_result_keys(
task_id)
if not request_key or not result_key:
logging.error(
'Cannot search for a falsey key. Request: %s Result: %s',
request_key, result_key)
continue
request_obj = request_key.get()
if not request_obj:
logging.error('Request for %s was not found.',
request_key.id())
continue
ok, was_running = task_scheduler.cancel_task(
request_obj, result_key, kill_running)
logging.info('task %s canceled: %s was running: %s', task_id, ok,
was_running)
def cancel(self, request):
"""Cancels a task.
If a bot was running the task, the bot will forcibly cancel the task.
"""
logging.info('%s', request)
summary_key = task_pack.unpack_result_summary_key(request.task_id)
ok, was_running = task_scheduler.cancel_task(summary_key)
return swarming_rpcs.CancelResponse(ok=ok, was_running=was_running)
def cancel(self, request):
"""Cancels a task.
If a bot was running the task, the bot will forcibly cancel the task.
"""
logging.info('%s', request)
summary_key = task_pack.unpack_result_summary_key(request.task_id)
ok, was_running = task_scheduler.cancel_task(summary_key)
return swarming_rpcs.CancelResponse(ok=ok, was_running=was_running)
def test_cancel_task(self):
data = _gen_request_data(
properties=dict(dimensions={u'OS': u'Windows-3.1.1'}))
request = task_request.make_request(data)
result_summary = task_scheduler.schedule_request(request)
ok, was_running = task_scheduler.cancel_task(result_summary.key)
self.assertEqual(True, ok)
self.assertEqual(False, was_running)
result_summary = result_summary.key.get()
self.assertEqual(task_result.State.CANCELED, result_summary.state)
def test_cancel_task(self):
data = _gen_request_data(properties=dict(
dimensions={u'OS': u'Windows-3.1.1'}))
request = task_request.make_request(data)
result_summary = task_scheduler.schedule_request(request)
ok, was_running = task_scheduler.cancel_task(result_summary.key)
self.assertEqual(True, ok)
self.assertEqual(False, was_running)
result_summary = result_summary.key.get()
self.assertEqual(task_result.State.CANCELED, result_summary.state)
def post(self, task_id):
request, result = self.get_request_and_result(task_id)
if not task_scheduler.cancel_task(request, result.key)[0]:
self.abort(400, 'Task cancelation error')
# The cancel button appears at both the /tasks and /task pages. Redirect to
# the right place.
if self.request.get('redirect_to', '') == 'listing':
self.redirect('/user/tasks')
else:
self.redirect('/user/task/%s' % task_id)
def post(self):
request = self.parse_body()
task_id = request.get('task_id')
summary_key = task_pack.unpack_result_summary_key(task_id)
ok, was_running = task_scheduler.cancel_task(summary_key)
out = {
'ok': ok,
'was_running': was_running,
}
self.send_response(out)
def post(self):
request = self.parse_body()
task_id = request.get('task_id')
summary_key = task_pack.unpack_result_summary_key(task_id)
ok, was_running = task_scheduler.cancel_task(summary_key)
out = {
'ok': ok,
'was_running': was_running,
}
self.send_response(out)
def cancel(self, request):
"""Cancels a task.
If a bot was running the task, the bot will forcibly cancel the task.
"""
logging.debug('%s', request)
request_key, result_key = _to_keys(request.task_id)
request_obj = _get_task_request_async(request.task_id, request_key,
_EDIT).get_result()
ok, was_running = task_scheduler.cancel_task(
request_obj, result_key, request.kill_running or False)
return swarming_rpcs.CancelResponse(ok=ok, was_running=was_running)
def test_cancel_task_running(self):
data = _gen_request_data(
properties=dict(dimensions={u'OS': u'Windows-3.1.1'}))
request = task_request.make_request(data)
result_summary = task_scheduler.schedule_request(request)
reaped_request, run_result = task_scheduler.bot_reap_task(
{'OS': 'Windows-3.1.1'}, 'localhost', 'abc')
ok, was_running = task_scheduler.cancel_task(result_summary.key)
self.assertEqual(False, ok)
self.assertEqual(True, was_running)
result_summary = result_summary.key.get()
self.assertEqual(task_result.State.RUNNING, result_summary.state)
def test_cancel_task_running(self):
data = _gen_request_data(properties=dict(
dimensions={u'OS': u'Windows-3.1.1'}))
request = task_request.make_request(data)
result_summary = task_scheduler.schedule_request(request)
reaped_request, run_result = task_scheduler.bot_reap_task(
{'OS': 'Windows-3.1.1'}, 'localhost', 'abc')
ok, was_running = task_scheduler.cancel_task(result_summary.key)
self.assertEqual(False, ok)
self.assertEqual(True, was_running)
result_summary = result_summary.key.get()
self.assertEqual(task_result.State.RUNNING, result_summary.state)
def test_cancel_task(self):
data = _gen_request(
properties=dict(dimensions={u'OS': u'Windows-3.1.1'}),
pubsub_topic='projects/abc/topics/def')
pub_sub_calls = self.mock_pub_sub()
request = task_request.make_request(data, True)
result_summary = task_scheduler.schedule_request(request)
ok, was_running = task_scheduler.cancel_task(result_summary.key)
self.assertEqual(True, ok)
self.assertEqual(False, was_running)
result_summary = result_summary.key.get()
self.assertEqual(task_result.State.CANCELED, result_summary.state)
self.assertEqual(1, len(pub_sub_calls)) # sent completion notification
def test_cancel_task_running(self):
data = _gen_request(
properties=dict(dimensions={u'OS': u'Windows-3.1.1'}),
pubsub_topic='projects/abc/topics/def')
pub_sub_calls = self.mock_pub_sub()
request = task_request.make_request(data, True)
result_summary = task_scheduler.schedule_request(request)
reaped_request, run_result = task_scheduler.bot_reap_task(
{'OS': 'Windows-3.1.1'}, 'localhost', 'abc')
ok, was_running = task_scheduler.cancel_task(result_summary.key)
self.assertEqual(False, ok)
self.assertEqual(True, was_running)
result_summary = result_summary.key.get()
self.assertEqual(task_result.State.RUNNING, result_summary.state)
self.assertEqual(0, len(pub_sub_calls)) # no notifications
def post(self):
# There's two ways to query, either with TaskToRun.queue_number or with
# TaskResultSummary.state.
canceled = 0
was_running = 0
q = task_result.TaskResultSummary.query(
task_result.TaskResultSummary.state == task_result.State.PENDING)
status = ''
try:
for result_key in q.iter(keys_only=True):
request_obj = task_pack.result_summary_key_to_request_key(
result_key).get()
ok, wr = task_scheduler.cancel_task(request_obj, result_key)
if ok:
canceled += 1
if wr:
was_running += 1
status = 'Success'
except runtime.DeadlineExceededError:
status = 'Deadline exceeded'
self.response.write(
'Canceled %d tasks.\n%d tasks were running.\n%s' %
(canceled, was_running, status))
def cancel(self, request): """Cancels a task and indicate success.""" summary_key = task_pack.unpack_result_summary_key(request.task_id) ok, was_running = task_scheduler.cancel_task(summary_key) return swarming_rpcs.CancelResponse(ok=ok, was_running=was_running)
def cancel(self, request):
"""Cancels a task and indicate success."""
summary_key = task_pack.unpack_result_summary_key(request.task_id)
ok, was_running = task_scheduler.cancel_task(summary_key)
return swarming_rpcs.CancelResponse(ok=ok, was_running=was_running)
