def _index(self, req, tenant_safe=True): filter_whitelist = { 'status': 'mixed', 'name': 'mixed', } whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) if not filter_params: filter_params = None stacks = self.rpc_client.list_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, **params) count = None if req.params.get('with_count'): try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.rpc_client.count_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe) except AttributeError as exc: logger.warning("Old Engine Version: %s" % str(exc)) return stacks_view.collection(req, stacks=stacks, count=count, tenant_safe=tenant_safe)
def index(self, req, identity, resource_name=None): """ Lists summary information for all events """ whitelist = {"limit": "single", "marker": "single", "sort_dir": "single", "sort_keys": "multi"} filter_whitelist = { "resource_status": "mixed", "resource_action": "mixed", "resource_name": "mixed", "resource_type": "mixed", } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) key = rpc_api.PARAM_LIMIT if key in params: try: limit = param_utils.extract_int(key, params[key], allow_zero=True) except ValueError as e: raise exc.HTTPBadRequest(six.text_type(e)) params[key] = limit if resource_name is None: if not filter_params: filter_params = None else: filter_params["resource_name"] = resource_name events = self._event_list(req, identity, filters=filter_params, **params) if not events and resource_name is not None: msg = _("No events found for resource %s") % resource_name raise exc.HTTPNotFound(msg) return {"events": events}
def index(self, req, identity, resource_name=None): """ Lists summary information for all events """ whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', } filter_whitelist = { 'resource_status': 'mixed', 'resource_action': 'mixed', 'resource_name': 'mixed', 'resource_type': 'mixed', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) if not filter_params: filter_params = None if resource_name is None: events = self._event_list(req, identity, filters=filter_params, **params) else: res_match = lambda e: e[rpc_api.EVENT_RES_NAME] == resource_name events = self._event_list(req, identity, res_match, filters=filter_params, **params) if not events: msg = _('No events found for resource %s') % resource_name raise exc.HTTPNotFound(msg) return {'events': events}
def _index(self, req, tenant_safe=True): filter_whitelist = { 'status': 'mixed', 'name': 'mixed', 'action': 'mixed', 'tenant': 'mixed', 'username': '******', 'owner_id': 'mixed', } whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', 'show_deleted': 'single', 'show_nested': 'single', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) show_deleted = False if rpc_api.PARAM_SHOW_DELETED in params: params[rpc_api.PARAM_SHOW_DELETED] = param_utils.extract_bool( params[rpc_api.PARAM_SHOW_DELETED]) show_deleted = params[rpc_api.PARAM_SHOW_DELETED] show_nested = False if rpc_api.PARAM_SHOW_NESTED in params: params[rpc_api.PARAM_SHOW_NESTED] = param_utils.extract_bool( params[rpc_api.PARAM_SHOW_NESTED]) show_nested = params[rpc_api.PARAM_SHOW_NESTED] # get the with_count value, if invalid, raise ValueError with_count = False if req.params.get('with_count'): with_count = param_utils.extract_bool(req.params.get('with_count')) if not filter_params: filter_params = None stacks = self.rpc_client.list_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, **params) count = None if with_count: try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.rpc_client.count_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, show_deleted=show_deleted, show_nested=show_nested) except AttributeError as exc: LOG.warn(_LW("Old Engine Version: %s") % exc) return stacks_view.collection(req, stacks=stacks, count=count, tenant_safe=tenant_safe)
def index(self, req): """ Lists summary information for all stacks """ filter_whitelist = { 'status': 'mixed', 'name': 'mixed', } whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) stacks = self.engine.list_stacks(req.context, filters=filter_params, **params) count = None if req.params.get('with_count'): try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.engine.count_stacks(req.context, filters=filter_params) except AttributeError as exc: logger.warning("Old Engine Version: %s" % str(exc)) return stacks_view.collection(req, stacks=stacks, count=count)
def _index(self, req, tenant_safe=True): filter_whitelist = { 'status': 'mixed', 'name': 'mixed', 'action': 'mixed', 'tenant': 'mixed', 'username': '******', 'owner_id': 'mixed', } whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', 'show_deleted': 'single', 'show_nested': 'single', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) show_deleted = False if engine_api.PARAM_SHOW_DELETED in params: params[engine_api.PARAM_SHOW_DELETED] = param_utils.extract_bool( params[engine_api.PARAM_SHOW_DELETED]) show_deleted = params[engine_api.PARAM_SHOW_DELETED] show_nested = False if engine_api.PARAM_SHOW_NESTED in params: params[engine_api.PARAM_SHOW_NESTED] = param_utils.extract_bool( params[engine_api.PARAM_SHOW_NESTED]) show_nested = params[engine_api.PARAM_SHOW_NESTED] # get the with_count value, if invalid, raise ValueError with_count = False if req.params.get('with_count'): with_count = param_utils.extract_bool( req.params.get('with_count')) if not filter_params: filter_params = None stacks = self.rpc_client.list_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, **params) count = None if with_count: try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.rpc_client.count_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, show_deleted=show_deleted, show_nested=show_nested) except AttributeError as exc: LOG.warn(_LW("Old Engine Version: %s") % exc) return stacks_view.collection(req, stacks=stacks, count=count, tenant_safe=tenant_safe)
def index(self, req, identity, resource_name=None): """ Lists summary information for all events """ whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', } filter_whitelist = { 'resource_status': 'mixed', 'resource_action': 'mixed', 'resource_name': 'mixed', 'resource_type': 'mixed', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) if not filter_params: filter_params = None key = rpc_api.PARAM_LIMIT if key in params: try: limit = param_utils.extract_int(key, params[key], allow_zero=True) except ValueError as e: raise exc.HTTPBadRequest(six.text_type(e)) params[key] = limit if resource_name is None: events = self._event_list(req, identity, filters=filter_params, **params) else: res_match = lambda e: e[rpc_api.EVENT_RES_NAME] == resource_name events = self._event_list(req, identity, res_match, filters=filter_params, **params) if not events: msg = _('No events found for resource %s') % resource_name raise exc.HTTPNotFound(msg) return {'events': events}
def _param_show_nested(self, req): whitelist = {'show_nested': 'single'} params = util.get_allowed_params(req.params, whitelist) p_name = 'show_nested' if p_name in params: return self._extract_bool_param(p_name, params[p_name])
def validate_template(self, req, body): """ Implements the ValidateTemplate API action Validates the specified template """ data = InstantiationData(body) whitelist = {'show_nested': 'single'} params = util.get_allowed_params(req.params, whitelist) show_nested = False p_name = rpc_api.PARAM_SHOW_NESTED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_nested = params[p_name] result = self.rpc_client.validate_template(req.context, data.template(), data.environment(), files=data.files(), show_nested=show_nested) if 'Error' in result: raise exc.HTTPBadRequest(result['Error']) return result
def _param_show_nested(self, req): param_types = {'show_nested': util.PARAM_TYPE_SINGLE} params = util.get_allowed_params(req.params, param_types) p_name = 'show_nested' if p_name in params: return self._extract_bool_param(p_name, params[p_name])
def index(self, req, identity): """Lists information for all resources.""" whitelist = { 'type': 'mixed', 'status': 'mixed', 'name': 'mixed', 'action': 'mixed', 'id': 'mixed', 'physical_resource_id': 'mixed' } nested_depth = self._extract_to_param(req, rpc_api.PARAM_NESTED_DEPTH, param_utils.extract_int, default=0) with_detail = self._extract_to_param(req, rpc_api.PARAM_WITH_DETAIL, param_utils.extract_bool, default=False) params = util.get_allowed_params(req.params, whitelist) res_list = self.rpc_client.list_stack_resources(req.context, identity, nested_depth, with_detail, filters=params) return {'resources': [format_resource(req, res) for res in res_list]}
def _index(self, req, tenant_safe=True): whitelist = {'limit': 'single', 'marker': 'single'} params = util.get_allowed_params(req.params, whitelist) scs = self.rpc_client.list_software_configs(req.context, tenant_safe=tenant_safe, **params) return {'software_configs': scs}
def validate_template(self, req, body): """Implements the ValidateTemplate API action. Validates the specified template. """ data = InstantiationData(body) whitelist = {'show_nested': 'single'} params = util.get_allowed_params(req.params, whitelist) show_nested = False p_name = rpc_api.PARAM_SHOW_NESTED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_nested = params[p_name] result = self.rpc_client.validate_template(req.context, data.template(), data.environment(), files=data.files(), show_nested=show_nested) if 'Error' in result: raise exc.HTTPBadRequest(result['Error']) return result
def data_list_from_db(req): filter_whitelist = { 'create_time_first': 'single', 'create_time_end': 'single', 'app_name': 'single', 'stack_apps_style': 'single', 'stack_status': 'single' } whitelist = { 'limit': 'single', 'offset': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) return db_api.data_get_all_for_g_cloud(req.context, filters=validate_and_translate(filter_params), **params)
def test_handles_mixed_value_param_with_multiple_entries(self): self.whitelist = {'foo': 'mixed'} self.params.add('foo', 'foo value 2') result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual(2, len(result['foo'])) self.assertIn('foo value', result['foo']) self.assertIn('foo value 2', result['foo'])
def test_handles_mixed_value_param_with_multiple_entries(self): self.param_types = {'foo': util.PARAM_TYPE_MIXED} self.params.add('foo', 'foo value 2') result = util.get_allowed_params(self.params, self.param_types) self.assertEqual(2, len(result['foo'])) self.assertIn('foo value', result['foo']) self.assertIn('foo value 2', result['foo'])
def test_handles_multiple_value_params(self): self.whitelist = {'foo': util.PARAM_TYPE_MULTI} self.params.add('foo', 'foo value 2') result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual(2, len(result['foo'])) self.assertIn('foo value', result['foo']) self.assertIn('foo value 2', result['foo'])
def test_handles_mixed_value_param_with_multiple_entries(self): self.whitelist = {'foo': util.PARAM_TYPE_MIXED} self.params.add('foo', 'foo value 2') result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual(2, len(result['foo'])) self.assertIn('foo value', result['foo']) self.assertIn('foo value 2', result['foo'])
def index(self, req): """List software deployments.""" whitelist = { 'server_id': 'single', } params = util.get_allowed_params(req.params, whitelist) sds = self.rpc_client.list_software_deployments(req.context, **params) return {'software_deployments': sds}
def test_handles_multiple_value_params(self): self.whitelist = {'foo': 'multi'} self.params.add('foo', 'foo value 2') result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual(2, len(result['foo'])) self.assertIn('foo value', result['foo']) self.assertIn('foo value 2', result['foo'])
def index(self, req): """List software deployments.""" whitelist = { 'server_id': util.PARAM_TYPE_SINGLE, } params = util.get_allowed_params(req.params, whitelist) sds = self.rpc_client.list_software_deployments(req.context, **params) return {'software_deployments': sds}
def index(self, req, identity, resource_name=None): """ Lists summary information for all events """ whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', } filter_whitelist = { 'resource_status': 'mixed', 'resource_action': 'mixed', 'resource_name': 'mixed', 'resource_type': 'mixed', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) if not filter_params: filter_params = None key = rpc_api.PARAM_LIMIT if key in params: try: limit = param_utils.extract_int(key, params[key], allow_zero=True) except ValueError as e: raise exc.HTTPBadRequest(six.text_type(e)) params[key] = limit if resource_name is None: events = self._event_list(req, identity, filters=filter_params, **params) else: def res_match(e): return e[rpc_api.EVENT_RES_NAME] == resource_name events = self._event_list(req, identity, res_match, filters=filter_params, **params) if not events: msg = _('No events found for resource %s') % resource_name raise exc.HTTPNotFound(msg) return {'events': events}
def show(self, req, identity, resource_name): """Gets detailed information for a resource.""" whitelist = {'with_attr': 'multi'} params = util.get_allowed_params(req.params, whitelist) res = self.rpc_client.describe_stack_resource(req.context, identity, resource_name, **params) return {'resource': format_resource(req, res)}
def index(self, req): filter_whitelist = { 'name': 'single', 'type': 'single', 'user': '******', } whitelist = { 'limit': 'single', 'offset': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) templates = db_api.template_get_all(req.context, filters=translate_filters(filter_params), **params) return get_index_template_response_info(templates)
def index(self, req, identity, resource_name=None): """Lists summary information for all events.""" param_types = { 'limit': util.PARAM_TYPE_SINGLE, 'marker': util.PARAM_TYPE_SINGLE, 'sort_dir': util.PARAM_TYPE_SINGLE, 'sort_keys': util.PARAM_TYPE_MULTI, 'nested_depth': util.PARAM_TYPE_SINGLE, } filter_param_types = { 'resource_status': util.PARAM_TYPE_MIXED, 'resource_action': util.PARAM_TYPE_MIXED, 'resource_name': util.PARAM_TYPE_MIXED, 'resource_type': util.PARAM_TYPE_MIXED, } params = util.get_allowed_params(req.params, param_types) filter_params = util.get_allowed_params(req.params, filter_param_types) int_params = (rpc_api.PARAM_LIMIT, rpc_api.PARAM_NESTED_DEPTH) try: for key in int_params: if key in params: params[key] = param_utils.extract_int(key, params[key], allow_zero=True) except ValueError as e: raise exc.HTTPBadRequest(str(e)) if resource_name is None: if not filter_params: filter_params = None else: filter_params['resource_name'] = resource_name events = self._event_list(req, identity, filters=filter_params, **params) if not events and resource_name is not None: msg = _('No events found for resource %s') % resource_name raise exc.HTTPNotFound(msg) return {'events': events}
def show(self, req, identity, resource_name): """Gets detailed information for a resource.""" whitelist = {"with_attr": util.PARAM_TYPE_MULTI} params = util.get_allowed_params(req.params, whitelist) if "with_attr" not in params: params["with_attr"] = None res = self.rpc_client.describe_stack_resource(req.context, identity, resource_name, **params) return {"resource": format_resource(req, res)}
def _index(self, req, tenant_safe=True): whitelist = { 'limit': 'single', 'marker': 'single' } params = util.get_allowed_params(req.params, whitelist) scs = self.rpc_client.list_software_configs(req.context, tenant_safe=tenant_safe, **params) return {'software_configs': scs}
def show(self, req, identity, resource_name): """ Gets detailed information for a resource """ whitelist = {"with_attr": "multi"} params = util.get_allowed_params(req.params, whitelist) res = self.rpc_client.describe_stack_resource(req.context, identity, resource_name, **params) return {"resource": format_resource(req, res)}
def index(self, req): """ List software deployments. """ whitelist = { 'server_id': 'single', } params = util.get_allowed_params(req.params, whitelist) sds = self.engine.list_software_deployments(req.context, **params) return {'software_deployments': sds}
def show(self, req, identity, resource_name): """Gets detailed information for a resource.""" whitelist = {'with_attr': util.PARAM_TYPE_MULTI} params = util.get_allowed_params(req.params, whitelist) if 'with_attr' not in params: params['with_attr'] = None res = self.rpc_client.describe_stack_resource(req.context, identity, resource_name, **params) return {'resource': format_resource(req, res)}
def index(self, req, identity, resource_name=None): """Lists summary information for all events.""" whitelist = { 'limit': util.PARAM_TYPE_SINGLE, 'marker': util.PARAM_TYPE_SINGLE, 'sort_dir': util.PARAM_TYPE_SINGLE, 'sort_keys': util.PARAM_TYPE_MULTI, 'nested_depth': util.PARAM_TYPE_SINGLE, } filter_whitelist = { 'resource_status': util.PARAM_TYPE_MIXED, 'resource_action': util.PARAM_TYPE_MIXED, 'resource_name': util.PARAM_TYPE_MIXED, 'resource_type': util.PARAM_TYPE_MIXED, } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) int_params = (rpc_api.PARAM_LIMIT, rpc_api.PARAM_NESTED_DEPTH) try: for key in int_params: if key in params: params[key] = param_utils.extract_int( key, params[key], allow_zero=True) except ValueError as e: raise exc.HTTPBadRequest(six.text_type(e)) if resource_name is None: if not filter_params: filter_params = None else: filter_params['resource_name'] = resource_name events = self._event_list( req, identity, filters=filter_params, **params) if not events and resource_name is not None: msg = _('No events found for resource %s') % resource_name raise exc.HTTPNotFound(msg) return {'events': events}
def _index(self, req, tenant_safe=True): filter_whitelist = {"status": "mixed", "name": "mixed"} whitelist = {"limit": "single", "marker": "single", "sort_dir": "single", "sort_keys": "multi"} params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) if not filter_params: filter_params = None stacks = self.rpc_client.list_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, **params) count = None if req.params.get("with_count"): try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.rpc_client.count_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe) except AttributeError as exc: logger.warning(_("Old Engine Version: %s") % exc) return stacks_view.collection(req, stacks=stacks, count=count, tenant_safe=tenant_safe)
def _index(self, req, use_admin_cnxt=False): param_types = { 'limit': util.PARAM_TYPE_SINGLE, 'marker': util.PARAM_TYPE_SINGLE } params = util.get_allowed_params(req.params, param_types) if use_admin_cnxt: cnxt = context.get_admin_context() else: cnxt = req.context scs = self.rpc_client.list_software_configs(cnxt, **params) return {'software_configs': scs}
def _index(self, req, tenant_safe=True): filter_whitelist = {"status": "mixed", "name": "mixed", "action": "mixed"} whitelist = { "limit": "single", "marker": "single", "sort_dir": "single", "sort_keys": "multi", "show_deleted": "single", } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) show_deleted = False if engine_api.PARAM_SHOW_DELETED in params: params[engine_api.PARAM_SHOW_DELETED] = param_utils.extract_bool(params[engine_api.PARAM_SHOW_DELETED]) show_deleted = params[engine_api.PARAM_SHOW_DELETED] # get the with_count value, if invalid, raise ValueError with_count = False if req.params.get("with_count"): with_count = param_utils.extract_bool(req.params.get("with_count")) if not filter_params: filter_params = None stacks = self.rpc_client.list_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, **params) count = None if with_count: try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.rpc_client.count_stacks( req.context, filters=filter_params, tenant_safe=tenant_safe, show_deleted=show_deleted ) except AttributeError as exc: LOG.warning(_("Old Engine Version: %s") % exc) return stacks_view.collection(req, stacks=stacks, count=count, tenant_safe=tenant_safe)
def _index(self, req, use_admin_cnxt=False): whitelist = { 'limit': util.PARAM_TYPE_SINGLE, 'marker': util.PARAM_TYPE_SINGLE } params = util.get_allowed_params(req.params, whitelist) if use_admin_cnxt: cnxt = context.get_admin_context() else: cnxt = req.context scs = self.rpc_client.list_software_configs(cnxt, **params) return {'software_configs': scs}
def validate_template(self, req, body): """Implements the ValidateTemplate API action. Validates the specified template. """ data = InstantiationData(body) param_types = { 'show_nested': util.PARAM_TYPE_SINGLE, 'ignore_errors': util.PARAM_TYPE_SINGLE } params = util.get_allowed_params(req.params, param_types) show_nested = False p_name = rpc_api.PARAM_SHOW_NESTED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_nested = params[p_name] if rpc_api.PARAM_IGNORE_ERRORS in params: ignorable_errors = params[rpc_api.PARAM_IGNORE_ERRORS].split(',') else: ignorable_errors = None result = self.rpc_client.validate_template( req.context, data.template(), data.environment(), files=data.files(), environment_files=data.environment_files(), files_container=data.files_container(), show_nested=show_nested, ignorable_errors=ignorable_errors) if 'Error' in result: raise exc.HTTPBadRequest(result['Error']) return result
def index(self, req, identity): """Lists information for all resources.""" whitelist = { 'type': 'mixed', 'status': 'mixed', 'name': 'mixed', 'action': 'mixed', 'id': 'mixed', 'physical_resource_id': 'mixed' } invalid_keys = (set(req.params.keys()) - set( list(whitelist) + [rpc_api.PARAM_NESTED_DEPTH, rpc_api.PARAM_WITH_DETAIL])) if invalid_keys: raise exc.HTTPBadRequest( _('Invalid filter parameters %s') % six.text_type(list(invalid_keys))) nested_depth = self._extract_to_param(req, rpc_api.PARAM_NESTED_DEPTH, param_utils.extract_int, default=0) with_detail = self._extract_to_param(req, rpc_api.PARAM_WITH_DETAIL, param_utils.extract_bool, default=False) params = util.get_allowed_params(req.params, whitelist) res_list = self.rpc_client.list_stack_resources(req.context, identity, nested_depth, with_detail, filters=params) return {'resources': [format_resource(req, res) for res in res_list]}
def index(self, req, identity): """Lists information for all resources.""" whitelist = { 'type': 'mixed', 'status': 'mixed', 'name': 'mixed', 'action': 'mixed', 'id': 'mixed', 'physical_resource_id': 'mixed' } invalid_keys = (set(req.params.keys()) - set(list(whitelist) + [rpc_api.PARAM_NESTED_DEPTH, rpc_api.PARAM_WITH_DETAIL])) if invalid_keys: raise exc.HTTPBadRequest(_('Invalid filter parameters %s') % six.text_type(list(invalid_keys))) nested_depth = self._extract_to_param(req, rpc_api.PARAM_NESTED_DEPTH, param_utils.extract_int, default=0) with_detail = self._extract_to_param(req, rpc_api.PARAM_WITH_DETAIL, param_utils.extract_bool, default=False) params = util.get_allowed_params(req.params, whitelist) res_list = self.rpc_client.list_stack_resources(req.context, identity, nested_depth, with_detail, filters=params) return {'resources': [format_resource(req, res) for res in res_list]}
def validate_template(self, req, body): """Implements the ValidateTemplate API action. Validates the specified template. """ data = InstantiationData(body) whitelist = {'show_nested': util.PARAM_TYPE_SINGLE, 'ignore_errors': util.PARAM_TYPE_SINGLE} params = util.get_allowed_params(req.params, whitelist) show_nested = False p_name = rpc_api.PARAM_SHOW_NESTED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_nested = params[p_name] if rpc_api.PARAM_IGNORE_ERRORS in params: ignorable_errors = params[rpc_api.PARAM_IGNORE_ERRORS].split(',') else: ignorable_errors = None result = self.rpc_client.validate_template( req.context, data.template(), data.environment(), files=data.files(), environment_files=data.environment_files(), files_container=data.files_container(), show_nested=show_nested, ignorable_errors=ignorable_errors) if 'Error' in result: raise exc.HTTPBadRequest(result['Error']) return result
def _index(self, req, use_admin_cnxt=False): filter_whitelist = { # usage of keys in this list are not encouraged, please use # rpc_api.STACK_KEYS instead 'id': util.PARAM_TYPE_MIXED, 'status': util.PARAM_TYPE_MIXED, 'name': util.PARAM_TYPE_MIXED, 'action': util.PARAM_TYPE_MIXED, 'tenant': util.PARAM_TYPE_MIXED, 'username': util.PARAM_TYPE_MIXED, 'owner_id': util.PARAM_TYPE_MIXED, } whitelist = { 'limit': util.PARAM_TYPE_SINGLE, 'marker': util.PARAM_TYPE_SINGLE, 'sort_dir': util.PARAM_TYPE_SINGLE, 'sort_keys': util.PARAM_TYPE_MULTI, 'show_deleted': util.PARAM_TYPE_SINGLE, 'show_nested': util.PARAM_TYPE_SINGLE, 'show_hidden': util.PARAM_TYPE_SINGLE, 'tags': util.PARAM_TYPE_SINGLE, 'tags_any': util.PARAM_TYPE_SINGLE, 'not_tags': util.PARAM_TYPE_SINGLE, 'not_tags_any': util.PARAM_TYPE_SINGLE, } params = util.get_allowed_params(req.params, whitelist) stack_keys = dict.fromkeys(rpc_api.STACK_KEYS, util.PARAM_TYPE_MIXED) unsupported = ( rpc_api.STACK_ID, # not user visible rpc_api.STACK_CAPABILITIES, # not supported rpc_api.STACK_CREATION_TIME, # don't support timestamp rpc_api.STACK_DELETION_TIME, # don't support timestamp rpc_api.STACK_DESCRIPTION, # not supported rpc_api.STACK_NOTIFICATION_TOPICS, # not supported rpc_api.STACK_OUTPUTS, # not in database rpc_api.STACK_PARAMETERS, # not in this table rpc_api.STACK_TAGS, # tags query following a specific guideline rpc_api.STACK_TMPL_DESCRIPTION, # not supported rpc_api.STACK_UPDATED_TIME, # don't support timestamp ) for key in unsupported: stack_keys.pop(key) # downward compatibility stack_keys.update(filter_whitelist) filter_params = util.get_allowed_params(req.params, stack_keys) show_deleted = False p_name = rpc_api.PARAM_SHOW_DELETED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_deleted = params[p_name] show_nested = False p_name = rpc_api.PARAM_SHOW_NESTED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_nested = params[p_name] key = rpc_api.PARAM_LIMIT if key in params: params[key] = self._extract_int_param(key, params[key]) show_hidden = False p_name = rpc_api.PARAM_SHOW_HIDDEN if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_hidden = params[p_name] tags = None if rpc_api.PARAM_TAGS in params: params[rpc_api.PARAM_TAGS] = self._extract_tags_param( params[rpc_api.PARAM_TAGS]) tags = params[rpc_api.PARAM_TAGS] tags_any = None if rpc_api.PARAM_TAGS_ANY in params: params[rpc_api.PARAM_TAGS_ANY] = self._extract_tags_param( params[rpc_api.PARAM_TAGS_ANY]) tags_any = params[rpc_api.PARAM_TAGS_ANY] not_tags = None if rpc_api.PARAM_NOT_TAGS in params: params[rpc_api.PARAM_NOT_TAGS] = self._extract_tags_param( params[rpc_api.PARAM_NOT_TAGS]) not_tags = params[rpc_api.PARAM_NOT_TAGS] not_tags_any = None if rpc_api.PARAM_NOT_TAGS_ANY in params: params[rpc_api.PARAM_NOT_TAGS_ANY] = self._extract_tags_param( params[rpc_api.PARAM_NOT_TAGS_ANY]) not_tags_any = params[rpc_api.PARAM_NOT_TAGS_ANY] # get the with_count value, if invalid, raise ValueError with_count = False if req.params.get('with_count'): with_count = self._extract_bool_param('with_count', req.params.get('with_count')) if not filter_params: filter_params = None if use_admin_cnxt: cnxt = context.get_admin_context() else: cnxt = req.context stacks = self.rpc_client.list_stacks(cnxt, filters=filter_params, **params) count = None if with_count: try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.rpc_client.count_stacks(cnxt, filters=filter_params, show_deleted=show_deleted, show_nested=show_nested, show_hidden=show_hidden, tags=tags, tags_any=tags_any, not_tags=not_tags, not_tags_any=not_tags_any) except AttributeError as ex: LOG.warning("Old Engine Version: %s", ex) return stacks_view.collection(req, stacks=stacks, count=count, include_project=cnxt.is_admin)
def test_returns_only_whitelisted_params(self): self.params.add('bar', 'bar value') result = util.get_allowed_params(self.params, self.whitelist) self.assertIn('foo', result) self.assertNotIn('bar', result)
def test_handles_single_value_params(self): result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual('foo value', result['foo'])
def test_returns_empty_dict(self): self.whitelist = {} result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual({}, result)
def test_only_adds_whitelisted_params_if_param_exists(self): self.whitelist = {'foo': 'single'} self.params.clear() result = util.get_allowed_params(self.params, self.whitelist) self.assertNotIn('foo', result)
def test_handles_mixed_value_param_with_single_entry(self): self.param_types = {'foo': util.PARAM_TYPE_MIXED} result = util.get_allowed_params(self.params, self.param_types) self.assertEqual('foo value', result['foo'])
def test_ignores_bogus_whitelist_items(self): self.whitelist = {'foo': 'blah'} result = util.get_allowed_params(self.params, self.whitelist) self.assertNotIn('foo', result)
def _index(self, req, tenant_safe=True): filter_whitelist = { # usage of keys in this list are not encouraged, please use # rpc_api.STACK_KEYS instead 'id': 'mixed', 'status': 'mixed', 'name': 'mixed', 'action': 'mixed', 'tenant': 'mixed', 'username': '******', 'owner_id': 'mixed', } whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', 'show_deleted': 'single', 'show_nested': 'single', 'show_hidden': 'single', 'tags': 'single', 'tags_any': 'single', 'not_tags': 'single', 'not_tags_any': 'single', } params = util.get_allowed_params(req.params, whitelist) stack_keys = dict.fromkeys(rpc_api.STACK_KEYS, 'mixed') unsupported = ( rpc_api.STACK_ID, # not user visible rpc_api.STACK_CAPABILITIES, # not supported rpc_api.STACK_CREATION_TIME, # don't support timestamp rpc_api.STACK_DELETION_TIME, # don't support timestamp rpc_api.STACK_DESCRIPTION, # not supported rpc_api.STACK_NOTIFICATION_TOPICS, # not supported rpc_api.STACK_OUTPUTS, # not in database rpc_api.STACK_PARAMETERS, # not in this table rpc_api.STACK_TAGS, # tags query following a specific guideline rpc_api.STACK_TMPL_DESCRIPTION, # not supported rpc_api.STACK_UPDATED_TIME, # don't support timestamp ) for key in unsupported: stack_keys.pop(key) # downward compatibility stack_keys.update(filter_whitelist) filter_params = util.get_allowed_params(req.params, stack_keys) show_deleted = False p_name = rpc_api.PARAM_SHOW_DELETED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_deleted = params[p_name] show_nested = False p_name = rpc_api.PARAM_SHOW_NESTED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_nested = params[p_name] key = rpc_api.PARAM_LIMIT if key in params: params[key] = self._extract_int_param(key, params[key]) show_hidden = False p_name = rpc_api.PARAM_SHOW_HIDDEN if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_hidden = params[p_name] tags = None if rpc_api.PARAM_TAGS in params: params[rpc_api.PARAM_TAGS] = self._extract_tags_param( params[rpc_api.PARAM_TAGS]) tags = params[rpc_api.PARAM_TAGS] tags_any = None if rpc_api.PARAM_TAGS_ANY in params: params[rpc_api.PARAM_TAGS_ANY] = self._extract_tags_param( params[rpc_api.PARAM_TAGS_ANY]) tags_any = params[rpc_api.PARAM_TAGS_ANY] not_tags = None if rpc_api.PARAM_NOT_TAGS in params: params[rpc_api.PARAM_NOT_TAGS] = self._extract_tags_param( params[rpc_api.PARAM_NOT_TAGS]) not_tags = params[rpc_api.PARAM_NOT_TAGS] not_tags_any = None if rpc_api.PARAM_NOT_TAGS_ANY in params: params[rpc_api.PARAM_NOT_TAGS_ANY] = self._extract_tags_param( params[rpc_api.PARAM_NOT_TAGS_ANY]) not_tags_any = params[rpc_api.PARAM_NOT_TAGS_ANY] # get the with_count value, if invalid, raise ValueError with_count = False if req.params.get('with_count'): with_count = self._extract_bool_param( 'with_count', req.params.get('with_count')) if not filter_params: filter_params = None stacks = self.rpc_client.list_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, **params) count = None if with_count: try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.rpc_client.count_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, show_deleted=show_deleted, show_nested=show_nested, show_hidden=show_hidden, tags=tags, tags_any=tags_any, not_tags=not_tags, not_tags_any=not_tags_any) except AttributeError as ex: LOG.warn(_LW("Old Engine Version: %s"), ex) return stacks_view.collection(req, stacks=stacks, count=count, tenant_safe=tenant_safe)
def test_only_adds_whitelisted_params_if_param_exists(self): self.whitelist = {'foo': util.PARAM_TYPE_SINGLE} self.params.clear() result = util.get_allowed_params(self.params, self.whitelist) self.assertNotIn('foo', result)
def test_handles_mixed_value_param_with_single_entry(self): self.whitelist = {'foo': 'mixed'} result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual('foo value', result['foo'])
def test_handles_mixed_value_param_with_single_entry(self): self.whitelist = {'foo': util.PARAM_TYPE_MIXED} result = util.get_allowed_params(self.params, self.whitelist) self.assertEqual('foo value', result['foo'])
def _index(self, req, tenant_safe=True): filter_whitelist = { 'id': 'mixed', 'status': 'mixed', 'name': 'mixed', 'action': 'mixed', 'tenant': 'mixed', 'username': '******', 'owner_id': 'mixed', } whitelist = { 'limit': 'single', 'marker': 'single', 'sort_dir': 'single', 'sort_keys': 'multi', 'show_deleted': 'single', 'show_nested': 'single', 'show_hidden': 'single', 'tags': 'single', 'tags_any': 'single', 'not_tags': 'single', 'not_tags_any': 'single', } params = util.get_allowed_params(req.params, whitelist) filter_params = util.get_allowed_params(req.params, filter_whitelist) show_deleted = False p_name = rpc_api.PARAM_SHOW_DELETED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_deleted = params[p_name] show_nested = False p_name = rpc_api.PARAM_SHOW_NESTED if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_nested = params[p_name] key = rpc_api.PARAM_LIMIT if key in params: params[key] = self._extract_int_param(key, params[key]) show_hidden = False p_name = rpc_api.PARAM_SHOW_HIDDEN if p_name in params: params[p_name] = self._extract_bool_param(p_name, params[p_name]) show_hidden = params[p_name] tags = None if rpc_api.PARAM_TAGS in params: params[rpc_api.PARAM_TAGS] = self._extract_tags_param( params[rpc_api.PARAM_TAGS]) tags = params[rpc_api.PARAM_TAGS] tags_any = None if rpc_api.PARAM_TAGS_ANY in params: params[rpc_api.PARAM_TAGS_ANY] = self._extract_tags_param( params[rpc_api.PARAM_TAGS_ANY]) tags_any = params[rpc_api.PARAM_TAGS_ANY] not_tags = None if rpc_api.PARAM_NOT_TAGS in params: params[rpc_api.PARAM_NOT_TAGS] = self._extract_tags_param( params[rpc_api.PARAM_NOT_TAGS]) not_tags = params[rpc_api.PARAM_NOT_TAGS] not_tags_any = None if rpc_api.PARAM_NOT_TAGS_ANY in params: params[rpc_api.PARAM_NOT_TAGS_ANY] = self._extract_tags_param( params[rpc_api.PARAM_NOT_TAGS_ANY]) not_tags_any = params[rpc_api.PARAM_NOT_TAGS_ANY] # get the with_count value, if invalid, raise ValueError with_count = False if req.params.get('with_count'): with_count = self._extract_bool_param( 'with_count', req.params.get('with_count')) if not filter_params: filter_params = None stacks = self.rpc_client.list_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, **params) count = None if with_count: try: # Check if engine has been updated to a version with # support to count_stacks before trying to use it. count = self.rpc_client.count_stacks(req.context, filters=filter_params, tenant_safe=tenant_safe, show_deleted=show_deleted, show_nested=show_nested, show_hidden=show_hidden, tags=tags, tags_any=tags_any, not_tags=not_tags, not_tags_any=not_tags_any) except AttributeError as ex: LOG.warn(_LW("Old Engine Version: %s"), ex) return stacks_view.collection(req, stacks=stacks, count=count, tenant_safe=tenant_safe)