def find(self, keyword):
"""find antiddos by keyword (UUID or IP)"""
if not IP_PATTERN.match(keyword):
try:
# try keyword as UUID
return self.get_antiddos(keyword)
except exceptions.ClientException as e:
pass
else:
# try keyword as IP
results = self.list(ip=keyword)
matched_number = len(results)
if matched_number > 1:
exactly_matched = [
obj for obj in results
if obj.floating_ip_address == keyword
]
if len(exactly_matched) == 1:
return exactly_matched[0]
raise execs.NotUniqueMatch
elif matched_number == 1:
return results[0]
message = _("AntiDDos with ID or IP '%s' not exists.") % keyword
raise exceptions.NotFound(message)
def test_delete_resource_provider_inventory_no_rp(self):
self.placement_fixture.mock_delete.side_effect = ks_exc.NotFound(
details='No resource provider with uuid')
self.assertRaises(
n_exc.PlacementResourceProviderNotFound,
self.placement_api_client.delete_resource_provider_inventory,
RESOURCE_PROVIDER_UUID, RESOURCE_CLASS_NAME)
def test_get_inventory_no_inventory(self):
_exception = ks_exc.NotFound()
_exception.details = _("No inventory of class")
self.placement_fixture.mock_get.side_effect = _exception
self.assertRaises(n_exc.PlacementInventoryNotFound,
self.placement_api_client.get_inventory,
RESOURCE_PROVIDER_UUID, RESOURCE_CLASS_NAME)
def find(self, **kwargs):
"""Find a single item with attributes matching ``**kwargs``."""
url = self.build_url(dict_args_in_out=kwargs)
query = self._build_query(kwargs)
url_query = '%(url)s%(query)s' % {
'url': url,
'query': query
}
elements = self._list(
url_query,
self.collection_key)
if self.client.include_metadata:
base_response = elements
elements = elements.data
base_response.data = elements[0]
if not elements:
msg = _("No %(name)s matching %(kwargs)s.") % {
'name': self.resource_class.__name__, 'kwargs': kwargs}
raise ksa_exceptions.NotFound(404, msg)
elif len(elements) > 1:
raise ksc_exceptions.NoUniqueMatch
else:
return (base_response if self.client.include_metadata
else elements[0])
def test_get_inventory_no_resource_provider(self):
_exception = ks_exc.NotFound()
_exception.details = "No resource provider with uuid"
self.placement_fixture.mock_get.side_effect = _exception
self.assertRaises(n_exc.PlacementResourceProviderNotFound,
self.placement_api_client.get_inventory,
RESOURCE_PROVIDER_UUID, RESOURCE_CLASS_NAME)
def test_update_resource_provider_inventories_no_rp(self):
self.placement_fixture.mock_put.side_effect = ks_exc.NotFound()
self.assertRaises(
n_exc.PlacementResourceProviderNotFound,
self.placement_api_client.update_resource_provider_inventories,
RESOURCE_PROVIDER_UUID, INVENTORY, RESOURCE_PROVIDER_GENERATION)
def test_get_inventory_not_found(self):
_exception = ks_exc.NotFound()
_exception.details = "Any other exception explanation"
self.placement_fixture.mock_get.side_effect = _exception
self.assertRaises(ks_exc.NotFound,
self.placement_api_client.get_inventory,
RESOURCE_PROVIDER_UUID, RESOURCE_CLASS_NAME)
def test_get_inventory_not_found(self):
_exception = ks_exc.NotFound()
_exception.details = "Any other exception explanation"
_exception.response = mock.Mock(text="Some error response body")
self.placement_fixture.mock_get.side_effect = _exception
self.assertRaises(n_exc.PlacementClientError,
self.placement_api_client.get_inventory,
RESOURCE_PROVIDER_UUID, RESOURCE_CLASS_NAME)
def find(self, name=None):
if name == '9999':
# NOTE(morganfainberg): special case that raises NoUniqueMatch.
raise ksc_exceptions.NoUniqueMatch()
for resource_id, resource in self.resources.items():
if resource['name'] == str(name):
return resource
raise ksa_exceptions.NotFound(name)
def test_get_not_found(self):
self.res.get.side_effect = ksa_exc.NotFound(message="test",
http_status=404)
self.assertRaisesRegexp(
exceptions.ResourceNotFound,
"No %s found for %s" % (RetrieveableResource.__name__, self.res),
self.sot._get, RetrieveableResource, self.res)
def test_update_resource_provider_traits_no_rp(self):
traits = [TRAIT_NAME]
self.placement_fixture.mock_put.side_effect = ks_exc.NotFound()
self.assertRaises(
n_exc.PlacementResourceProviderNotFound,
self.placement_api_client.update_resource_provider_traits,
RESOURCE_PROVIDER_UUID,
traits,
resource_provider_generation=0)
def test_update_resource_provider_inventory_not_found(self):
# Test the resource provider not found case
self.placement_fixture.mock_put.side_effect = ks_exc.NotFound(
details="No resource provider with uuid")
self.assertRaises(
n_exc.PlacementResourceNotFound,
self.placement_api_client.update_resource_provider_inventory,
RESOURCE_PROVIDER_UUID, INVENTORY, RESOURCE_CLASS_NAME,
RESOURCE_PROVIDER_GENERATION)
def test_down_endpoint(self, get):
"""Test failure when endpoint is down.
Replicate in devstack: start devstack with placement
engine, disable placement engine apache config.
"""
get.side_effect = ks_exc.NotFound()
res = self.cmd._check_placement()
self.assertEqual(status.UpgradeCheckCode.FAILURE, res.code)
self.assertIn('Placement API does not seem to be running', res.details)
def test_delete_ResourceNotFound(self):
self.res.delete.side_effect = ksa_exc.NotFound(message="test",
http_status=404)
self.assertRaisesRegexp(exceptions.ResourceNotFound,
"No %s found for %s" %
(DeleteableResource.__name__, self.res),
self.sot._delete,
DeleteableResource,
self.res,
ignore_missing=False)
def get_rule_id_from_name(client, parsed_args):
results = client.list_policy_rules(parsed_args.policy_name)['results']
rule_id = None
for result in results:
if result.get('name') == parsed_args.rule_id:
if rule_id is None:
rule_id = result.get('id')
else:
raise exceptions.Conflict(
"[Multiple rules with same name: %s]" %
parsed_args.rule_id)
if rule_id is None:
raise exceptions.NotFound("[No rule found with name: %s]" %
parsed_args.rule_id)
return rule_id
def test_handle_delete_not_found(self):
stack_name = 'stackuser_testdel-notfound'
project_id = 'aprojectdel2'
user_id = 'auserdel2'
rsrc = self._user_create(stack_name=stack_name,
project_id=project_id,
user_id=user_id)
self.fc.delete_stack_domain_user.side_effect = kc_exceptions.NotFound()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
scheduler.TaskRunner(rsrc.delete)()
self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state)
self.fc.delete_stack_domain_user.assert_called_once_with(
user_id=user_id, project_id=project_id)
def find(self, **kwargs):
"""Find a single item with attributes matching ``**kwargs``.
This isn't very efficient: it loads the entire list then filters on
the Python side.
"""
rl = self.findall(**kwargs)
num = len(rl)
if num == 0:
msg = _("No %(name)s matching %(kwargs)s.") % {
'name': self.resource_class.__name__,
'kwargs': kwargs
}
raise ksa_exceptions.NotFound(404, msg)
elif num > 1:
raise ksc_exceptions.NoUniqueMatch
else:
return rl[0]
def find(self, **kwargs):
"""Find a single item with attributes matching ``**kwargs``.
This isn't very efficient: it loads the entire list then filters on
the Python side.
"""
rl = self.findall(**kwargs)
if self.client.include_metadata:
base_response = rl
rl = rl.data
base_response.data = rl[0]
if len(rl) == 0:
msg = _("No %(name)s matching %(kwargs)s.") % {
'name': self.resource_class.__name__, 'kwargs': kwargs}
raise ksa_exceptions.NotFound(404, msg)
elif len(rl) > 1:
raise ksc_exceptions.NoUniqueMatch
else:
return base_response if self.client.include_metadata else rl[0]
def find(self, **kwargs):
"""Find a single item with attributes matching ``**kwargs``."""
url = self.build_url(dict_args_in_out=kwargs)
query = self._build_query(kwargs)
rl = self._list('%(url)s%(query)s' % {
'url': url,
'query': query,
}, self.collection_key)
num = len(rl)
if num == 0:
msg = _("No %(name)s matching %(kwargs)s.") % {
'name': self.resource_class.__name__,
'kwargs': kwargs
}
raise ksa_exceptions.NotFound(404, msg)
elif num > 1:
raise ksc_exceptions.NoUniqueMatch
else:
return rl[0]
def find(self, name):
"""find key by key-id
:param name: key-id
:rtype: resource.Key
:return: Key which id equal to 'name'
"""
try:
return self.get(name)
except exceptions.ClientException as e:
pass
# results = self.list(name=id_or_name)
# filtered = [result for result in results if result.name == id_or_name]
# matched_number = len(filtered)
# if matched_number > 1:
# raise execs.NotUniqueMatch
# elif matched_number == 1:
# return filtered[0]
message = _("No Key with ID '%s' exists.") % name
raise exceptions.NotFound(message)
def find(self, keyword):
"""find desktop by keyword (id only for now)"""
try:
# try keyword as UUID
return self.get(keyword)
except exceptions.ClientException as e:
pass
results = self.list_detail(computer_name=keyword)
# try to locate desktops
# which's computer_name exactly matches keyword
results = [
result for result in results if result.computer_name == keyword
]
matched_number = len(results)
if matched_number > 1:
raise execs.NotUniqueMatch
elif matched_number == 1:
return results[0]
message = _("No Desktop with ID or compute name of "
"'%s' exists.") % keyword
raise exceptions.NotFound(message)
def find(self, id_or_name):
"""find auto scaling instance config by id or name
exactly match will be performed
:param id_or_name:
:return:
"""
try:
# try keyword as UUID
return self.get(id_or_name)
except exceptions.ClientException as e:
pass
results = self.list(name=id_or_name)
filtered = [result for result in results if result.name == id_or_name]
matched_number = len(filtered)
if matched_number > 1:
raise execs.NotUniqueMatch
elif matched_number == 1:
return filtered[0]
message = _("No Auto Scaling Configuration with ID or name of "
"'%s' exists.") % id_or_name
raise exceptions.NotFound(message)
def find(self, id_or_name):
"""find auto scaling group by id or name
exactly match will be performed
:param id_or_name:
:rtype: resource.AutoScalingGroup
:return: AutoScalingGroup with id or name matches id_or_name
"""
try:
return self.get(id_or_name)
except exceptions.ClientException as e:
pass
results = self.list(name=id_or_name)
filtered = [result for result in results if result.name == id_or_name]
matched_number = len(filtered)
if matched_number > 1:
raise execs.NotUniqueMatch
elif matched_number == 1:
return filtered[0]
message = _("No Auto Scaling Group with ID or name of "
"'%s' exists.") % id_or_name
raise exceptions.NotFound(message)
def find(self, id_or_name):
"""find auto scaling policy by id or name
exactly match will be performed
:param id_or_name:
:rtype: resource.AutoScalingPolicy
:return: AutoScalingPolicy which id or name matches id_or_name
"""
try:
return self.get(id_or_name)
except exceptions.ClientException:
pass
# TODO(Woo) list need as group id now.
# results = self.list(name=id_or_name)
# matched_number = len(results)
# if matched_number > 1:
# raise execs.NotUniqueMatch
# elif matched_number == 1:
# return results[0]
message = _("No Auto Scaling Group with ID or name of "
"'%s' exists.") % id_or_name
raise exceptions.NotFound(message)
def test_delete_resource_class_no_resource_class(self):
self.placement_fixture.mock_delete.side_effect = ks_exc.NotFound()
self.assertRaises(n_exc.PlacementResourceClassNotFound,
self.placement_api_client.delete_resource_class,
RESOURCE_CLASS_NAME)
def test_delete_resource_provider_traits_no_rp(self):
self.placement_fixture.mock_delete.side_effect = ks_exc.NotFound()
self.assertRaises(
n_exc.PlacementResourceProviderNotFound,
self.placement_api_client.delete_resource_provider_traits,
RESOURCE_PROVIDER_UUID)
def test_delete_trait_no_trait(self):
self.placement_fixture.mock_delete.side_effect = ks_exc.NotFound()
self.assertRaises(n_exc.PlacementTraitNotFound,
self.placement_api_client.delete_trait, TRAIT_NAME)
def test_list_aggregates_no_resource_provider(self):
self.placement_fixture.mock_get.side_effect = ks_exc.NotFound()
self.assertRaises(n_exc.PlacementAggregateNotFound,
self.placement_api_client.list_aggregates,
RESOURCE_PROVIDER_UUID)
def _test_get_inventory_not_found(self, details, expected_exception):
rp_uuid = uuidutils.generate_uuid()
resource_class = 'fake_resource_class'
self.mock_request.side_effect = ks_exc.NotFound(details=details)
self.assertRaises(expected_exception, self.client.get_inventory,
rp_uuid, resource_class)
def test_get_resource_provider_no_resource_provider(self):
self.placement_fixture.mock_get.side_effect = ks_exc.NotFound()
self.assertRaises(n_exc.PlacementResourceProviderNotFound,
self.placement_api_client.get_resource_provider,
RESOURCE_PROVIDER_UUID)
