def _gen_request(**kwargs):
"""Returns an initialized task_request.TaskRequest."""
now = utils.utcnow()
args = {
# Don't be confused, this is not part of the API. This code is constructing
# a DB entity, not a swarming_rpcs.NewTaskRequest.
u'created_ts':
now,
u'manual_tags': [u'tag:1'],
u'name':
u'yay',
u'priority':
50,
u'task_slices': [
task_request.TaskSlice(expiration_secs=60,
properties=_gen_properties(),
wait_for_capacity=False),
],
u'user':
u'Jesus',
}
args.update(kwargs)
ret = task_request.TaskRequest(**args)
task_request.init_new_request(ret, True, task_request.TEMPLATE_AUTO)
return ret
def make_task_request(
self, service_account, service_account_token, try_number=1):
now = utils.utcnow()
args = {
'created_ts': now,
'manual_tags': [u'tag:1'],
'name': 'Request with %s' % service_account,
'priority': 50,
'task_slices': [
task_request.TaskSlice(
expiration_secs=60,
properties=task_request.TaskProperties(
command=[u'command1'],
dimensions_data={u'pool': [u'default']},
execution_timeout_secs=24*60*60)),
],
'user': '******',
}
req = task_request.TaskRequest(**args)
task_request.init_new_request(req, True)
req.key = task_request.new_request_key()
req.service_account = service_account
req.service_account_token = service_account_token
req.put()
summary_key = task_pack.request_key_to_result_summary_key(req.key)
run_result_key = task_pack.result_summary_key_to_run_result_key(
summary_key, try_number)
return task_pack.pack_run_result_key(run_result_key)
def _gen_request(properties=None, **kwargs):
"""Creates a TaskRequest."""
properties = properties or {}
def merge(override, defaults):
if override is None:
return None
result = defaults.copy()
result.update(override)
return result
cipd_input = properties.pop('cipd_input', {})
cipd_input = merge(cipd_input, {
'client_package': merge(cipd_input.pop('client_package', {}), {
'package_name': 'infra/tools/cipd/${platform}',
'version': 'git_revision:deadbeef',
}),
'packages': [{
'package_name': 'rm',
'path': 'bin',
'version': 'git_revision:deadbeef',
}],
'server': 'https://chrome-infra-packages.appspot.com'
})
inputs_ref = properties.pop('inputs_ref', {
'isolatedserver': 'https://isolateserver.appspot.com',
'namespace': 'default-gzip',
})
properties = merge(properties, {
'cipd_input': cipd_input,
'command': [u'command1', u'arg1'],
'dimensions': {
u'OS': u'Windows-3.1.1',
u'hostname': u'localhost',
u'pool': u'default',
},
'env': {u'foo': u'bar', u'joe': u'2'},
'execution_timeout_secs': 30,
'grace_period_secs': 30,
'idempotent': False,
'inputs_ref': inputs_ref,
'io_timeout_secs': None,
})
now = utils.utcnow()
args = {
'created_ts': now,
'name': 'Request name',
'priority': 50,
'properties': properties,
'expiration_ts': now + datetime.timedelta(seconds=30),
'tags': [u'tag:1'],
'user': '******',
}
args.update(kwargs)
# Note that ndb model constructor accepts dicts for structured properties.
return task_request.TaskRequest(**args)
def setUp(self):
super(AclTest, self).setUp()
def settings():
return config_pb2.SettingsCfg(auth=config_pb2.AuthSettings(
admins_group='admins',
bot_bootstrap_group='bot_bootstrap',
privileged_users_group='privileged_users',
users_group='users',
view_all_bots_group='view_all_bots',
view_all_tasks_group='view_all_tasks'))
self.mock(config, 'settings', settings)
auth_testing.reset_local_state()
self._task_owned = task_request.TaskRequest(
authenticated=auth.get_current_identity())
self._task_other = task_request.TaskRequest(
authenticated=auth.Identity(auth.IDENTITY_USER, 'larry@localhost'))
def post(self):
logging.error('Unexpected old client')
data = self.parse_body()
msg = log_unexpected_subset_keys(self._EXPECTED_DATA_KEYS,
self._REQUIRED_DATA_KEYS, data,
self.request, 'client',
'request keys')
if msg:
self.abort_with_error(400, error=msg)
data_properties = data['properties']
msg = log_unexpected_subset_keys(self._EXPECTED_PROPERTIES_KEYS,
self._REQUIRED_PROPERTIES_KEYS,
data_properties, self.request,
'client', 'request properties keys')
if msg:
self.abort_with_error(400, error=msg)
# Class TaskProperties takes care of making everything deterministic.
properties = task_request.TaskProperties(
commands=data_properties['commands'],
data=data_properties['data'],
dimensions=data_properties['dimensions'],
env=data_properties['env'],
execution_timeout_secs=data_properties['execution_timeout_secs'],
grace_period_secs=data_properties.get('grace_period_secs', 30),
idempotent=data_properties.get('idempotent', False),
io_timeout_secs=data_properties['io_timeout_secs'])
now = utils.utcnow()
expiration_ts = now + datetime.timedelta(
seconds=data['scheduling_expiration_secs'])
request = task_request.TaskRequest(
created_ts=now,
expiration_ts=expiration_ts,
name=data['name'],
parent_task_id=data.get('parent_task_id'),
priority=data['priority'],
properties=properties,
tags=data['tags'],
user=data['user'] or '')
try:
request = task_request.make_request(request, acl.is_bot_or_admin())
except (AttributeError, datastore_errors.BadValueError, TypeError,
ValueError) as e:
self.abort_with_error(400, error=str(e))
result_summary = task_scheduler.schedule_request(request)
data = {
'request': request.to_dict(),
'task_id': task_pack.pack_result_summary_key(result_summary.key),
}
self.send_response(utils.to_json_encodable(data))
def _gen_request_slices(**kwargs):
"""Creates a TaskRequest."""
now = utils.utcnow()
args = {
u'created_ts': now,
u'manual_tags': [u'tag:1'],
u'name': u'Request name',
u'priority': 50,
u'user': u'Jesus',
}
args.update(kwargs)
req = task_request.TaskRequest(**args)
task_request.init_new_request(req, True, task_request.TEMPLATE_AUTO)
return req
def _gen_request_slices(**kwargs):
"""Creates a TaskRequest."""
now = utils.utcnow()
args = {
u'created_ts': now,
u'manual_tags': [u'tag:1'],
u'name': u'Request name',
u'priority': 50,
u'task_slices': [
task_request.TaskSlice(expiration_secs=30, properties=_gen_properties()),
],
u'user': u'Jesus',
}
args.update(kwargs)
# Note that ndb model constructor accepts dicts for structured properties.
req = task_request.TaskRequest(**args)
task_request.init_new_request(req, True)
return req
def _gen_request(properties=None):
"""Creates a TaskRequest."""
now = utils.utcnow()
args = {
'created_ts': now,
'manual_tags': [u'tag:1'],
'name': 'Request name',
'priority': 50,
'task_slices': [
task_request.TaskSlice(
expiration_secs=60,
properties=properties or _gen_properties()),
],
'user': '******',
}
req = task_request.TaskRequest(**args)
task_request.init_new_request(req, True, task_request.TEMPLATE_AUTO)
return req
def terminate(self, request):
"""Asks a bot to terminate itself gracefully.
The bot will stay in the DB, use 'delete' to remove it from the DB
afterward. This request returns a pseudo-taskid that can be waited for to
wait for the bot to turn down.
This command is particularly useful when a privileged user needs to safely
debug a machine specific issue. The user can trigger a terminate for one of
the bot exhibiting the issue, wait for the pseudo-task to run then access
the machine with the guarantee that the bot is not running anymore.
"""
# TODO(maruel): Disallow a terminate task when there's one currently
# pending or if the bot is considered 'dead', e.g. no contact since 10
# minutes.
logging.info('%s', request)
bot_key = bot_management.get_info_key(request.bot_id)
get_or_raise(bot_key) # raises 404 if there is no such bot
try:
# Craft a special priority 0 task to tell the bot to shutdown.
properties = task_request.TaskProperties(
dimensions={u'id': request.bot_id},
execution_timeout_secs=0,
grace_period_secs=0,
io_timeout_secs=0)
now = utils.utcnow()
request = task_request.TaskRequest(
created_ts=now,
expiration_ts=now + datetime.timedelta(days=1),
name='Terminate %s' % request.bot_id,
priority=0,
properties=properties,
tags=['terminate:1'],
user=auth.get_current_identity().to_bytes())
assert request.properties.is_terminate
posted_request = task_request.make_request(request,
acl.is_bot_or_admin())
except (datastore_errors.BadValueError, TypeError, ValueError) as e:
raise endpoints.BadRequestException(e.message)
result_summary = task_scheduler.schedule_request(posted_request)
return swarming_rpcs.TerminateResponse(
task_id=task_pack.pack_result_summary_key(result_summary.key))
def _gen_request(properties=None, **kwargs):
"""Creates a TaskRequest."""
props = {
'command': [u'command1'],
'dimensions': {u'pool': u'default'},
'env': {},
'execution_timeout_secs': 24*60*60,
'io_timeout_secs': None,
}
props.update(properties or {})
now = utils.utcnow()
args = {
'created_ts': now,
'name': 'Request name',
'priority': 50,
'properties': task_request.TaskProperties(**props),
'expiration_ts': now + datetime.timedelta(seconds=60),
'tags': [u'tag:1'],
'user': '******',
}
args.update(kwargs)
return task_request.TaskRequest(**args)
def _gen_request(properties=None, **kwargs):
"""Creates a TaskRequest."""
props = {
'commands': [[u'command1', u'arg1']],
'data': [
[u'http://localhost/foo', u'foo.zip'],
[u'http://localhost/bar', u'bar.zip'],
],
'dimensions': {
u'OS': u'Windows-3.1.1',
u'hostname': u'localhost'
},
'env': {
u'foo': u'bar',
u'joe': u'2'
},
'execution_timeout_secs':
30,
'grace_period_secs':
30,
'idempotent':
False,
'io_timeout_secs':
None,
}
props.update(properties or {})
now = utils.utcnow()
args = {
'created_ts': now,
'name': 'Request name',
'priority': 50,
'properties': task_request.TaskProperties(**props),
'expiration_ts': now + datetime.timedelta(seconds=30),
'tags': [u'tag:1'],
'user': '******',
}
args.update(kwargs)
return task_request.TaskRequest(**args)
def _gen_request(properties=None, **kwargs):
"""Creates a TaskRequest."""
properties = properties or {}
packages = properties.pop('packages', [{
'package_name': 'rm',
'version': PINNED_PACKAGE_VERSION,
}])
props = {
'command': [u'command1', u'arg1'],
'packages': [task_request.CipdPackage(**p) for p in packages],
'dimensions': {
u'OS': u'Windows-3.1.1',
u'hostname': u'localhost',
u'pool': u'default',
},
'env': {
u'foo': u'bar',
u'joe': u'2'
},
'execution_timeout_secs': 30,
'grace_period_secs': 30,
'idempotent': False,
'io_timeout_secs': None,
}
props.update(properties)
now = utils.utcnow()
args = {
'created_ts': now,
'name': 'Request name',
'priority': 50,
'properties': task_request.TaskProperties(**props),
'expiration_ts': now + datetime.timedelta(seconds=30),
'tags': [u'tag:1'],
'user': '******',
}
args.update(kwargs)
return task_request.TaskRequest(**args)
def _gen_request_slice(**kwargs):
"""Creates a TaskRequest."""
now = utils.utcnow()
args = {
'created_ts':
now,
'manual_tags': [u'tag:1'],
'name':
'Request name',
'priority':
50,
'task_slices': [
task_request.TaskSlice(expiration_secs=60,
properties=_gen_properties()),
],
'user':
'******',
}
args.update(kwargs)
ret = task_request.TaskRequest(**args)
task_request.init_new_request(ret, True)
ret.key = task_request.new_request_key()
ret.put()
return ret
