def delete(nova_client, **kwargs):
if not is_external_resource(ctx):
ctx.logger.info('deleting server group')
nova_client.server_groups.delete(get_openstack_id(ctx))
else:
ctx.logger.info('not deleting server group since an external server '
'group is being used')
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def creation_validation(nova_client, **kwargs):
def validate_private_key_permissions(private_key_path):
ctx.logger.debug('checking whether private key file {0} has the '
'correct permissions'.format(private_key_path))
if not os.access(private_key_path, os.R_OK | os.W_OK):
err = 'private key file {0} is not readable and/or ' \
'writeable'.format(private_key_path)
ctx.logger.error('VALIDATION ERROR: ' + err)
raise NonRecoverableError(err)
ctx.logger.debug('OK: private key file {0} has the correct '
'permissions'.format(private_key_path))
def validate_path_owner(path):
ctx.logger.debug('checking whether directory {0} is owned by the '
'current user'.format(path))
from pwd import getpwnam, getpwuid
user = getuser()
owner = getpwuid(os.stat(path).st_uid).pw_name
current_user_id = str(getpwnam(user).pw_uid)
owner_id = str(os.stat(path).st_uid)
if not current_user_id == owner_id:
err = '{0} is not owned by the current user (it is owned by {1})'\
.format(path, owner)
ctx.logger.error('VALIDATION ERROR: ' + err)
raise NonRecoverableError(err)
ctx.logger.debug('OK: {0} is owned by the current user'.format(path))
validate_resource(ctx, nova_client, KEYPAIR_OPENSTACK_TYPE)
private_key_path = _get_private_key_path()
pk_exists = _check_private_key_exists(private_key_path)
if is_external_resource(ctx):
if pk_exists:
if platform.system() == 'Linux':
validate_private_key_permissions(private_key_path)
validate_path_owner(private_key_path)
else:
err = "can't use external keypair: the public key {0} is " \
"available on Openstack, but the private key could not be " \
"found at {1}".format(ctx.node.properties['resource_id'],
private_key_path)
ctx.logger.error('VALIDATION ERROR: ' + err)
raise NonRecoverableError(err)
else:
if pk_exists:
err = 'private key path already exists: {0}'.format(
private_key_path)
ctx.logger.error('VALIDATION ERROR: ' + err)
raise NonRecoverableError(err)
ctx.logger.debug('OK: keypair configuration is valid')
def delete(nova_client, **kwargs):
if not is_external_resource(ctx):
ctx.logger.info('deleting server')
server = get_server_by_context(nova_client)
nova_client.servers.delete(server)
_wait_for_server_to_be_deleted(nova_client, server)
else:
ctx.logger.info('not deleting server since an external server is '
'being used')
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def stop(neutron_client, **kwargs):
if is_external_resource(ctx):
ctx.logger.info('Not stopping network since an external network is '
'being used')
return
neutron_client.update_network(
get_openstack_id(ctx),
{NETWORK_OPENSTACK_TYPE: {
ADMIN_STATE_UP: False
}})
def delete(nova_client, **kwargs):
if not is_external_resource(ctx):
ctx.logger.info('deleting server')
server = get_server_by_context(nova_client)
nova_client.servers.delete(server)
_wait_for_server_to_be_deleted(nova_client, server)
else:
ctx.logger.info('not deleting server since an external server is '
'being used')
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def stop(neutron_client, **kwargs):
if is_external_resource(ctx):
ctx.logger.info('Not stopping network since an external network is '
'being used')
return
neutron_client.update_network(
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY],
{'network': {
'admin_state_up': False
}})
def delete(nova_client, **kwargs):
if not is_external_resource(ctx):
ctx.logger.info('deleting server group')
nova_client.server_groups.delete(
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY])
else:
ctx.logger.info('not deleting server group since an external server '
'group is being used')
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def creation_validation(nova_client, **kwargs):
def validate_private_key_permissions(private_key_path):
ctx.logger.debug('checking whether private key file {0} has the '
'correct permissions'.format(private_key_path))
if not os.access(private_key_path, os.R_OK | os.W_OK):
err = 'private key file {0} is not readable and/or ' \
'writeable'.format(private_key_path)
ctx.logger.error('VALIDATION ERROR: ' + err)
raise NonRecoverableError(err)
ctx.logger.debug('OK: private key file {0} has the correct '
'permissions'.format(private_key_path))
def validate_path_owner(path):
ctx.logger.debug('checking whether directory {0} is owned by the '
'current user'.format(path))
from pwd import getpwnam, getpwuid
user = getuser()
owner = getpwuid(os.stat(path).st_uid).pw_name
current_user_id = str(getpwnam(user).pw_uid)
owner_id = str(os.stat(path).st_uid)
if not current_user_id == owner_id:
err = '{0} is not owned by the current user (it is owned by {1})'\
.format(path, owner)
ctx.logger.error('VALIDATION ERROR: ' + err)
raise NonRecoverableError(err)
ctx.logger.debug('OK: {0} is owned by the current user'.format(path))
validate_resource(ctx, nova_client, KEYPAIR_OPENSTACK_TYPE)
private_key_path = _get_private_key_path()
pk_exists = _check_private_key_exists(private_key_path)
if is_external_resource(ctx):
if pk_exists:
if platform.system() == 'Linux':
validate_private_key_permissions(private_key_path)
validate_path_owner(private_key_path)
else:
err = "can't use external keypair: the public key {0} is " \
"available on Openstack, but the private key could not be " \
"found at {1}".format(ctx.node.properties['resource_id'],
private_key_path)
ctx.logger.error('VALIDATION ERROR: ' + err)
raise NonRecoverableError(err)
else:
if pk_exists:
err = 'private key path already exists: {0}'.format(
private_key_path)
ctx.logger.error('VALIDATION ERROR: ' + err)
raise NonRecoverableError(err)
ctx.logger.debug('OK: keypair configuration is valid')
def delete(nova_client, **kwargs):
if not is_external_resource(ctx):
host_aggregate = nova_client.aggregates.get(get_openstack_id(ctx))
_remove_hosts(ctx, nova_client, get_openstack_id(ctx),
host_aggregate.hosts)
if HOSTS_PROPERTY in ctx.instance.runtime_properties:
ctx.instance.runtime_properties.pop(HOSTS_PROPERTY, None)
delete_resource_and_runtime_properties(ctx, nova_client,
RUNTIME_PROPERTIES_KEYS)
def delete(nova_client, **kwargs):
if not is_external_resource(ctx):
ctx.logger.info('deleting keypair')
_delete_private_key_file()
nova_client.keypairs.delete(get_openstack_id(ctx))
else:
ctx.logger.info('not deleting keypair since an external keypair is '
'being used')
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def stop(neutron_client, **kwargs):
if is_external_resource(ctx):
ctx.logger.info('Not stopping network since an external network is '
'being used')
return
neutron_client.update_network(
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY], {
'network': {
'admin_state_up': False
}
})
def stop(nova_client, **kwargs):
"""
Stop server.
Depends on OpenStack implementation, server.stop() might not be supported.
"""
if is_external_resource(ctx):
ctx.logger.info('Not stopping server since an external server is '
'being used')
return
server = get_server_by_context(nova_client)
_server_stop(nova_client, server)
def delete(nova_client, **kwargs):
if not is_external_resource(ctx):
ctx.logger.info('deleting keypair')
_delete_private_key_file()
nova_client.keypairs.delete(
ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY])
else:
ctx.logger.info('not deleting keypair since an external keypair is '
'being used')
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def start(nova_client, start_retry_interval, private_key_path, **kwargs):
server = get_server_by_context(nova_client)
if is_external_resource(ctx):
ctx.logger.info('Validating external server is started')
if server.status != SERVER_STATUS_ACTIVE:
raise NonRecoverableError(
'Expected external resource server {0} to be in '
'"{1}" status'.format(server.id, SERVER_STATUS_ACTIVE))
return
if server.status == SERVER_STATUS_ACTIVE:
ctx.logger.info('Server is {0}'.format(server.status))
if ctx.node.properties['use_password']:
private_key = _get_private_key(private_key_path)
ctx.logger.debug('retrieving password for server')
password = server.get_password(private_key)
if not password:
return ctx.operation.retry(
message='Waiting for server to post generated password',
retry_after=start_retry_interval)
ctx.instance.runtime_properties[ADMIN_PASSWORD_PROPERTY] = password
ctx.logger.info('Server has been set with a password')
_set_network_and_ip_runtime_properties(server)
return
server_task_state = getattr(server, OS_EXT_STS_TASK_STATE)
if server.status == SERVER_STATUS_SHUTOFF and \
server_task_state != SERVER_TASK_STATE_POWERING_ON:
ctx.logger.info('Server is in {0} status - starting server...'.format(
SERVER_STATUS_SHUTOFF))
server.start()
server_task_state = SERVER_TASK_STATE_POWERING_ON
if server.status == SERVER_STATUS_BUILD or \
server_task_state == SERVER_TASK_STATE_POWERING_ON:
return ctx.operation.retry(
message='Waiting for server to be in {0} state but is in {1}:{2} '
'state. Retrying...'.format(SERVER_STATUS_ACTIVE,
server.status,
server_task_state),
retry_after=start_retry_interval)
raise NonRecoverableError(
'Unexpected server state {0}:{1}'.format(server.status,
server_task_state))
def start(nova_client, start_retry_interval, private_key_path, **kwargs):
server = get_server_by_context(nova_client)
if is_external_resource(ctx):
ctx.logger.info('Validating external server is started')
if server.status != SERVER_STATUS_ACTIVE:
raise NonRecoverableError(
'Expected external resource server {0} to be in '
'"{1}" status'.format(server.id, SERVER_STATUS_ACTIVE))
return
if server.status == SERVER_STATUS_ACTIVE:
ctx.logger.info('Server is {0}'.format(server.status))
if ctx.node.properties['use_password']:
private_key = _get_private_key(private_key_path)
ctx.logger.debug('retrieving password for server')
password = server.get_password(private_key)
if not password:
return ctx.operation.retry(
message='Waiting for server to post generated password',
retry_after=start_retry_interval)
ctx.instance.runtime_properties[ADMIN_PASSWORD_PROPERTY] = password
ctx.logger.info('Server has been set with a password')
_set_network_and_ip_runtime_properties(server)
return
server_task_state = getattr(server, OS_EXT_STS_TASK_STATE)
if server.status == SERVER_STATUS_SHUTOFF and \
server_task_state != SERVER_TASK_STATE_POWERING_ON:
ctx.logger.info('Server is in {0} status - starting server...'.format(
SERVER_STATUS_SHUTOFF))
server.start()
server_task_state = SERVER_TASK_STATE_POWERING_ON
if server.status == SERVER_STATUS_BUILD or \
server_task_state == SERVER_TASK_STATE_POWERING_ON:
return ctx.operation.retry(
message='Waiting for server to be in {0} state but is in {1}:{2} '
'state. Retrying...'.format(SERVER_STATUS_ACTIVE,
server.status,
server_task_state),
retry_after=start_retry_interval)
raise NonRecoverableError(
'Unexpected server state {0}:{1}'.format(server.status,
server_task_state))
def start(nova_client, **kwargs):
server = get_server_by_context(nova_client)
if is_external_resource(ctx):
ctx.logger.info('Validating external server is started')
if server.status != SERVER_STATUS_ACTIVE:
raise NonRecoverableError(
'Expected external resource server {0} to be in '
'"{1}" status'.format(server.id, SERVER_STATUS_ACTIVE))
return
if server.status not in (SERVER_STATUS_ACTIVE, SERVER_STATUS_BUILD):
server.start()
else:
ctx.logger.info('Server is already started')
def stop(nova_client, **kwargs):
"""
Stop server.
Depends on OpenStack implementation, server.stop() might not be supported.
"""
if is_external_resource(ctx):
ctx.logger.info('Not stopping server since an external server is '
'being used')
return
server = get_server_by_context(nova_client)
if server.status != SERVER_STATUS_SHUTOFF:
nova_client.servers.stop(server)
else:
ctx.logger.info('Server is already stopped')
def stop(nova_client, **kwargs):
"""
Stop server.
Depends on OpenStack implementation, server.stop() might not be supported.
"""
if is_external_resource(ctx):
ctx.logger.info('Not stopping server since an external server is '
'being used')
return
server = get_server_by_context(nova_client)
if server.status != SERVER_STATUS_SHUTOFF:
nova_client.servers.stop(server)
else:
ctx.logger.info('Server is already stopped')
def start(neutron_client, **kwargs):
network_id = ctx.instance.runtime_properties[OPENSTACK_ID_PROPERTY]
if is_external_resource(ctx):
ctx.logger.info('Validating external network is started')
if not neutron_client.show_network(
network_id)['network']['admin_state_up']:
raise NonRecoverableError(
'Expected external resource network {0} to be in '
'"admin_state_up"=True'.format(network_id))
return
neutron_client.update_network(
network_id, {
'network': {
'admin_state_up': True
}
})
def delete(nova_client, **kwargs):
if not is_external_resource(ctx):
_remove_hosts(ctx, nova_client, get_openstack_id(ctx), kwargs)
delete_resource_and_runtime_properties(ctx, nova_client,
RUNTIME_PROPERTIES_KEYS)
