def create(nova_client, args, **kwargs):
if use_external_resource(ctx, nova_client, FLAVOR_OPENSTACK_TYPE):
return
flavor_dict = create_object_dict(ctx, FLAVOR_OPENSTACK_TYPE, args, {})
flavor = nova_client.flavors.create(**flavor_dict)
set_openstack_runtime_properties(ctx, flavor, FLAVOR_OPENSTACK_TYPE)
def create(neutron_client, args, **kwargs):
if use_external_resource(ctx, neutron_client, ROUTER_OPENSTACK_TYPE):
try:
ext_net_id_by_rel = _get_connected_ext_net_id(neutron_client)
if ext_net_id_by_rel:
router_id = get_openstack_id(ctx)
router = neutron_client.show_router(router_id)['router']
if not (router['external_gateway_info']
and 'network_id' in router['external_gateway_info']
and router['external_gateway_info']['network_id']
== ext_net_id_by_rel):
raise NonRecoverableError(
'Expected external resources router {0} and '
'external network {1} to be connected'.format(
router_id, ext_net_id_by_rel))
return
except Exception:
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
router = create_object_dict(ctx, ROUTER_OPENSTACK_TYPE, args, {})
ctx.logger.info('router: {0}'.format(router))
_handle_external_network_config(router, neutron_client)
r = neutron_client.create_router({ROUTER_OPENSTACK_TYPE:
router})[ROUTER_OPENSTACK_TYPE]
set_neutron_runtime_properties(ctx, r, ROUTER_OPENSTACK_TYPE)
def create(cinder_client, status_attempts, status_timeout, args, **kwargs):
if use_external_resource(ctx, cinder_client, VOLUME_OPENSTACK_TYPE,
'name'):
return
volume_dict = create_object_dict(ctx, VOLUME_OPENSTACK_TYPE, args, {})
handle_image_from_relationship(volume_dict, 'imageRef', ctx)
v = cinder_client.volumes.create(**volume_dict)
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY] = v.id
ctx.instance.runtime_properties[OPENSTACK_TYPE_PROPERTY] = \
VOLUME_OPENSTACK_TYPE
ctx.instance.runtime_properties[OPENSTACK_NAME_PROPERTY] = \
volume_dict['name']
wait_until_status(
cinder_client=cinder_client,
volume_id=v.id,
status=VOLUME_STATUS_AVAILABLE,
num_tries=status_attempts,
timeout=status_timeout,
)
ctx.instance.runtime_properties[OPENSTACK_AZ_PROPERTY] = \
v.availability_zone
def create(cinder_client,
args={},
status_timeout=15,
status_attempts=20,
**kwargs):
external_volume = use_external_resource(
ctx, cinder_client, VOLUME_OPENSTACK_TYPE, VOLUME_OPENSTACK_ID_KEY)
if external_volume:
_set_volume_runtime_properties(external_volume)
return
volume_dict = create_object_dict(ctx, VOLUME_OPENSTACK_TYPE, args, {})
handle_image_from_relationship(volume_dict, 'imageRef', ctx)
v = cinder_client.volumes.create(**volume_dict)
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY] = v.id
ctx.instance.runtime_properties[OPENSTACK_TYPE_PROPERTY] = \
VOLUME_OPENSTACK_TYPE
ctx.instance.runtime_properties[OPENSTACK_NAME_PROPERTY] = \
volume_dict[VOLUME_OPENSTACK_ID_KEY]
wait_until_status(cinder_client=cinder_client,
volume_id=v.id,
status=VOLUME_STATUS_AVAILABLE,
num_tries=status_attempts,
timeout=status_timeout,
)
_set_volume_runtime_properties(v)
def update_project(keystone_client, args, **kwargs):
project_dict = create_object_dict(ctx, PROJECT_OPENSTACK_TYPE, args,
{'domain': 'default'})
project_dict[PROJECT_OPENSTACK_TYPE] = get_openstack_id(ctx)
project = keystone_client.projects.update(**project_dict)
set_openstack_runtime_properties(ctx, project, PROJECT_OPENSTACK_TYPE)
def create(neutron_client, args, **kwargs):
if use_external_resource(ctx, neutron_client, SUBNET_OPENSTACK_TYPE):
try:
net_id = \
get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, NETWORK_OPENSTACK_TYPE, True)
if net_id:
subnet_id = get_openstack_id(ctx)
if neutron_client.show_subnet(
subnet_id)[SUBNET_OPENSTACK_TYPE][NETWORK_ID] \
!= net_id:
raise NonRecoverableError(
'Expected external resources subnet {0} and network'
' {1} to be connected'.format(subnet_id, net_id))
return
except Exception:
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
net_id = get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, NETWORK_OPENSTACK_TYPE)
subnet = create_object_dict(ctx,
SUBNET_OPENSTACK_TYPE,
args,
{NETWORK_ID: net_id})
s = neutron_client.create_subnet(
{SUBNET_OPENSTACK_TYPE: subnet})[SUBNET_OPENSTACK_TYPE]
set_neutron_runtime_properties(ctx, s, SUBNET_OPENSTACK_TYPE)
def create(keystone_client, args, **kwargs):
if use_external_resource(ctx, keystone_client, USER_OPENSTACK_TYPE):
return
user_dict = create_object_dict(ctx, USER_OPENSTACK_TYPE, args, {})
user = keystone_client.users.create(**user_dict)
set_openstack_runtime_properties(ctx, user, USER_OPENSTACK_TYPE)
def create(keystone_client, args, **kwargs):
if use_external_resource(ctx, keystone_client, PROJECT_OPENSTACK_TYPE):
return
project_dict = create_object_dict(ctx, PROJECT_OPENSTACK_TYPE, args,
{'domain': 'default'})
project = keystone_client.projects.create(**project_dict)
set_openstack_runtime_properties(ctx, project, PROJECT_OPENSTACK_TYPE)
def create(neutron_client, args, **kwargs):
if use_external_resource(ctx, neutron_client, NETWORK_OPENSTACK_TYPE):
return
network = create_object_dict(ctx, NETWORK_OPENSTACK_TYPE, args,
{ADMIN_STATE_UP: True})
net = neutron_client.create_network({NETWORK_OPENSTACK_TYPE:
network})[NETWORK_OPENSTACK_TYPE]
set_neutron_runtime_properties(ctx, net, NETWORK_OPENSTACK_TYPE)
def create(nova_client, args, **kwargs):
if use_external_resource(ctx, nova_client, SERVER_GROUP_OPENSTACK_TYPE):
return
server_grp = create_object_dict(
ctx, SERVER_GROUP_OPENSTACK_TYPE, args,
{'policies': [ctx.node.properties['policy']]})
server_grp = nova_client.server_groups.create(**server_grp)
set_openstack_runtime_properties(ctx, server_grp,
SERVER_GROUP_OPENSTACK_TYPE)
def create(nova_client, args, **kwargs):
if use_external_resource(ctx, nova_client, FLAVOR_OPENSTACK_TYPE):
return
flavor_dict = create_object_dict(ctx, FLAVOR_OPENSTACK_TYPE, args, {})
ctx.logger.info('Creating flavor: {0}'.format(flavor_dict))
flavor = nova_client.flavors.create(**flavor_dict)
set_openstack_runtime_properties(ctx, flavor, FLAVOR_OPENSTACK_TYPE)
_set_extra_specs(ctx, flavor)
_set_tenants_access(ctx, nova_client, flavor)
def update(nova_client, args, **kwargs):
host_aggregate_dict = create_object_dict(ctx,
HOST_AGGREGATE_OPENSTACK_TYPE,
args)
_remove_hosts(ctx, nova_client, get_openstack_id(ctx), kwargs)
host_aggregate = nova_client.aggregates.update(get_openstack_id(ctx),
host_aggregate_dict)
_add_hosts(ctx, nova_client, host_aggregate, kwargs)
_set_metadata(ctx, nova_client, host_aggregate, kwargs)
set_openstack_runtime_properties(ctx, host_aggregate,
HOST_AGGREGATE_OPENSTACK_TYPE)
def create(nova_client, args, **kwargs):
if use_external_resource(ctx, nova_client, HOST_AGGREGATE_OPENSTACK_TYPE):
return
host_aggregate_dict = create_object_dict(ctx,
HOST_AGGREGATE_OPENSTACK_TYPE,
args)
host_aggregate = nova_client.aggregates.create(**host_aggregate_dict)
_add_hosts(ctx, nova_client, host_aggregate, kwargs)
_set_metadata(ctx, nova_client, host_aggregate, kwargs)
set_openstack_runtime_properties(ctx, host_aggregate,
HOST_AGGREGATE_OPENSTACK_TYPE)
def create(neutron_client, args, **kwargs):
ext_port = use_external_resource(ctx, neutron_client, PORT_OPENSTACK_TYPE)
if ext_port:
try:
net_id = \
get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, NETWORK_OPENSTACK_TYPE, True)
if net_id:
port_id = get_openstack_id(ctx)
if neutron_client.show_port(
port_id)[PORT_OPENSTACK_TYPE]['network_id'] != net_id:
raise NonRecoverableError(
'Expected external resources port {0} and network {1} '
'to be connected'.format(port_id, net_id))
ctx.instance.runtime_properties[FIXED_IP_ADDRESS_PROPERTY] = \
_get_fixed_ip(ext_port)
ctx.instance.runtime_properties[MAC_ADDRESS_PROPERTY] = \
ext_port['mac_address']
return
except Exception:
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
net_id = ctx.node.properties.get(PORT_OPENSTACK_TYPE, {}).get('network_id')
if not net_id:
net_id = \
get_openstack_id_of_single_connected_node_by_openstack_type(
ctx, NETWORK_OPENSTACK_TYPE)
port = create_object_dict(ctx, PORT_OPENSTACK_TYPE, args,
{'network_id': net_id})
_handle_fixed_ips(port, neutron_client)
_handle_security_groups(port)
p = neutron_client.create_port({PORT_OPENSTACK_TYPE:
port})[PORT_OPENSTACK_TYPE]
set_neutron_runtime_properties(ctx, p, PORT_OPENSTACK_TYPE)
ctx.instance.runtime_properties[FIXED_IP_ADDRESS_PROPERTY] = \
_get_fixed_ip(p)
ctx.instance.runtime_properties[MAC_ADDRESS_PROPERTY] = p['mac_address']
def create(nova_client, args, **kwargs):
private_key_path = _get_private_key_path()
pk_exists = _check_private_key_exists(private_key_path)
if use_external_resource(ctx, nova_client, KEYPAIR_OPENSTACK_TYPE):
if not pk_exists:
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise NonRecoverableError(
'Failed to use external keypair (node {0}): the public key {1}'
' is available on Openstack, but the private key could not be '
'found at {2}'.format(ctx.node.id,
ctx.node.properties['resource_id'],
private_key_path))
return
if pk_exists:
raise NonRecoverableError(
"Can't create keypair - private key path already exists: {0}".
format(private_key_path))
keypair = create_object_dict(ctx, KEYPAIR_OPENSTACK_TYPE, args, {})
keypair = nova_client.keypairs.create(keypair['name'],
keypair.get('public_key'))
set_openstack_runtime_properties(ctx, keypair, KEYPAIR_OPENSTACK_TYPE)
try:
# write private key file
_mkdir_p(os.path.dirname(private_key_path))
with open(private_key_path, 'w') as f:
f.write(keypair.private_key)
os.chmod(private_key_path, 0600)
except Exception:
_delete_private_key_file()
delete_resource_and_runtime_properties(ctx, nova_client,
RUNTIME_PROPERTIES_KEYS)
raise
def create(glance_client, args, **kwargs):
if use_external_resource(ctx, glance_client, IMAGE_OPENSTACK_TYPE):
return
_validate_image_dictionary()
img_dict = create_object_dict(ctx, IMAGE_OPENSTACK_TYPE, args, {})
img_path = img_dict.pop('data', '')
img = glance_client.images.create(**img_dict)
img_url = ctx.node.properties.get('image_url')
try:
_validate_image()
if img_path:
with open(img_path, 'rb') as image_file:
glance_client.images.upload(image_id=img.id,
image_data=image_file)
elif img_url:
img = glance_client.images.add_location(img.id, img_url, {})
except Exception:
_remove_protected(glance_client)
glance_client.images.delete(image_id=img.id)
raise
set_openstack_runtime_properties(ctx, img, IMAGE_OPENSTACK_TYPE)
def update(glance_client, args, **kwargs):
image_dict = create_object_dict(ctx, IMAGE_OPENSTACK_TYPE, args)
image_dict[IMAGE_OPENSTACK_TYPE] = get_openstack_id(ctx)
image = glance_client.images.update(**image_dict)
set_openstack_runtime_properties(ctx, image, IMAGE_OPENSTACK_TYPE)
def update(keystone_client, args, **kwargs):
user_dict = create_object_dict(ctx, USER_OPENSTACK_TYPE, args, {})
user_dict[USER_OPENSTACK_TYPE] = get_openstack_id(ctx)
user = keystone_client.users.update(**user_dict)
set_openstack_runtime_properties(ctx, user, USER_OPENSTACK_TYPE)