def validate(self, value, context):
nova_client = clients.Clients(context).nova()
try:
nova_utils.get_flavor_id(nova_client, value)
except exception.FlavorMissing:
return False
else:
return True
def validate(self, value, context):
nova_client = clients.Clients(context).nova()
try:
nova_utils.get_flavor_id(nova_client, value)
except exception.FlavorMissing:
return False
else:
return True
def test_get_flavor_id(self):
"""Tests the get_flavor_id function."""
flav_id = str(uuid.uuid4())
flav_name = "X-Large"
my_flavor = self.m.CreateMockAnything()
my_flavor.name = flav_name
my_flavor.id = flav_id
self.nova_client.flavors = self.m.CreateMockAnything()
self.nova_client.flavors.list().MultipleTimes().AndReturn([my_flavor])
self.m.ReplayAll()
self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client, flav_name))
self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client, flav_id))
self.assertRaises(exception.FlavorMissing, nova_utils.get_flavor_id, self.nova_client, "noflavor")
self.m.VerifyAll()
def handle_create(self):
'''
Create cloud database instance.
'''
self.dbinstancename = self.physical_resource_name()
self.flavor = nova_utils.get_flavor_id(self.trove(),
self.properties['flavor'])
self.volume = {'size': self.properties['size']}
self.databases = self.properties.get('databases', [])
self.users = self.properties.get('users', [])
restore_point = self.properties.get('restore_point', None)
zone = self.properties.get('availability_zone', None)
# convert user databases to format required for troveclient.
# that is, list of database dictionaries
for user in self.users:
user['databases'] = [{'name': db}
for db in user.get('databases', [])]
# create db instance
instance = self.trove().instances.create(
self.dbinstancename,
self.flavor,
volume=self.volume,
databases=self.databases,
users=self.users,
restorePoint=restore_point,
availability_zone=zone)
self.resource_id_set(instance.id)
return instance
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
"""Try to update a Cloud Server's parameters.
If the Cloud Server's Metadata or flavor changed, update the
Cloud Server. If any other parameters changed, re-create the
Cloud Server with the new parameters.
"""
if 'Metadata' in tmpl_diff:
self.metadata = json_snippet['Metadata']
metadata_string = json.dumps(self.metadata)
files = [{
'path': "/var/cache/heat-cfntools/last_metadata",
'data': metadata_string
}]
self._sftp_files(files)
command = "bash -x /var/lib/cloud/data/cfn-userdata > " + \
"/root/cfn-userdata.log 2>&1"
exit_code = self._run_ssh_command(command)
if exit_code != 0:
raise exception.Error(self.script_error_msg % {
'path': "cfn-userdata",
'log': "/root/cfn-userdata.log"
})
if 'flavor' in prop_diff:
flav = json_snippet['Properties']['flavor']
new_flavor = nova_utils.get_flavor_id(self.nova(), flav)
self.server.resize(new_flavor)
resize = scheduler.TaskRunner(nova_utils.check_resize, self.server,
flav)
resize.start()
return resize
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
"""Try to update a Cloud Server's parameters.
If the Cloud Server's Metadata or flavor changed, update the
Cloud Server. If any other parameters changed, re-create the
Cloud Server with the new parameters.
"""
if "Metadata" in tmpl_diff:
self.metadata = json_snippet["Metadata"]
metadata_string = json.dumps(self.metadata)
files = [{"path": "/var/cache/heat-cfntools/last_metadata", "data": metadata_string}]
self._sftp_files(files)
command = "bash -x /var/lib/cloud/data/cfn-userdata > " + "/root/cfn-userdata.log 2>&1"
exit_code = self._run_ssh_command(command)
if exit_code != 0:
raise exception.Error(self.script_error_msg % {"path": "cfn-userdata", "log": "/root/cfn-userdata.log"})
if "flavor" in prop_diff:
flav = json_snippet["Properties"]["flavor"]
new_flavor = nova_utils.get_flavor_id(self.nova(), flav)
self.server.resize(new_flavor)
resize = scheduler.TaskRunner(nova_utils.check_resize, self.server, flav)
resize.start()
return resize
def handle_create(self):
security_groups = self.properties.get(self.SECURITY_GROUPS)
user_data_format = self.properties.get(self.USER_DATA_FORMAT)
userdata = nova_utils.build_userdata(
self,
self.properties.get(self.USER_DATA),
instance_user=self.properties[self.ADMIN_USER],
user_data_format=user_data_format)
flavor = self.properties[self.FLAVOR]
availability_zone = self.properties[self.AVAILABILITY_ZONE]
key_name = self.properties[self.KEY_NAME]
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image = self.properties.get(self.IMAGE)
if image:
image = nova_utils.get_image_id(self.nova(), image)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
instance_meta = self.properties.get(self.METADATA)
if instance_meta is not None:
instance_meta = nova_utils.meta_serialize(instance_meta)
scheduler_hints = self.properties.get(self.SCHEDULER_HINTS)
nics = self._build_nics(self.properties.get(self.NETWORKS))
block_device_mapping = self._build_block_device_mapping(
self.properties.get(self.BLOCK_DEVICE_MAPPING))
reservation_id = self.properties.get(self.RESERVATION_ID)
config_drive = self.properties.get(self.CONFIG_DRIVE)
disk_config = self.properties.get(self.DISK_CONFIG)
server = None
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image,
flavor=flavor_id,
key_name=key_name,
security_groups=security_groups,
userdata=userdata,
meta=instance_meta,
scheduler_hints=scheduler_hints,
nics=nics,
availability_zone=availability_zone,
block_device_mapping=block_device_mapping,
reservation_id=reservation_id,
config_drive=config_drive,
disk_config=disk_config)
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
def handle_create(self):
'''
Create cloud database instance.
'''
self.dbinstancename = self.physical_resource_name()
self.flavor = nova_utils.get_flavor_id(self.trove(),
self.properties[self.FLAVOR])
self.volume = {'size': self.properties[self.SIZE]}
self.databases = self.properties.get(self.DATABASES)
self.users = self.properties.get(self.USERS)
restore_point = self.properties.get(self.RESTORE_POINT)
zone = self.properties.get(self.AVAILABILITY_ZONE)
# convert user databases to format required for troveclient.
# that is, list of database dictionaries
for user in self.users:
dbs = [{'name': db} for db in user.get(self.USER_DATABASES, [])]
user[self.USER_DATABASES] = dbs
# create db instance
instance = self.trove().instances.create(
self.dbinstancename,
self.flavor,
volume=self.volume,
databases=self.databases,
users=self.users,
restorePoint=restore_point,
availability_zone=zone)
self.resource_id_set(instance.id)
return instance
def handle_create(self):
'''
Create cloud database instance.
'''
self.dbinstancename = self.physical_resource_name()
self.flavor = nova_utils.get_flavor_id(self.trove(),
self.properties['flavor'])
self.volume = {'size': self.properties['size']}
self.databases = self.properties.get('databases', [])
self.users = self.properties.get('users', [])
restore_point = self.properties.get('restore_point', None)
zone = self.properties.get('availability_zone', None)
# convert user databases to format required for troveclient.
# that is, list of database dictionaries
for user in self.users:
user['databases'] = [{
'name': db
} for db in user.get('databases', [])]
# create db instance
instance = self.trove().instances.create(self.dbinstancename,
self.flavor,
volume=self.volume,
databases=self.databases,
users=self.users,
restorePoint=restore_point,
availability_zone=zone)
self.resource_id_set(instance.id)
return instance
def handle_create(self):
security_groups = self.properties.get(self.SECURITY_GROUPS)
user_data_format = self.properties.get(self.USER_DATA_FORMAT)
userdata = nova_utils.build_userdata(
self,
self.properties.get(self.USER_DATA),
instance_user=self.properties[self.ADMIN_USER],
user_data_format=user_data_format)
flavor = self.properties[self.FLAVOR]
availability_zone = self.properties[self.AVAILABILITY_ZONE]
key_name = self.properties[self.KEY_NAME]
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image = self.properties.get(self.IMAGE)
if image:
image = nova_utils.get_image_id(self.nova(), image)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
instance_meta = self.properties.get(self.METADATA)
if instance_meta is not None:
instance_meta = nova_utils.meta_serialize(instance_meta)
scheduler_hints = self.properties.get(self.SCHEDULER_HINTS)
nics = self._build_nics(self.properties.get(self.NETWORKS))
block_device_mapping = self._build_block_device_mapping(
self.properties.get(self.BLOCK_DEVICE_MAPPING))
reservation_id = self.properties.get(self.RESERVATION_ID)
config_drive = self.properties.get(self.CONFIG_DRIVE)
disk_config = self.properties.get(self.DISK_CONFIG)
server = None
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image,
flavor=flavor_id,
key_name=key_name,
security_groups=security_groups,
userdata=userdata,
meta=instance_meta,
scheduler_hints=scheduler_hints,
nics=nics,
availability_zone=availability_zone,
block_device_mapping=block_device_mapping,
reservation_id=reservation_id,
config_drive=config_drive,
disk_config=disk_config)
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
def handle_create(self):
'''
Create cloud database instance.
'''
self.flavor = nova_utils.get_flavor_id(self.trove(),
self.properties[self.FLAVOR])
self.volume = {'size': self.properties[self.SIZE]}
self.databases = self.properties.get(self.DATABASES)
self.users = self.properties.get(self.USERS)
restore_point = self.properties.get(self.RESTORE_POINT)
zone = self.properties.get(self.AVAILABILITY_ZONE)
self.datastore_type = self.properties.get(self.DATASTORE_TYPE)
self.datastore_version = self.properties.get(self.DATASTORE_VERSION)
# convert user databases to format required for troveclient.
# that is, list of database dictionaries
for user in self.users:
dbs = [{'name': db} for db in user.get(self.USER_DATABASES, [])]
user[self.USER_DATABASES] = dbs
# create db instance
instance = self.trove().instances.create(
self._dbinstance_name(),
self.flavor,
volume=self.volume,
databases=self.databases,
users=self.users,
restorePoint=restore_point,
availability_zone=zone,
datastore=self.datastore_type,
datastore_version=self.datastore_version)
self.resource_id_set(instance.id)
return instance
def test_get_flavor_id(self):
"""Tests the get_flavor_id function."""
flav_id = str(uuid.uuid4())
flav_name = 'X-Large'
my_flavor = self.m.CreateMockAnything()
my_flavor.name = flav_name
my_flavor.id = flav_id
self.nova_client.flavors = self.m.CreateMockAnything()
self.nova_client.flavors.list().MultipleTimes().AndReturn([my_flavor])
self.m.ReplayAll()
self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client,
flav_name))
self.assertEqual(flav_id, nova_utils.get_flavor_id(self.nova_client,
flav_id))
self.assertRaises(exception.FlavorMissing, nova_utils.get_flavor_id,
self.nova_client, 'noflavor')
self.m.VerifyAll()
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata = tmpl_diff['Metadata']
checkers = []
server = None
if self.METADATA in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(), server,
prop_diff[self.METADATA])
if self.FLAVOR in prop_diff:
flavor_update_policy = (prop_diff.get(self.FLAVOR_UPDATE_POLICY)
or self.properties.get(
self.FLAVOR_UPDATE_POLICY))
if flavor_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
flavor = prop_diff[self.FLAVOR]
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checkers.append(checker)
if self.IMAGE in prop_diff:
image_update_policy = (prop_diff.get(self.IMAGE_UPDATE_POLICY)
or self.properties.get(
self.IMAGE_UPDATE_POLICY))
if image_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
image = prop_diff[self.IMAGE]
image_id = nova_utils.get_image_id(self.nova(), image)
if not server:
server = self.nova().servers.get(self.resource_id)
preserve_ephemeral = (
image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL')
checker = scheduler.TaskRunner(
nova_utils.rebuild,
server,
image_id,
preserve_ephemeral=preserve_ephemeral)
checkers.append(checker)
if self.NAME in prop_diff:
if not server:
server = self.nova().servers.get(self.resource_id)
nova_utils.rename(server, prop_diff[self.NAME])
# Optimization: make sure the first task is started before
# check_update_complete.
if checkers:
checkers[0].start()
return checkers
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata = tmpl_diff['Metadata']
checkers = []
server = None
if self.METADATA in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(),
server,
prop_diff[self.METADATA])
if self.FLAVOR in prop_diff:
flavor_update_policy = (
prop_diff.get(self.FLAVOR_UPDATE_POLICY) or
self.properties.get(self.FLAVOR_UPDATE_POLICY))
if flavor_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
flavor = prop_diff[self.FLAVOR]
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checkers.append(checker)
if self.IMAGE in prop_diff:
image_update_policy = (
prop_diff.get(self.IMAGE_UPDATE_POLICY) or
self.properties.get(self.IMAGE_UPDATE_POLICY))
if image_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
image = prop_diff[self.IMAGE]
image_id = nova_utils.get_image_id(self.nova(), image)
if not server:
server = self.nova().servers.get(self.resource_id)
preserve_ephemeral = (
image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL')
checker = scheduler.TaskRunner(
nova_utils.rebuild, server, image_id,
preserve_ephemeral=preserve_ephemeral)
checkers.append(checker)
if self.NAME in prop_diff:
if not server:
server = self.nova().servers.get(self.resource_id)
nova_utils.rename(server, prop_diff[self.NAME])
# Optimization: make sure the first task is started before
# check_update_complete.
if checkers:
checkers[0].start()
return checkers
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata = tmpl_diff['Metadata']
if 'InstanceType' in prop_diff:
flavor = prop_diff['InstanceType']
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
server = self.nova().servers.get(self.resource_id)
server.resize(flavor_id)
scheduler.TaskRunner(nova_utils.check_resize, server, flavor)()
def handle_create(self):
security_groups = self._get_security_groups()
userdata = self.properties['UserData'] or ''
flavor = self.properties['InstanceType']
availability_zone = self.properties['AvailabilityZone']
key_name = self.properties['KeyName']
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image_name = self.properties['ImageId']
image_id = nova_utils.get_image_id(self.nova(), image_name)
flavor_id = nova_utils.get_flavor_id(self.nova(), 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'],
security_groups=security_groups,
subnet_id=self.properties['SubnetId'])
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=self.get_mime_string(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, scheduler.TaskRunner(self._attach_volumes_task())
def handle_create(self):
security_groups = self.properties.get('security_groups', [])
user_data_format = self.properties.get('user_data_format')
userdata = nova_utils.build_userdata(
self,
self.properties.get('user_data', ''),
instance_user=self.properties['admin_user'],
user_data_format=user_data_format)
flavor = self.properties['flavor']
availability_zone = self.properties['availability_zone']
key_name = self.properties['key_name']
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image = self.properties.get('image')
if image:
image = nova_utils.get_image_id(self.nova(), image)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
instance_meta = self.properties.get('metadata')
scheduler_hints = self.properties.get('scheduler_hints')
nics = self._build_nics(self.properties.get('networks'))
block_device_mapping = self._build_block_device_mapping(
self.properties.get('block_device_mapping'))
reservation_id = self.properties.get('reservation_id')
config_drive = self.properties.get('config_drive')
disk_config = self.properties.get('diskConfig')
server = None
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image,
flavor=flavor_id,
key_name=key_name,
security_groups=security_groups,
userdata=userdata,
meta=instance_meta,
scheduler_hints=scheduler_hints,
nics=nics,
availability_zone=availability_zone,
block_device_mapping=block_device_mapping,
reservation_id=reservation_id,
config_drive=config_drive,
disk_config=disk_config)
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
def handle_create(self):
security_groups = self.properties.get('security_groups', [])
user_data_format = self.properties.get('user_data_format')
if user_data_format == 'HEAT_CFNTOOLS':
userdata = self.get_mime_string(
self.properties.get('user_data', ''))
else:
userdata = self.properties.get('user_data', '')
flavor = self.properties['flavor']
availability_zone = self.properties['availability_zone']
key_name = self.properties['key_name']
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image = self.properties.get('image')
if image:
image = nova_utils.get_image_id(self.nova(), image)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
instance_meta = self.properties.get('metadata')
scheduler_hints = self.properties.get('scheduler_hints')
nics = self._build_nics(self.properties.get('networks'))
block_device_mapping = self._build_block_device_mapping(
self.properties.get('block_device_mapping'))
reservation_id = self.properties.get('reservation_id')
config_drive = self.properties.get('config_drive')
disk_config = self.properties.get('diskConfig')
server = None
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image,
flavor=flavor_id,
key_name=key_name,
security_groups=security_groups,
userdata=userdata,
meta=instance_meta,
scheduler_hints=scheduler_hints,
nics=nics,
availability_zone=availability_zone,
block_device_mapping=block_device_mapping,
reservation_id=reservation_id,
config_drive=config_drive,
disk_config=disk_config)
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
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if "Metadata" in tmpl_diff:
self.metadata = tmpl_diff["Metadata"]
if "InstanceType" in prop_diff:
flavor = prop_diff["InstanceType"]
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
server = self.nova().servers.get(self.resource_id)
server.resize(flavor_id)
checker = scheduler.TaskRunner(nova_utils.check_resize, server, flavor)
checker.start()
return checker
def handle_create(self):
security_groups = self._get_security_groups()
userdata = self.properties['UserData'] or ''
flavor = self.properties['InstanceType']
availability_zone = self.properties['AvailabilityZone']
key_name = self.properties['KeyName']
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image_name = self.properties['ImageId']
image_id = nova_utils.get_image_id(self.nova(), image_name)
flavor_id = nova_utils.get_flavor_id(self.nova(), 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 = 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=self.get_mime_string(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, scheduler.TaskRunner(self._attach_volumes_task())
def handle_create(self):
security_groups = self._get_security_groups()
userdata = self.properties[self.USER_DATA] or ''
flavor = self.properties[self.INSTANCE_TYPE]
availability_zone = self.properties[self.AVAILABILITY_ZONE]
image_name = self.properties[self.IMAGE_ID]
image_id = nova_utils.get_image_id(self.nova(), image_name)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
scheduler_hints = {}
if self.properties[self.NOVA_SCHEDULER_HINTS]:
for tm in self.properties[self.NOVA_SCHEDULER_HINTS]:
scheduler_hints[tm[self.TAG_KEY]] = tm[self.TAG_VALUE]
else:
scheduler_hints = None
nics = self._build_nics(self.properties[self.NETWORK_INTERFACES],
security_groups=security_groups,
subnet_id=self.properties[self.SUBNET_ID])
server = None
# FIXME(shadower): the instance_user config option is deprecated. Once
# it's gone, we should always use ec2-user for compatibility with
# CloudFormation.
if cfg.CONF.instance_user:
instance_user = cfg.CONF.instance_user
else:
instance_user = '******'
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image_id,
flavor=flavor_id,
key_name=self.properties[self.KEY_NAME],
security_groups=security_groups,
userdata=nova_utils.build_userdata(self, userdata,
instance_user),
meta=self._get_nova_metadata(self.properties),
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, scheduler.TaskRunner(self._attach_volumes_task())
def handle_create(self):
security_groups = self._get_security_groups()
userdata = self.properties[self.USER_DATA] or ''
flavor = self.properties[self.INSTANCE_TYPE]
availability_zone = self.properties[self.AVAILABILITY_ZONE]
image_name = self.properties[self.IMAGE_ID]
image_id = nova_utils.get_image_id(self.nova(), image_name)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
scheduler_hints = {}
if self.properties[self.NOVA_SCHEDULER_HINTS]:
for tm in self.properties[self.NOVA_SCHEDULER_HINTS]:
scheduler_hints[tm[self.TAG_KEY]] = tm[self.TAG_VALUE]
else:
scheduler_hints = None
nics = self._build_nics(self.properties[self.NETWORK_INTERFACES],
security_groups=security_groups,
subnet_id=self.properties[self.SUBNET_ID])
server = None
# FIXME(shadower): the instance_user config option is deprecated. Once
# it's gone, we should always use ec2-user for compatibility with
# CloudFormation.
if cfg.CONF.instance_user:
instance_user = cfg.CONF.instance_user
else:
instance_user = '******'
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image_id,
flavor=flavor_id,
key_name=self.properties[self.KEY_NAME],
security_groups=security_groups,
userdata=nova_utils.build_userdata(self, userdata,
instance_user),
meta=self._get_nova_metadata(self.properties),
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, scheduler.TaskRunner(self._attach_volumes_task())
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata = tmpl_diff['Metadata']
checkers = []
server = None
if 'metadata' in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(),
server,
prop_diff['metadata'])
if 'flavor' in prop_diff:
flavor_update_policy = (
prop_diff.get('flavor_update_policy') or
self.properties.get('flavor_update_policy'))
if flavor_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
flavor = prop_diff['flavor']
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checkers.append(checker)
if 'image' in prop_diff:
image_update_policy = (
prop_diff.get('image_update_policy') or
self.properties.get('image_update_policy'))
if image_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
image = prop_diff['image']
image_id = nova_utils.get_image_id(self.nova(), image)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.rebuild, server,
image_id)
checkers.append(checker)
# Optimization: make sure the first task is started before
# check_update_complete.
if checkers:
checkers[0].start()
return checkers
def handle_create(self):
security_groups = self._get_security_groups()
userdata = self.properties[self.USER_DATA] or ''
flavor = self.properties[self.INSTANCE_TYPE]
availability_zone = self.properties[self.AVAILABILITY_ZONE]
key_name = self.properties[self.KEY_NAME]
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image_name = self.properties[self.IMAGE_ID]
image_id = nova_utils.get_image_id(self.nova(), image_name)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
scheduler_hints = {}
if self.properties[self.NOVA_SCHEDULER_HINTS]:
for tm in self.properties[self.NOVA_SCHEDULER_HINTS]:
scheduler_hints[tm[self.TAG_KEY]] = tm[self.TAG_VALUE]
else:
scheduler_hints = None
nics = self._build_nics(self.properties[self.NETWORK_INTERFACES],
security_groups=security_groups,
subnet_id=self.properties[self.SUBNET_ID])
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=nova_utils.build_userdata(self, userdata),
meta=self._get_nova_metadata(self.properties),
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, scheduler.TaskRunner(self._attach_volumes_task())
def handle_create(self):
security_groups = self._get_security_groups()
userdata = self.properties[self.USER_DATA] or ''
flavor = self.properties[self.INSTANCE_TYPE]
availability_zone = self.properties[self.AVAILABILITY_ZONE]
key_name = self.properties[self.KEY_NAME]
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image_name = self.properties[self.IMAGE_ID]
image_id = nova_utils.get_image_id(self.nova(), image_name)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
scheduler_hints = {}
if self.properties[self.NOVA_SCHEDULER_HINTS]:
for tm in self.properties[self.NOVA_SCHEDULER_HINTS]:
scheduler_hints[tm[self.TAG_KEY]] = tm[self.TAG_VALUE]
else:
scheduler_hints = None
nics = self._build_nics(self.properties[self.NETWORK_INTERFACES],
security_groups=security_groups,
subnet_id=self.properties[self.SUBNET_ID])
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=nova_utils.build_userdata(self, userdata),
meta=self._get_nova_metadata(self.properties),
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, scheduler.TaskRunner(self._attach_volumes_task())
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata = tmpl_diff['Metadata']
checkers = []
server = None
if 'metadata' in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(), server, prop_diff['metadata'])
if 'flavor' in prop_diff:
flavor_update_policy = (
prop_diff.get('flavor_update_policy')
or self.properties.get('flavor_update_policy'))
if flavor_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
flavor = prop_diff['flavor']
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checkers.append(checker)
if 'image' in prop_diff:
image_update_policy = (prop_diff.get('image_update_policy') or
self.properties.get('image_update_policy'))
if image_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
image = prop_diff['image']
image_id = nova_utils.get_image_id(self.nova(), image)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.rebuild, server,
image_id)
checkers.append(checker)
# Optimization: make sure the first task is started before
# check_update_complete.
if checkers:
checkers[0].start()
return checkers
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata = tmpl_diff['Metadata']
if 'flavor' in prop_diff:
flavor_update_policy = (
prop_diff.get('flavor_update_policy') or
self.properties.get('flavor_update_policy'))
if flavor_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
flavor = prop_diff['flavor']
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
server = self.nova().servers.get(self.resource_id)
server.resize(flavor_id)
scheduler.TaskRunner(nova_utils.check_resize, server, flavor)()
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata = tmpl_diff['Metadata']
server = None
if self.TAGS in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(), server,
self._get_nova_metadata(prop_diff))
if self.INSTANCE_TYPE in prop_diff:
flavor = prop_diff[self.INSTANCE_TYPE]
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checker.start()
return checker
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata = tmpl_diff['Metadata']
server = None
if self.TAGS in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(),
server,
self._get_nova_metadata(prop_diff))
if self.INSTANCE_TYPE in prop_diff:
flavor = prop_diff[self.INSTANCE_TYPE]
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checker.start()
return checker
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata_set(tmpl_diff['Metadata'])
checkers = []
server = None
if self.METADATA in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(),
server,
prop_diff[self.METADATA])
if self.FLAVOR in prop_diff:
flavor_update_policy = (
prop_diff.get(self.FLAVOR_UPDATE_POLICY) or
self.properties.get(self.FLAVOR_UPDATE_POLICY))
if flavor_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
flavor = prop_diff[self.FLAVOR]
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checkers.append(checker)
if self.IMAGE in prop_diff:
image_update_policy = (
prop_diff.get(self.IMAGE_UPDATE_POLICY) or
self.properties.get(self.IMAGE_UPDATE_POLICY))
if image_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
image = prop_diff[self.IMAGE]
image_id = self.client_plugin('glance').get_image_id(image)
if not server:
server = self.nova().servers.get(self.resource_id)
preserve_ephemeral = (
image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL')
checker = scheduler.TaskRunner(
nova_utils.rebuild, server, image_id,
preserve_ephemeral=preserve_ephemeral)
checkers.append(checker)
if self.NAME in prop_diff:
if not server:
server = self.nova().servers.get(self.resource_id)
nova_utils.rename(server, prop_diff[self.NAME])
if self.NETWORKS in prop_diff:
new_networks = prop_diff.get(self.NETWORKS)
attach_first_free_port = False
if not new_networks:
new_networks = []
attach_first_free_port = True
old_networks = self.properties.get(self.NETWORKS)
if not server:
server = self.nova().servers.get(self.resource_id)
interfaces = server.interface_list()
# if old networks is None, it means that the server got first
# free port. so we should detach this interface.
if old_networks is None:
for iface in interfaces:
checker = scheduler.TaskRunner(server.interface_detach,
iface.port_id)
checkers.append(checker)
# if we have any information in networks field, we should:
# 1. find similar networks, if they exist
# 2. remove these networks from new_networks and old_networks
# lists
# 3. detach unmatched networks, which were present in old_networks
# 4. attach unmatched networks, which were present in new_networks
else:
# remove not updated networks from old and new networks lists,
# also get list these networks
not_updated_networks = \
self._get_network_matches(old_networks, new_networks)
self.update_networks_matching_iface_port(
old_networks + not_updated_networks, interfaces)
# according to nova interface-detach command detached port
# will be deleted
for net in old_networks:
checker = scheduler.TaskRunner(server.interface_detach,
net.get('port'))
checkers.append(checker)
# attach section similar for both variants that
# were mentioned above
for net in new_networks:
if net.get('port'):
checker = scheduler.TaskRunner(server.interface_attach,
net['port'], None, None)
checkers.append(checker)
elif net.get('network'):
checker = scheduler.TaskRunner(server.interface_attach,
None, net['network'],
net.get('fixed_ip'))
checkers.append(checker)
# if new_networks is None, we should attach first free port,
# according to similar behavior during instance creation
if attach_first_free_port:
checker = scheduler.TaskRunner(server.interface_attach,
None, None, None)
checkers.append(checker)
# Optimization: make sure the first task is started before
# check_update_complete.
if checkers:
checkers[0].start()
return checkers
def handle_create(self):
security_groups = self.properties.get(self.SECURITY_GROUPS)
user_data_format = self.properties.get(self.USER_DATA_FORMAT)
ud_content = self.properties.get(self.USER_DATA)
if self.user_data_software_config() or self.user_data_raw():
if uuidutils.is_uuid_like(ud_content):
# attempt to load the userdata from software config
try:
ud_content = sc.SoftwareConfig.get_software_config(
self.heat(), ud_content)
except exception.SoftwareConfigMissing:
# no config was found, so do not modify the user_data
pass
if self.user_data_software_config():
self._create_transport_credentials()
self._populate_deployments_metadata()
if self.properties[self.ADMIN_USER]:
instance_user = self.properties[self.ADMIN_USER]
elif cfg.CONF.instance_user:
instance_user = cfg.CONF.instance_user
else:
instance_user = None
userdata = nova_utils.build_userdata(
self,
ud_content,
instance_user=instance_user,
user_data_format=user_data_format)
flavor = self.properties[self.FLAVOR]
availability_zone = self.properties[self.AVAILABILITY_ZONE]
image = self.properties.get(self.IMAGE)
if image:
image = self.client_plugin('glance').get_image_id(image)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
instance_meta = self.properties.get(self.METADATA)
if instance_meta is not None:
instance_meta = nova_utils.meta_serialize(instance_meta)
scheduler_hints = self.properties.get(self.SCHEDULER_HINTS)
nics = self._build_nics(self.properties.get(self.NETWORKS))
block_device_mapping = self._build_block_device_mapping(
self.properties.get(self.BLOCK_DEVICE_MAPPING))
reservation_id = self.properties.get(self.RESERVATION_ID)
disk_config = self.properties.get(self.DISK_CONFIG)
admin_pass = self.properties.get(self.ADMIN_PASS) or None
personality_files = self.properties.get(self.PERSONALITY)
key_name = self.properties.get(self.KEY_NAME)
server = None
try:
server = self.nova().servers.create(
name=self._server_name(),
image=image,
flavor=flavor_id,
key_name=key_name,
security_groups=security_groups,
userdata=userdata,
meta=instance_meta,
scheduler_hints=scheduler_hints,
nics=nics,
availability_zone=availability_zone,
block_device_mapping=block_device_mapping,
reservation_id=reservation_id,
config_drive=self._config_drive(),
disk_config=disk_config,
files=personality_files,
admin_pass=admin_pass)
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
def validate_with_client(self, client, value):
nova_client = client.client('nova')
nova_utils.get_flavor_id(nova_client, value)
def handle_create(self):
security_groups = self._get_security_groups()
userdata = self.properties['UserData'] or ''
flavor = self.properties['InstanceType']
availability_zone = self.properties['AvailabilityZone']
key_name = self.properties['KeyName']
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image_name = self.properties['ImageId']
image_id = nova_utils.get_image_id(self.nova(), image_name)
flavor_id = nova_utils.get_flavor_id(self.nova(), 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'],
security_groups=security_groups,
subnet_id=self.properties['SubnetId'])
server = None
# TODO(sdake/shardy) ensure physical_resource_name() never returns a
# string longer than 63 characters, as this is pretty inconvenient
# behavior for autoscaling groups and nested stacks where instance
# names can easily become quite long even with terse names.
physical_resource_name_len = len(self.physical_resource_name())
if physical_resource_name_len > 63:
raise exception.Error(
_('Server %(server)s length %(length)d > 63'
' characters, please reduce the length of'
' stack or resource names') %
dict(server=self.physical_resource_name(),
length=physical_resource_name_len))
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=self.get_mime_string(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, scheduler.TaskRunner(self._attach_volumes_task())
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata_set(tmpl_diff['Metadata'])
checkers = []
server = None
if self.TAGS in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(), server,
self._get_nova_metadata(prop_diff))
if self.INSTANCE_TYPE in prop_diff:
flavor = prop_diff[self.INSTANCE_TYPE]
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checkers.append(checker)
if self.NETWORK_INTERFACES in prop_diff:
new_network_ifaces = prop_diff.get(self.NETWORK_INTERFACES)
old_network_ifaces = self.properties.get(self.NETWORK_INTERFACES)
subnet_id = (prop_diff.get(self.SUBNET_ID)
or self.properties.get(self.SUBNET_ID))
security_groups = self._get_security_groups()
if not server:
server = self.nova().servers.get(self.resource_id)
# if there is entrys in old_network_ifaces and new_network_ifaces,
# remove the same entrys from old and new ifaces
if old_network_ifaces and new_network_ifaces:
# there are four situations:
# 1.old includes new, such as: old = 2,3, new = 2
# 2.new includes old, such as: old = 2,3, new = 1,2,3
# 3.has overlaps, such as: old = 2,3, new = 1,2
# 4.different, such as: old = 2,3, new = 1,4
# detach unmatched ones in old, attach unmatched ones in new
self._remove_matched_ifaces(old_network_ifaces,
new_network_ifaces)
if old_network_ifaces:
old_nics = self._build_nics(old_network_ifaces)
for nic in old_nics:
checker = scheduler.TaskRunner(server.interface_detach,
nic['port-id'])
checkers.append(checker)
if new_network_ifaces:
new_nics = self._build_nics(new_network_ifaces)
for nic in new_nics:
checker = scheduler.TaskRunner(server.interface_attach,
nic['port-id'], None,
None)
checkers.append(checker)
# if the interfaces not come from property 'NetworkInterfaces',
# the situation is somewhat complex, so to detach the old ifaces,
# and then attach the new ones.
else:
interfaces = server.interface_list()
for iface in interfaces:
checker = scheduler.TaskRunner(server.interface_detach,
iface.port_id)
checkers.append(checker)
nics = self._build_nics(new_network_ifaces,
security_groups=security_groups,
subnet_id=subnet_id)
# 'SubnetId' property is empty(or None) and
# 'NetworkInterfaces' property is empty(or None),
# _build_nics() will return nics = None,we should attach
# first free port, according to similar behavior during
# instance creation
if not nics:
checker = scheduler.TaskRunner(server.interface_attach,
None, None, None)
checkers.append(checker)
else:
for nic in nics:
checker = scheduler.TaskRunner(server.interface_attach,
nic['port-id'], None,
None)
checkers.append(checker)
if checkers:
checkers[0].start()
return checkers
def handle_create(self):
security_groups = self._get_security_groups()
userdata = self.properties['UserData'] or ''
flavor = self.properties['InstanceType']
availability_zone = self.properties['AvailabilityZone']
key_name = self.properties['KeyName']
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image_name = self.properties['ImageId']
image_id = nova_utils.get_image_id(self.nova(), image_name)
flavor_id = nova_utils.get_flavor_id(self.nova(), 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'],
security_groups=security_groups,
subnet_id=self.properties['SubnetId'])
server = None
# TODO(sdake/shardy) ensure physical_resource_name() never returns a
# string longer than 63 characters, as this is pretty inconvenient
# behavior for autoscaling groups and nested stacks where instance
# names can easily become quite long even with terse names.
physical_resource_name_len = len(self.physical_resource_name())
if physical_resource_name_len > 63:
raise exception.Error(_('Server %(server)s length %(length)d > 63'
' characters, please reduce the length of'
' stack or resource names') %
dict(server=self.physical_resource_name(),
length=physical_resource_name_len))
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=self.get_mime_string(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, scheduler.TaskRunner(self._attach_volumes_task())
def flavor(self):
"""Get the flavors from the API."""
if not self._flavor:
self._flavor = nova_utils.get_flavor_id(self.nova(), self.properties["flavor"])
return self._flavor
def handle_create(self):
security_groups = self.properties.get('security_groups', [])
user_data_format = self.properties.get('user_data_format')
if user_data_format == 'HEAT_CFNTOOLS':
userdata = self.get_mime_string(
self.properties.get('user_data', ''))
else:
userdata = self.properties.get('user_data', '')
flavor = self.properties['flavor']
availability_zone = self.properties['availability_zone']
key_name = self.properties['key_name']
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image = self.properties.get('image')
if image:
image = nova_utils.get_image_id(self.nova(), image)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
instance_meta = self.properties.get('metadata')
scheduler_hints = self.properties.get('scheduler_hints')
nics = self._build_nics(self.properties.get('networks'))
block_device_mapping = self._build_block_device_mapping(
self.properties.get('block_device_mapping'))
reservation_id = self.properties.get('reservation_id')
config_drive = self.properties.get('config_drive')
disk_config = self.properties.get('diskConfig')
# TODO(sdake/shardy) ensure physical_resource_name() never returns a
# string longer than 63 characters, as this is pretty inconvenient
# behavior for autoscaling groups and nested stacks where instance
# names can easily become quite long even with terse names.
physical_resource_name_len = len(self.physical_resource_name())
if physical_resource_name_len > 63:
raise exception.Error(
_('Server %(server)s length %(length)d > 63'
' characters, please reduce the length of'
' stack or resource names') %
dict(server=self.physical_resource_name(),
length=physical_resource_name_len))
server = None
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image,
flavor=flavor_id,
key_name=key_name,
security_groups=security_groups,
userdata=userdata,
meta=instance_meta,
scheduler_hints=scheduler_hints,
nics=nics,
availability_zone=availability_zone,
block_device_mapping=block_device_mapping,
reservation_id=reservation_id,
config_drive=config_drive,
disk_config=disk_config)
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
def flavor(self):
"""Get the flavors from the API."""
if not self._flavor:
flavor = self.properties[self.FLAVOR]
self._flavor = nova_utils.get_flavor_id(self.nova(), flavor)
return self._flavor
def handle_create(self):
security_groups = self.properties.get(self.SECURITY_GROUPS)
user_data_format = self.properties.get(self.USER_DATA_FORMAT)
ud_content = self.properties.get(self.USER_DATA)
if self.user_data_software_config() or self.user_data_raw():
if uuidutils.is_uuid_like(ud_content):
# attempt to load the userdata from software config
try:
ud_content = sc.SoftwareConfig.get_software_config(
self.heat(), ud_content)
except exception.SoftwareConfigMissing:
# no config was found, so do not modify the user_data
pass
if self.user_data_software_config():
self._create_transport_credentials()
if self.properties[self.ADMIN_USER]:
instance_user = self.properties[self.ADMIN_USER]
elif cfg.CONF.instance_user:
instance_user = cfg.CONF.instance_user
else:
instance_user = None
userdata = nova_utils.build_userdata(self,
ud_content,
instance_user=instance_user,
user_data_format=user_data_format)
flavor = self.properties[self.FLAVOR]
availability_zone = self.properties[self.AVAILABILITY_ZONE]
image = self.properties.get(self.IMAGE)
if image:
image = nova_utils.get_image_id(self.nova(), image)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
instance_meta = self.properties.get(self.METADATA)
if instance_meta is not None:
instance_meta = nova_utils.meta_serialize(instance_meta)
scheduler_hints = self.properties.get(self.SCHEDULER_HINTS)
nics = self._build_nics(self.properties.get(self.NETWORKS))
block_device_mapping = self._build_block_device_mapping(
self.properties.get(self.BLOCK_DEVICE_MAPPING))
reservation_id = self.properties.get(self.RESERVATION_ID)
config_drive = self.properties.get(self.CONFIG_DRIVE)
disk_config = self.properties.get(self.DISK_CONFIG)
admin_pass = self.properties.get(self.ADMIN_PASS) or None
server = None
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image,
flavor=flavor_id,
key_name=self._key_name(),
security_groups=security_groups,
userdata=userdata,
meta=instance_meta,
scheduler_hints=scheduler_hints,
nics=nics,
availability_zone=availability_zone,
block_device_mapping=block_device_mapping,
reservation_id=reservation_id,
config_drive=config_drive,
disk_config=disk_config,
files=self._personality(),
admin_pass=admin_pass)
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
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata_set(tmpl_diff['Metadata'])
checkers = []
server = None
if self.TAGS in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(),
server,
self._get_nova_metadata(prop_diff))
if self.INSTANCE_TYPE in prop_diff:
flavor = prop_diff[self.INSTANCE_TYPE]
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checkers.append(checker)
if self.NETWORK_INTERFACES in prop_diff:
new_network_ifaces = prop_diff.get(self.NETWORK_INTERFACES)
old_network_ifaces = self.properties.get(self.NETWORK_INTERFACES)
subnet_id = (
prop_diff.get(self.SUBNET_ID) or
self.properties.get(self.SUBNET_ID))
security_groups = self._get_security_groups()
if not server:
server = self.nova().servers.get(self.resource_id)
# if there is entrys in old_network_ifaces and new_network_ifaces,
# remove the same entrys from old and new ifaces
if old_network_ifaces and new_network_ifaces:
# there are four situations:
# 1.old includes new, such as: old = 2,3, new = 2
# 2.new includes old, such as: old = 2,3, new = 1,2,3
# 3.has overlaps, such as: old = 2,3, new = 1,2
# 4.different, such as: old = 2,3, new = 1,4
# detach unmatched ones in old, attach unmatched ones in new
self._remove_matched_ifaces(old_network_ifaces,
new_network_ifaces)
if old_network_ifaces:
old_nics = self._build_nics(old_network_ifaces)
for nic in old_nics:
checker = scheduler.TaskRunner(
server.interface_detach,
nic['port-id'])
checkers.append(checker)
if new_network_ifaces:
new_nics = self._build_nics(new_network_ifaces)
for nic in new_nics:
checker = scheduler.TaskRunner(
server.interface_attach,
nic['port-id'],
None, None)
checkers.append(checker)
# if the interfaces not come from property 'NetworkInterfaces',
# the situation is somewhat complex, so to detach the old ifaces,
# and then attach the new ones.
else:
interfaces = server.interface_list()
for iface in interfaces:
checker = scheduler.TaskRunner(server.interface_detach,
iface.port_id)
checkers.append(checker)
nics = self._build_nics(new_network_ifaces,
security_groups=security_groups,
subnet_id=subnet_id)
# 'SubnetId' property is empty(or None) and
# 'NetworkInterfaces' property is empty(or None),
# _build_nics() will return nics = None,we should attach
# first free port, according to similar behavior during
# instance creation
if not nics:
checker = scheduler.TaskRunner(server.interface_attach,
None, None, None)
checkers.append(checker)
else:
for nic in nics:
checker = scheduler.TaskRunner(
server.interface_attach,
nic['port-id'], None, None)
checkers.append(checker)
if checkers:
checkers[0].start()
return checkers
def handle_create(self):
security_groups = self.properties.get('security_groups', [])
userdata = self.properties.get('user_data', '')
flavor = self.properties['flavor']
availability_zone = self.properties['availability_zone']
key_name = self.properties['key_name']
if key_name:
# confirm keypair exists
nova_utils.get_keypair(self.nova(), key_name)
image = self.properties.get('image')
if image:
image = nova_utils.get_image_id(self.nova(), image)
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
instance_meta = self.properties.get('metadata')
scheduler_hints = self.properties.get('scheduler_hints')
nics = self._build_nics(self.properties.get('networks'))
block_device_mapping = self._build_block_device_mapping(
self.properties.get('block_device_mapping'))
reservation_id = self.properties.get('reservation_id')
config_drive = self.properties.get('config_drive')
disk_config = self.properties.get('diskConfig')
# TODO(sdake/shardy) ensure physical_resource_name() never returns a
# string longer than 63 characters, as this is pretty inconvenient
# behavior for autoscaling groups and nested stacks where instance
# names can easily become quite long even with terse names.
physical_resource_name_len = len(self.physical_resource_name())
if physical_resource_name_len > 63:
raise exception.Error(_('Server %(server)s length %(length)d > 63'
' characters, please reduce the length of'
' stack or resource names') %
dict(server=self.physical_resource_name(),
length=physical_resource_name_len))
server = None
try:
server = self.nova().servers.create(
name=self.physical_resource_name(),
image=image,
flavor=flavor_id,
key_name=key_name,
security_groups=security_groups,
userdata=self.get_mime_string(userdata),
meta=instance_meta,
scheduler_hints=scheduler_hints,
nics=nics,
availability_zone=availability_zone,
block_device_mapping=block_device_mapping,
reservation_id=reservation_id,
config_drive=config_drive,
disk_config=disk_config)
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
def flavor(self):
"""Get the flavors from the API."""
if not self._flavor:
self._flavor = nova_utils.get_flavor_id(self.nova(),
self.properties['flavor'])
return self._flavor
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if 'Metadata' in tmpl_diff:
self.metadata = tmpl_diff['Metadata']
checkers = []
server = None
if self.METADATA in prop_diff:
server = self.nova().servers.get(self.resource_id)
nova_utils.meta_update(self.nova(), server,
prop_diff[self.METADATA])
if self.FLAVOR in prop_diff:
flavor_update_policy = (prop_diff.get(self.FLAVOR_UPDATE_POLICY)
or self.properties.get(
self.FLAVOR_UPDATE_POLICY))
if flavor_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
flavor = prop_diff[self.FLAVOR]
flavor_id = nova_utils.get_flavor_id(self.nova(), flavor)
if not server:
server = self.nova().servers.get(self.resource_id)
checker = scheduler.TaskRunner(nova_utils.resize, server, flavor,
flavor_id)
checkers.append(checker)
if self.IMAGE in prop_diff:
image_update_policy = (prop_diff.get(self.IMAGE_UPDATE_POLICY)
or self.properties.get(
self.IMAGE_UPDATE_POLICY))
if image_update_policy == 'REPLACE':
raise resource.UpdateReplace(self.name)
image = prop_diff[self.IMAGE]
image_id = nova_utils.get_image_id(self.nova(), image)
if not server:
server = self.nova().servers.get(self.resource_id)
preserve_ephemeral = (
image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL')
checker = scheduler.TaskRunner(
nova_utils.rebuild,
server,
image_id,
preserve_ephemeral=preserve_ephemeral)
checkers.append(checker)
if self.NAME in prop_diff:
if not server:
server = self.nova().servers.get(self.resource_id)
nova_utils.rename(server, prop_diff[self.NAME])
if self.NETWORKS in prop_diff:
new_networks = prop_diff.get(self.NETWORKS)
attach_first_free_port = False
if not new_networks:
new_networks = []
attach_first_free_port = True
old_networks = self.properties.get(self.NETWORKS)
if not server:
server = self.nova().servers.get(self.resource_id)
interfaces = server.interface_list()
# if old networks is None, it means that the server got first
# free port. so we should detach this interface.
if old_networks is None:
for iface in interfaces:
checker = scheduler.TaskRunner(server.interface_detach,
iface.port_id)
checkers.append(checker)
# if we have any information in networks field, we should:
# 1. find similar networks, if they exist
# 2. remove these networks from new_networks and old_networks
# lists
# 3. detach unmatched networks, which were present in old_networks
# 4. attach unmatched networks, which were present in new_networks
else:
# remove not updated networks from old and new networks lists,
# also get list these networks
not_updated_networks = \
self._get_network_matches(old_networks, new_networks)
self.update_networks_matching_iface_port(
old_networks + not_updated_networks, interfaces)
# according to nova interface-detach command detached port
# will be deleted
for net in old_networks:
checker = scheduler.TaskRunner(server.interface_detach,
net.get('port'))
checkers.append(checker)
# attach section similar for both variants that
# were mentioned above
for net in new_networks:
if net.get('port'):
checker = scheduler.TaskRunner(server.interface_attach,
net['port'], None, None)
checkers.append(checker)
elif net.get('network'):
checker = scheduler.TaskRunner(server.interface_attach,
None, net['network'],
net.get('fixed_ip'))
checkers.append(checker)
# if new_networks is None, we should attach first free port,
# according to similar behavior during instance creation
if attach_first_free_port:
checker = scheduler.TaskRunner(server.interface_attach, None,
None, None)
checkers.append(checker)
# Optimization: make sure the first task is started before
# check_update_complete.
if checkers:
checkers[0].start()
return checkers
def validate_with_client(self, client, value):
nova_client = client.nova()
nova_utils.get_flavor_id(nova_client, value)
def flavor(self):
"""Get the flavors from the API."""
if not self._flavor:
flavor = self.properties[self.FLAVOR]
self._flavor = nova_utils.get_flavor_id(self.nova(), flavor)
return self._flavor
