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