def get_image_id(nova_client, image_identifier):
'''
Return an id for the specified image name or identifier.
:param nova_client: the nova client to use
:param image_identifier: image name or a UUID-like identifier
:returns: the id of the requested :image_identifier:
:raises: exception.ImageNotFound, exception.NoUniqueImageFound
'''
image_id = None
if uuidutils.is_uuid_like(image_identifier):
try:
image_id = nova_client.images.get(image_identifier).id
except clients.novaclient.exceptions.NotFound:
logger.info("Image %s was not found in glance" % image_identifier)
raise exception.ImageNotFound(image_name=image_identifier)
else:
try:
image_list = nova_client.images.list()
except clients.novaclient.exceptions.ClientException as ex:
raise exception.Error(
message="Error retrieving image list from nova: %s" % str(ex))
image_names = dict(
(o.id, o.name) for o in image_list if o.name == image_identifier)
if len(image_names) == 0:
logger.info("Image %s was not found in glance" % image_identifier)
raise exception.ImageNotFound(image_name=image_identifier)
elif len(image_names) > 1:
logger.info("Mulitple images %s were found in glance with name" %
image_identifier)
raise exception.NoUniqueImageFound(image_name=image_identifier)
image_id = image_names.popitem()[0]
return image_id
def get_image_id_by_name(nova_client, image_identifier):
'''
Return an id for the specified image name or identifier.
:param nova_client: the nova client to use
:param image_identifier: image name or a UUID-like identifier
:returns: the id of the requested :image_identifier:
:raises: exception.ImageNotFound, exception.PhysicalResourceNameAmbiguity
'''
try:
image_list = nova_client.images.list()
except clients.novaclient.exceptions.ClientException as ex:
raise exception.Error(
message=(_("Error retrieving image list from nova: %s") % ex))
image_names = dict(
(o.id, o.name) for o in image_list if o.name == image_identifier)
if len(image_names) == 0:
logger.info(_("Image %s was not found in glance") % image_identifier)
raise exception.ImageNotFound(image_name=image_identifier)
elif len(image_names) > 1:
logger.info(
_("Multiple images %s were found in glance with name") %
image_identifier)
raise exception.PhysicalResourceNameAmbiguity(name=image_identifier)
image_id = image_names.popitem()[0]
return image_id
def get_image_id_by_name(self, image_identifier):
'''
Return an id for the specified image name.
:param image_identifier: image name
:returns: the id of the requested :image_identifier:
:raises: exception.ImageNotFound,
exception.PhysicalResourceNameAmbiguity
'''
try:
filters = {'name': image_identifier}
image_list = self.client().images.find(**filters)
except sahara_base.APIException as ex:
raise exception.Error(
_("Error retrieving image list from sahara: "
"%s") % six.text_type(ex))
num_matches = len(image_list)
if num_matches == 0:
LOG.info(_LI("Image %s was not found in sahara images"),
image_identifier)
raise exception.ImageNotFound(image_name=image_identifier)
elif num_matches > 1:
LOG.info(_LI("Multiple images %s were found in sahara with name"),
image_identifier)
raise exception.PhysicalResourceNameAmbiguity(
name=image_identifier)
else:
return image_list[0].id
def get_image_id_by_name(glance_client, image_identifier):
'''
Return an id for the specified image name or identifier.
:param glance_client: the glance client to use
:param image_identifier: image name or a UUID-like identifier
:returns: the id of the requested :image_identifier:
:raises: exception.ImageNotFound, exception.PhysicalResourceNameAmbiguity
'''
try:
filters = {'name': image_identifier}
image_list = list(glance_client.images.list(filters=filters))
except glance_exceptions.ClientException as ex:
raise exception.Error(
_("Error retrieving image list from glance: %s") % ex)
num_matches = len(image_list)
if num_matches == 0:
logger.info(_("Image %s was not found in glance") % image_identifier)
raise exception.ImageNotFound(image_name=image_identifier)
elif num_matches > 1:
logger.info(
_("Multiple images %s were found in glance with name") %
image_identifier)
raise exception.PhysicalResourceNameAmbiguity(name=image_identifier)
else:
return image_list[0].id
def test_missing_image(self):
t = template_format.parse(ig_template)
stack = utils.parse_stack(t)
self.create_resource(t, stack, 'JobServerConfig')
rsrc = stack['JobServerGroup']
self.m.StubOutWithMock(instance.Instance, 'handle_create')
not_found = exception.ImageNotFound(image_name='bla')
instance.Instance.handle_create().AndRaise(not_found)
self.m.StubOutWithMock(parser.Stack, 'validate')
parser.Stack.validate()
self.m.StubOutWithMock(nova_keypair.KeypairConstraint, 'validate')
nova_keypair.KeypairConstraint.validate(
mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True)
self.m.StubOutWithMock(image.ImageConstraint, 'validate')
image.ImageConstraint.validate(
mox.IgnoreArg(), mox.IgnoreArg()).MultipleTimes().AndReturn(True)
self.m.ReplayAll()
create = scheduler.TaskRunner(rsrc.create)
self.assertRaises(exception.ResourceFailure, create)
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
self.m.VerifyAll()
def get_image_id_by_name(self, image_identifier):
'''
Return an id for the specified image name.
:param image_identifier: image name
:returns: the id of the requested :image_identifier:
:raises: exception.ImageNotFound,
exception.PhysicalResourceNameAmbiguity
'''
try:
filters = {'name': image_identifier}
image_list = list(self.client().images.list(filters=filters))
except exc.ClientException as ex:
raise exception.Error(
_("Error retrieving image list from glance: %s") % ex)
num_matches = len(image_list)
if num_matches == 0:
LOG.info(_LI("Image %s was not found in glance"),
image_identifier)
raise exception.ImageNotFound(image_name=image_identifier)
elif num_matches > 1:
LOG.info(_LI("Multiple images %s were found in glance with name"),
image_identifier)
raise exception.PhysicalResourceNameAmbiguity(
name=image_identifier)
else:
return image_list[0].id
def test_unregistered_image(self):
t = template_format.parse(test_template_image)
template = parser.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template,
environment.Environment({'KeyName': 'test'}))
self._mock_get_image_id_fail(
'image_name', exception.ImageNotFound(image_name='image_name'))
self.m.ReplayAll()
resource = stack['Instance']
self.assertRaises(exception.StackValidationFailed, resource.validate)
self.m.VerifyAll()
def test_missing_image(self):
t = self.load_template()
stack = self.parse_stack(t)
resource = asc.InstanceGroup('JobServerGroup',
t['Resources']['JobServerGroup'], stack)
self.m.StubOutWithMock(instance.Instance, 'handle_create')
not_found = exception.ImageNotFound(image_name='bla')
instance.Instance.handle_create().AndRaise(not_found)
self.m.ReplayAll()
self.assertNotEqual(resource.create(), None)
self.assertEqual(asc.InstanceGroup.CREATE_FAILED, resource.state)
self.m.VerifyAll()
def test_missing_image(self):
t = template_format.parse(ig_template)
stack = parse_stack(t)
resource = asc.InstanceGroup('JobServerGroup',
t['Resources']['JobServerGroup'], stack)
self.m.StubOutWithMock(instance.Instance, 'handle_create')
not_found = exception.ImageNotFound(image_name='bla')
instance.Instance.handle_create().AndRaise(not_found)
self.m.ReplayAll()
create = scheduler.TaskRunner(resource.create)
self.assertRaises(exception.ResourceFailure, create)
self.assertEqual(asc.InstanceGroup.CREATE_FAILED, resource.state)
self.m.VerifyAll()
def test_missing_image(self):
t = template_format.parse(ig_template)
stack = utils.parse_stack(t)
conf = self.create_resource(t, stack, 'JobServerConfig')
rsrc = stack.resources['JobServerGroup']
self.m.StubOutWithMock(instance.Instance, 'handle_create')
not_found = exception.ImageNotFound(image_name='bla')
instance.Instance.handle_create().AndRaise(not_found)
self.m.StubOutWithMock(parser.Stack, 'validate')
parser.Stack.validate()
self.m.ReplayAll()
create = scheduler.TaskRunner(rsrc.create)
self.assertRaises(exception.ResourceFailure, create)
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
self.m.VerifyAll()
def test_instance_create_image_name_err(self):
stack_name = 'test_instance_create_image_name_err_stack'
(tmpl, stack) = self._setup_test_stack(stack_name)
# create an instance with non exist image name
tmpl.t['Resources']['WebServer']['Properties']['ImageId'] = 'Slackware'
resource_defns = tmpl.resource_definitions(stack)
instance = instances.Instance('instance_create_image_err',
resource_defns['WebServer'], stack)
self._mock_get_image_id_fail('Slackware',
exception.ImageNotFound(
image_name='Slackware'))
self.m.ReplayAll()
create = scheduler.TaskRunner(instance.create)
error = self.assertRaises(exception.ResourceFailure, create)
self.assertEqual(
'StackValidationFailed: Property error : WebServer: '
'ImageId Error validating value \'Slackware\': '
'The Image (Slackware) could not be found.',
str(error))
self.m.VerifyAll()
def handle_create(self):
if self.properties.get('SecurityGroups') == None:
security_groups = None
else:
security_groups = [self.physical_resource_name_find(sg) for sg in
self.properties.get('SecurityGroups')]
userdata = self.properties['UserData']
userdata += '\ntouch /var/lib/cloud/instance/provision-finished\n'
flavor = self.properties['InstanceType']
key_name = self.properties['KeyName']
keypairs = [k.name for k in self.nova().keypairs.list()]
if key_name not in keypairs:
raise exception.UserKeyPairMissing(key_name=key_name)
image_name = self.properties['ImageId']
image_id = None
image_list = self.nova().images.list()
for o in image_list:
if o.name == image_name:
image_id = o.id
if image_id is None:
logger.info("Image %s was not found in glance" % image_name)
raise exception.ImageNotFound(image_name=image_name)
flavor_list = self.nova().flavors.list()
for o in flavor_list:
if o.name == flavor:
flavor_id = o.id
tags = {}
if self.properties['Tags']:
for tm in self.properties['Tags']:
tags[tm['Key']] = tm['Value']
else:
tags = None
scheduler_hints = {}
if self.properties['NovaSchedulerHints']:
for tm in self.properties['NovaSchedulerHints']:
scheduler_hints[tm['Key']] = tm['Value']
else:
scheduler_hints = None
server_userdata = self._build_userdata(userdata)
server = self.nova().servers.create(name=self.physical_resource_name(),
image=image_id,
flavor=flavor_id,
key_name=key_name,
security_groups=security_groups,
userdata=server_userdata,
meta=tags,
scheduler_hints=scheduler_hints)
while server.status == 'BUILD':
server.get()
eventlet.sleep(1)
if server.status == 'ACTIVE':
self.instance_id_set(server.id)
self._set_ipaddress(server.networks)
else:
raise exception.Error('%s instance[%s] status[%s]' %
('nova reported unexpected',
self.name, server.status))
def test_validation_error(self, mock_get_image):
with mock.patch.object(clients, "OpenStackClients"):
constraint = image.ImageConstraint()
mock_get_image.side_effect = exception.ImageNotFound(
image_name='bar')
self.assertFalse(constraint.validate("bar", None))
def test_validation_error(self):
self.mock_get_image.side_effect = exception.ImageNotFound(
image_name='bar')
self.assertFalse(self.constraint.validate("bar", self.ctx))
def handle_create(self):
if self.properties.get('SecurityGroups') is None:
security_groups = None
else:
security_groups = [
self.physical_resource_name_find(sg)
for sg in self.properties.get('SecurityGroups')
]
userdata = self.properties['UserData'] or ''
flavor = self.properties['InstanceType']
key_name = self.properties['KeyName']
availability_zone = self.properties['AvailabilityZone']
keypairs = [k.name for k in self.nova().keypairs.list()]
if key_name not in keypairs and key_name is not None:
raise exception.UserKeyPairMissing(key_name=key_name)
image_name = self.properties['ImageId']
image_id = None
image_list = self.nova().images.list()
for o in image_list:
if o.name == image_name:
image_id = o.id
break
if image_id is None:
logger.info("Image %s was not found in glance" % image_name)
raise exception.ImageNotFound(image_name=image_name)
flavor_id = None
flavor_list = self.nova().flavors.list()
for o in flavor_list:
if o.name == flavor:
flavor_id = o.id
break
if flavor_id is None:
raise exception.FlavorMissing(flavor_id=flavor)
tags = {}
if self.properties['Tags']:
for tm in self.properties['Tags']:
tags[tm['Key']] = tm['Value']
else:
tags = None
scheduler_hints = {}
if self.properties['NovaSchedulerHints']:
for tm in self.properties['NovaSchedulerHints']:
scheduler_hints[tm['Key']] = tm['Value']
else:
scheduler_hints = None
nics = self._build_nics(self.properties['NetworkInterfaces'],
subnet_id=self.properties['SubnetId'])
server_userdata = self._build_userdata(userdata)
server = None
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image_id,
flavor=flavor_id,
key_name=key_name,
security_groups=security_groups,
userdata=server_userdata,
meta=tags,
scheduler_hints=scheduler_hints,
nics=nics,
availability_zone=availability_zone)
finally:
# Avoid a race condition where the thread could be cancelled
# before the ID is stored
if server is not None:
self.resource_id_set(server.id)
return server
