def disconnect_network(ctx, **kwargs):
cloud_driver = get_cloud_driver(ctx)
fip_id = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
fip = get_floating_ip_by_id(ctx, cloud_driver, fip_id)
firewall_rules = [rule for rule in cloud_driver.ex_list_firewall_rules()
if fip.id == rule.address.id]
for rule in firewall_rules:
ctx.logger.info('Deleting fw rule: {3}:{0}:{1}-{2}'.format(
rule.cidr_list, rule.start_port, rule.end_port, rule.protocol))
cloud_driver.ex_delete_firewall_rule(rule)
ctx.logger.info('Deleting floating ip: {0}'.format(fip))
try:
cloud_driver.ex_release_public_ip(address=fip)
except Exception as e:
ctx.logger.warn('Floating IP: {0} may not have been deleted: {1}'
.format(fip, str(e)))
pass
def delete_vpn_customer_gateway(**kwargs):
"""
Deletes a VPN Customer Gateway.
"""
cloud_driver = get_cloud_driver(ctx)
id_ = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
vpn_customer_gateway = get_vpn_customer_gateway(cloud_driver, id_)
if not vpn_customer_gateway:
raise NonRecoverableError(
'Could not find VPN Customer Gateway with id={0}'.format(id_))
use_external = ctx.source.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if not use_external:
for obj in get_vpn_connections():
if obj.vpn_customer_gateway_id == id_:
raise NonRecoverableError(
'Could not delete VPN Customer Gateway id={0} because '
'of VPN Connection id={1}'.format(id_, obj.id))
vpn_customer_gateway.delete()
ctx.logger.info('Deleted VPN Customer Gateway id={0}'.format(id_))
else:
ctx.logger.info(
'Did not delete VPN Customer Gateway id={0}'.format(id_))
def delete(ctx, **kwargs):
ctx.logger.info("Initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
server_config = ctx.node.properties['server']
expunge = server_config.get(['expunge'][0], False)
cloud_driver = get_cloud_driver(ctx)
instance_id = ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
if instance_id is None:
raise NameError('Could not find node ID in runtime context: {0} '
.format(instance_id))
node = get_vm_by_id(ctx, cloud_driver, instance_id)
if node is None:
raise NameError('Could not find node with ID: {0} '
.format(instance_id))
ctx.logger.info('destroying vm: {0} expunge {1}'.format(node.name,
expunge))
cloud_driver.destroy_node(node)
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def delete(ctx, **kwargs):
network_name = ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY]
cloud_driver = get_cloud_driver(ctx)
network = get_network(cloud_driver, network_name)
if not ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY] is True:
# firewall_rules = [rule for rule in cloud_driver.
# ex_list_egress_firewall_rules() if
# network.id == rule.network_id]
#
# for rule in firewall_rules:
#
# ctx.logger.info('Deleting egress fw rule: {3}:{0}:{1}-{2} '
# 'from network: {4}'.format(
# rule.cidr_list, rule.start_port, rule.end_port,
# rule.protocol, network_name))
#
# cloud_driver.ex_delete_egress_firewall_rule(rule)
try:
cloud_driver.ex_delete_network(network)
except Exception as e:
ctx.logger.warn('Network {0} may not have been deleted: {1}'
.format(network_name, str(e)))
return False
pass
else:
ctx.logger.info('This is an external resource only removing '
'runtime props')
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
return True
def connect_network(ctx, **kwargs):
cloud_driver = get_cloud_driver(ctx)
network_id = ctx.related.runtime_properties['network_id']
network = get_network_by_id(ctx, cloud_driver, network_id)
if network.extra['vpc_id'] is not None:
ctx.logger.info('Acquiring IP for VPC with id: {0}'
.format(network.extra['vpc_id']))
fip = cloud_driver.ex_allocate_public_ip(vpc_id=
network.extra['vpc_id'])
elif network.id is not None:
ctx.logger.info('Acquiring IP for network with id: {0}'.
format(network.id))
fip = cloud_driver.ex_allocate_public_ip(network_id=network.id)
else:
raise NonRecoverableError('Cannot resolve network or vpc id')
ctx.runtime_properties['external_id'] = fip.id
ctx.runtime_properties['external_type'] = 'publicip'
ctx.runtime_properties['floating_ip_address'] = fip.address
def get_state(ctx, **kwargs):
ctx.logger.info("initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
instance_id = ctx.runtime_properties['instance_id']
networking_type = ctx.runtime_properties['networking_type']
ctx.logger.info('getting node with ID {0}'.format(instance_id))
node = get_node_by_id(ctx, cloud_driver, instance_id)
if node is None:
return False
if networking_type == 'network':
ctx.runtime_properties['ip'] = node.private_ips[0]
#ctx.runtime_properties['ip_address'] = node.private_ips[0]
ctx.logger.info('instance started successfully with IP {0}'
.format(ctx.runtime_properties['ip']))
return True
elif networking_type == 'security_group':
ctx.runtime.properties['ip'] = node.public_ips[0]
ctx.logger.info('instance started successfully with IP {0}'
.format(ctx.runtime_properties['ip']))
return True
else:
ctx.runtime_properties['ip'] = node.private_ips[0]
ctx.logger.info('Cannot determine networking type,'
' using private_ip as {0} ip'
.format(ctx.runtime_properties['ip']))
return True
def disconnect_floating_ip(ctx, **kwargs):
cloud_driver = get_cloud_driver(ctx)
node_id = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
node = get_vm_by_id(ctx, cloud_driver, node_id)
portmaps = get_portmaps_by_vm_id(ctx, cloud_driver, node_id)
for portmap in portmaps:
try:
ctx.logger.info('Deleting portmap for node: {0}:{1}-{2} on'
' {3}:{4}-{5}'.
format(node.name, portmap.private_port,
portmap.private_end_port,
portmap.address, portmap.public_port,
portmap.public_end_port))
cloud_driver.ex_delete_port_forwarding_rule(node=node,
rule=portmap)
except Exception as e:
ctx.logger.warn('Port forward may not have been removed: '
'{0}'.format(str(e)))
return False
return True
def delete(ctx, **kwargs):
ctx.logger.info("Initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
server_config = ctx.node.properties['server']
expunge = server_config.get(['expunge'][0], False)
cloud_driver = get_cloud_driver(ctx)
instance_id = ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
if instance_id is None:
raise NameError('Could not find node ID in runtime context: {0} '
.format(instance_id))
node = get_vm_by_id(ctx, cloud_driver, instance_id)
if node is None:
raise NameError('Could not find node with ID: {0} '
.format(instance_id))
ctx.logger.info('destroying vm: {0} expunge {1}'.format(node.name,
expunge))
cloud_driver.destroy_node(node)
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def disconnect_floating_ip(ctx, **kwargs):
cloud_driver = get_cloud_driver(ctx)
node_id = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
node = get_vm_by_id(ctx, cloud_driver, node_id)
portmaps = get_portmaps_by_vm_id(ctx, cloud_driver, node_id)
for portmap in portmaps:
try:
ctx.logger.info('Deleting portmap for node: {0}:{1}-{2} on'
' {3}:{4}-{5}'.
format(node.name, portmap.private_port,
portmap.private_end_port,
portmap.address, portmap.public_port,
portmap.public_end_port))
cloud_driver.ex_delete_port_forwarding_rule(node=node,
rule=portmap)
except Exception as e:
ctx.logger.warn('Port forward may not have been removed: '
'{0}'.format(str(e)))
return False
return True
def delete_vpn_customer_gateway(**kwargs):
"""
Deletes a VPN Customer Gateway.
"""
cloud_driver = get_cloud_driver(ctx)
id_ = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
vpn_customer_gateway = get_vpn_customer_gateway(cloud_driver, id_)
if not vpn_customer_gateway:
raise NonRecoverableError("Could not find VPN Customer Gateway with id={0}".format(id_))
use_external = ctx.source.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if not use_external:
for obj in get_vpn_connections():
if obj.vpn_customer_gateway_id == id_:
raise NonRecoverableError(
"Could not delete VPN Customer Gateway id={0} because "
"of VPN Connection id={1}".format(id_, obj.id)
)
vpn_customer_gateway.delete()
ctx.logger.info("Deleted VPN Customer Gateway id={0}".format(id_))
else:
ctx.logger.info("Did not delete VPN Customer Gateway id={0}".format(id_))
def create_vpn_customer_gateway(**kwargs):
"""
Creates a VPN Customer Gateway.
"""
cloud_driver = get_cloud_driver(ctx)
vpn_gateway = get_vpn_gateway(
cloud_driver,
ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY],
)
if not vpn_gateway:
raise NonRecoverableError('Could not find VPN Gateway id={0}'.format(
ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]))
try:
id_ = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
except KeyError:
id_ = None
exists = vpn_customer_gateway_exists(cloud_driver, id_)
use_external = ctx.source.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if (not exists) and (not use_external):
data = {
'cidr_list': ctx.source.node.properties['cidr_list'],
'dpd': ctx.source.node.properties['dpd'],
'esp_lifetime': ctx.source.node.properties['esp_lifetime'],
'esp_policy': ctx.source.node.properties['esp_policy'],
'gateway': vpn_gateway.public_ip,
'ike_lifetime': ctx.source.node.properties['ike_lifetime'],
'ike_policy': ctx.source.node.properties['ike_policy'],
'ipsec_psk': ctx.source.node.properties['ipsec_psk'],
}
vpn_customer_gateway = cloud_driver.ex_create_vpn_customer_gateway(
**data)
ctx.logger.info(
'Created VPN Customer Gateway id={0} vpn_gateway_id={1}'.format(
vpn_customer_gateway.id, vpn_gateway.id))
elif exists and use_external:
vpn_customer_gateway = get_vpn_customer_gateway(cloud_driver, id_)
ctx.logger.info('Using VPN Customer Gateway id={0}'.format(
vpn_customer_gateway.id))
elif exists and (not use_external):
raise NonRecoverableError(
'VPN Customer Gateway already exists id={0}'.format(id_))
elif (not exists) and use_external:
raise NonRecoverableError(
'Could not find VPN Customer Gateway id={0}'.format(id_))
ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = \
vpn_customer_gateway.id
ctx.source.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
VPN_CUSTOMER_GATEWAY_CLOUDSTACK_TYPE
def get_state(ctx, **kwargs):
ctx.logger.info("initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
instance_id = ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
networking_type = ctx.instance.runtime_properties[
NETWORKINGTYPE_CLOUDSTACK_TYPE]
node = get_vm_by_id(ctx, cloud_driver, instance_id)
if node is None:
return False
if networking_type == 'network':
if ctx.node.properties['management_network_name']:
ctx.logger.info('Management network defined: {0}'
.format(ctx.node.properties[
'management_network_name']))
mgt_net = get_network(cloud_driver, ctx.node.properties[
'management_network_name'])
nic = get_nic_by_node_and_network_id(ctx, cloud_driver, node,
mgt_net.id)
ctx.logger.info('CFY will use {0} for management,'
' overwriting previously set value'
.format(nic))
ctx.instance.runtime_properties[IP_PROPERTY] = nic.ip_address
return True
else:
ctx.instance.runtime_properties[IP_PROPERTY] = node.private_ips[0]
ctx.logger.info('VM {1} started successfully with IP {0}'
.format(ctx.instance.runtime_properties[
IP_PROPERTY],
ctx.instance.runtime_properties[
CLOUDSTACK_NAME_PROPERTY]))
return True
elif networking_type == 'security_group':
ctx.runtime.properties[IP_PROPERTY] = node.public_ips[0]
ctx.logger.info('instance started successfully with IP {0}'
.format(ctx.instance.runtime_properties[IP_PROPERTY]))
return True
else:
ctx.instance.runtime_properties[IP_PROPERTY] = node.private_ips[0]
ctx.logger.info('Cannot determine networking type,'
' using private_ip as {0} ip'
.format(ctx.instance.runtime_properties[IP_PROPERTY]))
return True
def get_state(ctx, **kwargs):
ctx.logger.info("initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
instance_id = ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
networking_type = ctx.instance.runtime_properties[
NETWORKINGTYPE_CLOUDSTACK_TYPE]
node = get_vm_by_id(ctx, cloud_driver, instance_id)
if node is None:
return False
if networking_type == 'network':
if ctx.node.properties['management_network_name']:
ctx.logger.info('Management network defined: {0}'
.format(ctx.node.properties[
'management_network_name']))
mgt_net = get_network(cloud_driver, ctx.node.properties[
'management_network_name'])
nic = get_nic_by_node_and_network_id(ctx, cloud_driver, node,
mgt_net.id)
ctx.logger.info('CFY will use {0} for management,'
' overwriting previously set value'
.format(nic))
ctx.instance.runtime_properties[IP_PROPERTY] = nic.ip_address
return True
else:
ctx.instance.runtime_properties[IP_PROPERTY] = node.private_ips[0]
ctx.logger.info('VM {1} started successfully with IP {0}'
.format(ctx.instance.runtime_properties[IP_PROPERTY],
ctx.instance.runtime_properties[
CLOUDSTACK_NAME_PROPERTY]))
return True
elif networking_type == 'security_group':
ctx.runtime.properties[IP_PROPERTY] = node.public_ips[0]
ctx.logger.info('instance started successfully with IP {0}'
.format(ctx.instance.runtime_properties[IP_PROPERTY]))
return True
else:
ctx.instance.runtime_properties[IP_PROPERTY] = node.private_ips[0]
ctx.logger.info('Cannot determine networking type,'
' using private_ip as {0} ip'
.format(ctx.instance.runtime_properties[IP_PROPERTY]))
return True
def connect_network(ctx, **kwargs):
cloud_driver = get_cloud_driver(ctx)
network_id = ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
network = get_network_by_id(ctx, cloud_driver, network_id)
#firewall_rules = ctx.node.target.properties.get(['firewall'][0], None)
if network.extra['vpc_id'] is not None:
ctx.logger.info('Acquiring IP for VPC with id: {0}'
.format(network.extra['vpc_id']))
fip = cloud_driver.ex_allocate_public_ip(vpc_id=
network.extra['vpc_id'])
elif network.id is not None:
ctx.logger.info('Acquiring IP for network with id: {0}'.
format(network.id))
fip = cloud_driver.ex_allocate_public_ip(network_id=network.id)
if 'firewall' in ctx.target.node.properties:
firewall_config = ctx.target.node.properties['firewall']
ingress_rules = [rule for rule in firewall_config if
rule['type'] == 'ingress']
for rule in ingress_rules:
rule_cidr = rule.get('cidr')
rule_protocol = rule.get('protocol')
rule_ports = rule.get('ports')
for port in rule_ports:
ctx.logger.info('Creating ingress fw rule:'
' {3}:{0}:{1}-{2}'
.format(rule_cidr,
port,
port,
rule_protocol))
cloud_driver.ex_create_firewall_rule(
address=fip,
cidr_list=rule_cidr,
protocol=rule_protocol,
start_port=port,
end_port=port
)
else:
raise NonRecoverableError('Cannot resolve network or vpc id')
ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = fip.id
ctx.source.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
FLOATINGIP_CLOUDSTACK_TYPE
ctx.source.instance.runtime_properties[IP_ADDRESS_PROPERTY] = fip.address
def delete(ctx, **kwargs):
try:
cloud_driver = get_cloud_driver(ctx)
cloud_driver.ex_delete_security_group(
ctx.runtime_properties['external_id'])
except:
ctx.logger.warn('security-group {0} may not have been deleted'.format(
ctx.runtime_properties['external_id']))
pass
def create(**kwargs):
""" Create a volume
"""
cloud_driver = get_cloud_driver(ctx)
volume = {}
if ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY] is False:
ctx.logger.debug('reading volume attributes.')
volume.update(copy.deepcopy(ctx.node.properties['volume']))
if 'name' in volume:
volume_name = volume['name']
else:
raise NonRecoverableError("To create a volume, the name of the "
"volume is needed")
if 'size' in volume:
volume_size = volume['size']
else:
raise NonRecoverableError("To create a volume, the size of the "
"volume is needed")
volume = cloud_driver.create_volume(name=volume_name,
size=volume_size)
if volume_exists(cloud_driver, volume.id):
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = volume.id
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
VOLUME_CLOUDSTACK_TYPE
else:
raise NonRecoverableError("Volume not created")
elif ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY] is True:
if ctx.node.properties['resource_id']:
resource_id = ctx.node.properties['resource_id']
volume = get_volume_by_id(cloud_driver, resource_id)
if volume is not None:
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = \
volume.id
ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY] = \
volume.name
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
VOLUME_CLOUDSTACK_TYPE
else:
raise NonRecoverableError("Could not find volume with id {0}".
format(resource_id))
else:
raise NonRecoverableError("Resource_id for volume is not supplied")
return
def connect_network(ctx, **kwargs):
cloud_driver = get_cloud_driver(ctx)
network_id = ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
network = get_network_by_id(ctx, cloud_driver, network_id)
if network.extra['vpc_id'] is not None:
ctx.logger.info('Acquiring IP for VPC with id: {0}'
.format(network.extra['vpc_id']))
fip = cloud_driver.ex_allocate_public_ip(
vpc_id=network.extra['vpc_id'])
elif network.id is not None:
ctx.logger.info('Acquiring IP for network with id: {0}'.
format(network.id))
fip = cloud_driver.ex_allocate_public_ip(network_id=network.id)
if 'firewall' in ctx.target.node.properties:
firewall_config = ctx.target.node.properties['firewall']
ingress_rules = [rule for rule in firewall_config
if rule['type'] == 'ingress']
for rule in ingress_rules:
rule_cidr = rule.get('cidr')
rule_protocol = rule.get('protocol')
rule_ports = rule.get('ports')
for port in rule_ports:
ctx.logger.info('Creating ingress fw rule:'
' {3}:{0}:{1}-{2}'
.format(rule_cidr,
port,
port,
rule_protocol))
cloud_driver.ex_create_firewall_rule(
address=fip,
cidr_list=rule_cidr,
protocol=rule_protocol,
start_port=port,
end_port=port
)
else:
raise NonRecoverableError('Cannot resolve network or vpc id')
ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = fip.id
ctx.source.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
FLOATINGIP_CLOUDSTACK_TYPE
ctx.source.instance.runtime_properties[IP_ADDRESS_PROPERTY] = fip.address
def delete(ctx, **kwargs):
try:
cloud_driver = get_cloud_driver(ctx)
cloud_driver.ex_delete_security_group(
ctx.instance.runtime_properties['external_id'])
except:
ctx.logger.warn(
'security-group {0} may not have been deleted'.format(
ctx.instance.runtime_properties['external_id']))
pass
def disconnect_network(ctx, **kwargs):
cloud_driver = get_cloud_driver(ctx)
fip_id = ctx.runtime_properties['external_id']
fip = get_floating_ip_by_id(ctx, cloud_driver, fip_id)
ctx.logger.info('Deleting floating ip: {0}'.format(fip))
cloud_driver.ex_release_public_ip(address=fip)
def create(**kwargs):
""" Create a volume
"""
cloud_driver = get_cloud_driver(ctx)
volume = {}
if ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY] is False:
ctx.logger.debug('reading volume attributes.')
volume.update(copy.deepcopy(ctx.node.properties['volume']))
if 'name' in volume:
volume_name = volume['name']
else:
raise NonRecoverableError("To create a volume, the name of the "
"volume is needed")
if 'size' in volume:
volume_size = volume['size']
else:
raise NonRecoverableError("To create a volume, the size of the "
"volume is needed")
volume = cloud_driver.create_volume(name=volume_name, size=volume_size)
if volume_exists(cloud_driver, volume.id):
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = volume.id
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
VOLUME_CLOUDSTACK_TYPE
else:
raise NonRecoverableError("Volume not created")
elif ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY] is True:
if ctx.node.properties['resource_id']:
resource_id = ctx.node.properties['resource_id']
volume = get_volume_by_id(cloud_driver, resource_id)
if volume is not None:
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = \
volume.id
ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY] = \
volume.name
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
VOLUME_CLOUDSTACK_TYPE
else:
raise NonRecoverableError(
"Could not find volume with id {0}".format(resource_id))
else:
raise NonRecoverableError("Resource_id for volume is not supplied")
return
def create_vpn_connection(**kwargs):
"""
Creates a VPN Connection.
"""
cloud_driver = get_cloud_driver(ctx)
vpn_gateway_id = kwargs.get("vpn_gateway_id")
vpn_customer_gateway_id = kwargs.get("vpn_customer_gateway_id")
vpn_gateway = get_vpn_gateway(cloud_driver, vpn_gateway_id)
if not vpn_gateway:
raise NonRecoverableError("Could not find VPN Gateway id={0}".format(vpn_gateway_id))
vpn_customer_gateway = get_vpn_customer_gateway(cloud_driver, vpn_customer_gateway_id)
if not vpn_customer_gateway:
raise NonRecoverableError("Could not find VPN Customer Gateway id={0}".format(vpn_customer_gateway_id))
try:
id_ = ctx.node.properties["resource_id"]
except KeyError:
id_ = None
exists = get_vpn_connection(cloud_driver, id_)
use_external = ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if (not exists) and (not use_external):
if not are_vpc_routers_running(cloud_driver, vpn_gateway.vpc_id):
return ctx.operation.retry(message="VPC Routers not running, waiting...", retry_after=5)
vpn_connection = cloud_driver.ex_create_vpn_connection(
vpn_customer_gateway=vpn_customer_gateway, vpn_gateway=vpn_gateway, passive=ctx.node.properties["passive"]
)
ctx.logger.info(
"Created VPN Connection id={0} for VPN Gateway "
"id={1} and VPN Customer Gateway id={2}".format(vpn_connection.id, vpn_gateway.id, vpn_customer_gateway.id)
)
elif exists and use_external:
vpn_connection = get_vpn_connection(cloud_driver, id_)
if not vpn_connection:
raise NonRecoverableError("Could not find VPN Connection id={0}".format(id_))
elif exists and (not use_external):
raise NonRecoverableError("VPN Connection id={0} already exists".format(exists.id))
elif (not exists) and use_external:
raise NonRecoverableError("Could not find VPN Connection id={0}".format(id_))
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = vpn_connection.id
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = VPN_CONNECTION_CLOUDSTACK_TYPE
def delete(ctx, **kwargs):
vpc_name = ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY]
cloud_driver = get_cloud_driver(ctx)
vpc = get_vpc(cloud_driver, vpc_name)
try:
cloud_driver.ex_delete_vpc(vpc)
except Exception as e:
ctx.logger.warn('vpc {0} may not have been deleted: {1}'.format(
vpc.name, str(e)))
pass
def delete(ctx, **kwargs):
vpc_name = ctx.runtime_properties['vpc_name']
cloud_driver = get_cloud_driver(ctx)
vpc = get_vpc(cloud_driver, vpc_name)
try:
cloud_driver.ex_delete_vpc(vpc)
except:
ctx.logger.warn('vpc {0} may not have been deleted'.format(
ctx.runtime_properties['vpc_name']))
pass
def delete(ctx, **kwargs):
vpc_name = ctx.runtime_properties['vpc_name']
cloud_driver = get_cloud_driver(ctx)
vpc = get_vpc(cloud_driver, vpc_name)
try:
cloud_driver.ex_delete_vpc(vpc)
except:
ctx.logger.warn(
'vpc {0} may not have been deleted'
.format(ctx.runtime_properties['vpc_name']))
pass
def detach_volume(ctx, **kwargs):
'''Detaches a volume and deletes if expunge is requested.'''
cloud_driver = get_cloud_driver(ctx)
volume_id = ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
volume = get_volume_by_id(cloud_driver, volume_id)
if not volume:
raise NonRecoverableError('Volume with id {0} not found'.format(
volume_id))
ctx.logger.info('Detaching volume {0}'.format(volume))
cloud_driver.detach_volume(volume=volume)
def delete(ctx, **kwargs):
vpc_name = ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY]
cloud_driver = get_cloud_driver(ctx)
vpc = get_vpc(cloud_driver, vpc_name)
try:
cloud_driver.ex_delete_vpc(vpc)
except Exception as e:
ctx.logger.warn(
'vpc {0} may not have been deleted: {1}'
.format(vpc.name, str(e)))
pass
def detach_volume(ctx, **kwargs):
'''Detaches a volume and deletes if expunge is requested.'''
cloud_driver = get_cloud_driver(ctx)
volume_id = ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
volume = get_volume_by_id(cloud_driver, volume_id)
if not volume:
raise NonRecoverableError('Volume with id {0} not found'.format(
volume_id))
ctx.logger.info('Detaching volume {0}'.format(volume))
cloud_driver.detach_volume(volume=volume)
def create_vpn_customer_gateway(**kwargs):
"""
Creates a VPN Customer Gateway.
"""
cloud_driver = get_cloud_driver(ctx)
vpn_gateway = get_vpn_gateway(cloud_driver, ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY])
if not vpn_gateway:
raise NonRecoverableError(
"Could not find VPN Gateway id={0}".format(ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY])
)
try:
id_ = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
except KeyError:
id_ = None
exists = vpn_customer_gateway_exists(cloud_driver, id_)
use_external = ctx.source.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if (not exists) and (not use_external):
data = {
"cidr_list": ctx.source.node.properties["cidr_list"],
"dpd": ctx.source.node.properties["dpd"],
"esp_lifetime": ctx.source.node.properties["esp_lifetime"],
"esp_policy": ctx.source.node.properties["esp_policy"],
"gateway": vpn_gateway.public_ip,
"ike_lifetime": ctx.source.node.properties["ike_lifetime"],
"ike_policy": ctx.source.node.properties["ike_policy"],
"ipsec_psk": ctx.source.node.properties["ipsec_psk"],
}
vpn_customer_gateway = cloud_driver.ex_create_vpn_customer_gateway(**data)
ctx.logger.info(
"Created VPN Customer Gateway id={0} vpn_gateway_id={1}".format(vpn_customer_gateway.id, vpn_gateway.id)
)
elif exists and use_external:
vpn_customer_gateway = get_vpn_customer_gateway(cloud_driver, id_)
ctx.logger.info("Using VPN Customer Gateway id={0}".format(vpn_customer_gateway.id))
elif exists and (not use_external):
raise NonRecoverableError("VPN Customer Gateway already exists id={0}".format(id_))
elif (not exists) and use_external:
raise NonRecoverableError("Could not find VPN Customer Gateway id={0}".format(id_))
ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = vpn_customer_gateway.id
ctx.source.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = VPN_CUSTOMER_GATEWAY_CLOUDSTACK_TYPE
def create(ctx, **kwargs):
private_key_path = _get_private_key_path()
pk_exists = _check_private_key_exists(private_key_path)
if ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY] is True:
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))
ctx.logger.info("Initializing {0} cloud driver".format(
Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
keypair = {
'name': get_resource_id(ctx, KEYPAIR_CLOUDSTACK_TYPE),
}
keypair.update(ctx.node.properties['keypair'])
#transform_resource_name(ctx, keypair)
keypair = cloud_driver.create_key_pair(keypair['name'])
# Cloudstack does not have an ID on keypair, so using name instead,
# which is unique
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = keypair.name
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
KEYPAIR_CLOUDSTACK_TYPE
ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY] = keypair.name
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.fchmod(f.fileno(), stat.S_IRUSR | stat.S_IWUSR)
except Exception:
_delete_private_key_file()
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
def create(ctx, **kwargs):
private_key_path = _get_private_key_path()
pk_exists = _check_private_key_exists(private_key_path)
if ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY] is True:
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))
ctx.logger.info("Initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
keypair = {
'name': get_resource_id(ctx, KEYPAIR_CLOUDSTACK_TYPE),
}
keypair.update(ctx.node.properties['keypair'])
keypair = cloud_driver.create_key_pair(keypair['name'])
# Cloudstack does not have an ID on keypair, so using name instead,
# which is unique
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = keypair.name
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
KEYPAIR_CLOUDSTACK_TYPE
ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY] = keypair.name
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.fchmod(f.fileno(), stat.S_IRUSR | stat.S_IWUSR)
except Exception:
_delete_private_key_file()
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
raise
def delete(ctx, **kwargs):
network_name = ctx.runtime_properties['network_name']
cloud_driver = get_cloud_driver(ctx)
network = get_network(cloud_driver, network_name)
try:
cloud_driver.ex_delete_network(network)
except Exception as e:
ctx.logger.warn('network {0} may not have been deleted: {1}'
.format(ctx.runtime_properties['network_name'], str(e)))
return False
pass
return True
def disconnect_floating_ip(ctx, **kwargs):
cloud_driver = get_cloud_driver(ctx)
node_id = ctx.runtime_properties['instance_id']
node = get_node_by_id(ctx, cloud_driver, node_id)
portmaps = get_portmaps_by_node_id(ctx, cloud_driver, node_id)
for portmap in portmaps:
try:
cloud_driver.ex_delete_port_forwarding_rule(node=node, rule=portmap)
except Exception as e:
ctx.logger.warn('Port forward may not have been removed: '
'{0}'.format(str(e)))
return False
return True
def start(ctx, **kwargs):
ctx.logger.info("initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
instance_id = ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
if instance_id is None:
raise RuntimeError(
'Could not find node ID in runtime context: {0} '
.format(instance_id))
node = get_vm_by_id(ctx, cloud_driver, instance_id)
if node is None:
raise RuntimeError('Could not find node with ID {0}'
.format(instance_id))
ctx.logger.info('Starting node: {0}'.format(node.name))
cloud_driver.ex_start(node)
def start(ctx, **kwargs):
ctx.logger.info("initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
instance_id = ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
if instance_id is None:
raise RuntimeError(
'Could not find node ID in runtime context: {0} '
.format(instance_id))
node = get_vm_by_id(ctx, cloud_driver, instance_id)
if node is None:
raise RuntimeError('Could not find node with ID {0}'
.format(instance_id))
ctx.logger.info('Starting node: {0}'.format(node.name))
cloud_driver.ex_start(node)
def delete(ctx, **kwargs):
ctx.logger.info("initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
instance_id = ctx['instance_id']
if instance_id is None:
raise NameError('could not find node ID in runtime context: {0} '
.format(instance_id))
ctx.logger.info('getting node with ID: {0} '.format(instance_id))
node = get_node_by_id(ctx, cloud_driver, instance_id)
if node is None:
raise NameError('could not find node with ID: {0} '
.format(instance_id))
ctx.logger.info('destroying vm with details: {0}'.format(node.name))
cloud_driver.destroy_node(node)
def delete(ctx, **kwargs):
if not ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]:
ctx.logger.info('deleting keypair')
_delete_private_key_file()
ctx.logger.info("Initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
key = get_key_pair(ctx, cloud_driver,
ctx.instance.runtime_properties
[CLOUDSTACK_ID_PROPERTY])
cloud_driver.delete_key_pair(key_pair=key)
else:
ctx.logger.info('not deleting keypair since an external keypair is '
'being used')
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def delete(**kwargs):
""" Delete a volume
"""
cloud_driver = get_cloud_driver(ctx)
volume_id = ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
volume = get_volume_by_id(cloud_driver, volume_id)
if volume is None:
raise NonRecoverableError('Volume with id {0} not found'
.format(volume_id))
if not ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]:
ctx.logger.info('Trying to destroy volume {0}'.format(volume))
cloud_driver.destroy_volume(volume=volume)
else:
ctx.logger.info('Volume {0} does not need to be destroyed'.format(
volume))
def create_vpn_gateway(**kwargs):
"""
Creates a VPN Gateway for a VPC.
"""
cloud_driver = get_cloud_driver(ctx)
vpc_id = ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
vpc = get_vpc_by_id(cloud_driver, vpc_id)
if not vpc:
raise NonRecoverableError('Could not find VPC id={0}'.format(vpc_id))
if not are_vpc_routers_running(cloud_driver, vpc.id):
return ctx.operation.retry(
message='VPC Routers not running, waiting...', retry_after=5)
exists = vpn_gateway_exists_for_vpc(cloud_driver, vpc_id)
use_external = ctx.source.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if (not exists) and (not use_external):
vpn_gateway = cloud_driver.ex_create_vpn_gateway(vpc)
ctx.logger.info('Created VPN Gateway id={0} vpc_id={1}'.format(
vpn_gateway.id, vpc_id))
elif exists and use_external:
vpn_gateway = get_vpn_gateway_by_vpc(cloud_driver, vpc_id)
ctx.logger.info('Using VPN Gateway id={0}'.format(vpn_gateway.id))
elif exists and (not use_external):
raise NonRecoverableError(
'VPN Gateway already exists vpc_id={0}'.format(vpc_id))
elif (not exists) and use_external:
raise NonRecoverableError(
'Could not find VPN Gateway vpc_id={0}'.format(vpc_id))
ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = \
vpn_gateway.id
ctx.source.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
VPN_GATEWAY_CLOUDSTACK_TYPE
def delete(**kwargs):
""" Delete a volume
"""
cloud_driver = get_cloud_driver(ctx)
volume_id = ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
volume = get_volume_by_id(cloud_driver, volume_id)
if volume is None:
raise NonRecoverableError(
'Volume with id {0} not found'.format(volume_id))
if not ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]:
ctx.logger.info('Trying to destroy volume {0}'.format(volume))
cloud_driver.destroy_volume(volume=volume)
else:
ctx.logger.info(
'Volume {0} does not need to be destroyed'.format(volume))
def delete(ctx, **kwargs):
if not ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]:
ctx.logger.info('deleting keypair')
_delete_private_key_file()
ctx.logger.info("Initializing {0} cloud driver".format(
Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
key = get_key_pair(
ctx, cloud_driver,
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY])
cloud_driver.delete_key_pair(key_pair=key)
else:
ctx.logger.info('not deleting keypair since an external keypair is '
'being used')
delete_runtime_properties(ctx, RUNTIME_PROPERTIES_KEYS)
def start(ctx, **kwargs):
ctx.logger.info("initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
instance_id = ctx.runtime_properties['instance_id']
if instance_id is None:
raise RuntimeError(
'could not find node ID in runtime context: {0} '
.format(instance_id))
ctx.logger.info('getting node with ID: {0} '.format(instance_id))
node = get_node_by_id(ctx, cloud_driver, instance_id)
if node is None:
raise RuntimeError('could not find node with ID {0}'
.format(instance_id))
ctx.logger.info('starting node with details {0}'.format(node.name))
cloud_driver.ex_start(node)
def create(ctx, **kwargs):
""" Create vpc with rules.
"""
cloud_driver = get_cloud_driver(ctx)
vpc = {
'description': None,
'name': get_resource_id(ctx, VPC_CLOUDSTACK_TYPE),
}
ctx.logger.debug('reading vpc configuration.')
vpc.update(ctx.node.properties['network'])
vpc_name = vpc['name']
cidr = vpc['cidr']
zone = vpc['zone']
location = get_location(cloud_driver, zone)
vpcoffer = vpc['service_offering']
vpc_offering = get_vpc_offering(cloud_driver, vpcoffer)
ctx.logger.info('Creating VPC {0}'.format(vpc_name))
if not vpc_exists(cloud_driver, vpc_name):
ctx.logger.info('creating vpc: {0}'.format(vpc_name))
vpc = cloud_driver.ex_create_vpc(
cidr=cidr,
name=vpc_name,
display_text=vpc_name,
vpc_offering=vpc_offering,
zone_id=location.id)
else:
ctx.logger.info('Using existing vpc network {0}'.
format(vpc_name))
vpc = get_vpc(cloud_driver, vpc_name)
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = vpc.id
ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY] = \
vpc.name
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
VPC_CLOUDSTACK_TYPE
def delete_vpn_connection(**kwargs):
"""
Deletes a VPN Connection.
"""
cloud_driver = get_cloud_driver(ctx)
id_ = ctx.node.runtime_properties[CLOUDSTACK_ID_PROPERTY]
vpn_connection = get_vpn_connection(cloud_driver, id_)
if not vpn_connection:
raise NonRecoverableError("Could not find VPN Connection id={0}".format(id_))
use_external = ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if not use_external:
vpn_connection.delete()
ctx.logger.info("Deleted VPN Connection id={0}".format(id_))
else:
ctx.logger.info("Did not delete VPN Connection id={0}".format(id_))
def delete_vpn_gateway(**kwargs):
"""
Deletes a VPN Gateway for a VPC.
"""
cloud_driver = get_cloud_driver(ctx)
id_ = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
vpn_gateway = get_vpn_gateway(cloud_driver, id_)
if not vpn_gateway:
raise NonRecoverableError("Could not find VPN Gateway id={0}".format(id_))
use_external = ctx.source.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if not use_external:
vpn_gateway.delete()
ctx.logger.info("Deleted VPN Gateway id={0} vpc_id={1}".format(id_, vpn_gateway.vpc_id))
else:
ctx.logger.info("Did not delete VPN Gateway id={0} vpc_id={1}".format(id_, vpn_gateway.vpc_id))
def create(ctx, **kwargs):
""" Create vpc with rules.
"""
cloud_driver = get_cloud_driver(ctx)
vpc = {
'description': None,
'name': ctx.node_id,
}
ctx.logger.debug('reading vpc configuration.')
vpc.update(ctx.properties['network'])
vpc_name = vpc['name']
cidr = vpc['cidr']
zone = vpc['zone']
location = get_location(cloud_driver, zone)
vpcoffer = vpc['service_offering']
vpc_offering = get_vpc_offering(cloud_driver, vpcoffer)
ctx.logger.info('Current node {0}{1}'.format(ctx.node_id, ctx.properties))
ctx['vpc_id'] = ctx.properties
if not _vpc_exists(cloud_driver, vpc_name):
ctx.logger.info('creating vpc: {0}'.format(vpc_name))
vpc = cloud_driver.ex_create_vpc(
cidr=cidr,
name=vpc_name,
display_text=vpc_name,
vpc_offering=vpc_offering,
zone_id=location.id)
else:
ctx.logger.info('using existing vpc network {0}'.
format(vpc_name))
vpc = get_vpc(cloud_driver, vpc_name)
ctx['vpc_id'] = vpc.id
ctx['vpc_name'] = vpc.name
def delete_vpn_connection(**kwargs):
"""
Deletes a VPN Connection.
"""
cloud_driver = get_cloud_driver(ctx)
id_ = ctx.node.runtime_properties[CLOUDSTACK_ID_PROPERTY]
vpn_connection = get_vpn_connection(cloud_driver, id_)
if not vpn_connection:
raise NonRecoverableError(
'Could not find VPN Connection id={0}'.format(id_))
use_external = ctx.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if not use_external:
vpn_connection.delete()
ctx.logger.info('Deleted VPN Connection id={0}'.format(id_))
else:
ctx.logger.info('Did not delete VPN Connection id={0}'.format(id_))
def create(ctx, **kwargs):
""" Create security group with rules.
"""
cloud_driver = get_cloud_driver(ctx)
security_group = {
'description': None,
'name': ctx.node_id,
}
ctx.logger.debug('reading security-group configuration.')
rules_to_apply = ctx.properties['rules']
security_group.update(ctx.properties['security_group'])
security_group_name = security_group['name']
if not _sg_exists(cloud_driver, security_group_name):
ctx.logger.info(
'creating security group: {0}'.format(security_group_name))
cloud_driver.ex_create_security_group(
security_group_name, description=security_group['description'])
for rule in rules_to_apply:
cidr = rule.get('cidr', None)
protocol = rule.get('protocol', 'TCP')
start_port = rule.get('start_port', None)
if start_port is None:
raise RuntimeError('You must specify start_port '
'for a security group rule')
end_port = rule.get('end_port', None)
_add_ingress_rule(ctx,
cloud_driver,
security_group_name=security_group_name,
start_port=start_port,
end_port=end_port,
cidr_list=cidr,
protocol=protocol)
else:
ctx.logger.info('using existing management security group {0}'.format(
security_group_name))
def create(ctx, **kwargs):
""" Create vpc with rules.
"""
cloud_driver = get_cloud_driver(ctx)
vpc = {
'description': None,
'name': ctx.node_id,
}
ctx.logger.debug('reading vpc configuration.')
vpc.update(ctx.properties['network'])
vpc_name = vpc['name']
cidr = vpc['cidr']
zone = vpc['zone']
location = get_location(cloud_driver, zone)
vpcoffer = vpc['service_offering']
vpc_offering = get_vpc_offering(cloud_driver, vpcoffer)
ctx.logger.info('Current node {0}{1}'.format(ctx.node_id, ctx.properties))
ctx['vpc_id'] = ctx.properties
if not _vpc_exists(cloud_driver, vpc_name):
ctx.logger.info('creating vpc: {0}'.format(vpc_name))
vpc = cloud_driver.ex_create_vpc(cidr=cidr,
name=vpc_name,
display_text=vpc_name,
vpc_offering=vpc_offering,
zone_id=location.id)
else:
ctx.logger.info('using existing vpc network {0}'.format(vpc_name))
vpc = get_vpc(cloud_driver, vpc_name)
ctx['vpc_id'] = vpc.id
ctx['vpc_name'] = vpc.name
def attach_volume(ctx, **kwargs):
""" Attach a volume to virtual machine.
"""
cloud_driver = get_cloud_driver(ctx)
server_id = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
volume_id = ctx.target.instance.runtime_properties.get(
CLOUDSTACK_ID_PROPERTY, None)
server = get_vm_by_id(ctx, cloud_driver, server_id)
volume = get_volume_by_id(cloud_driver, volume_id)
if server is None:
raise NonRecoverableError(
'Server with id {0} not found'.format(server_id))
if volume is None:
raise NonRecoverableError(
'Volume with id {0} not found'.format(volume_id))
cloud_driver.attach_volume(node=server, volume=volume)
def create(ctx, **kwargs):
""" Create security group with rules.
"""
cloud_driver = get_cloud_driver(ctx)
security_group = {
'description': None,
'name': ctx.node_id,
}
ctx.logger.debug('reading security-group configuration.')
rules_to_apply = ctx.node.properties['rules']
security_group.update(ctx.node.properties['security_group'])
security_group_name = security_group['name']
if not _sg_exists(cloud_driver, security_group_name):
ctx.logger.info('creating security group: {0}'.format(
security_group_name))
cloud_driver.ex_create_security_group(
security_group_name, description=security_group['description'])
for rule in rules_to_apply:
cidr = rule.get('cidr', None)
protocol = rule.get('protocol', 'TCP')
start_port = rule.get('start_port', None)
if start_port is None:
raise RuntimeError('You must specify start_port '
'for a security group rule')
end_port = rule.get('end_port', None)
_add_ingress_rule(ctx, cloud_driver,
security_group_name=security_group_name,
start_port=start_port,
end_port=end_port,
cidr_list=cidr,
protocol=protocol)
else:
ctx.logger.info('using existing management security group {0}'.format(
security_group_name))
def connect_network(ctx, **kwargs):
instance_id = ctx.runtime_properties['instance_id']
network_id = ctx.related.runtime_properties['network_id']
cloud_driver = get_cloud_driver(ctx)
# nodes = cloud_driver.list_nodes(instance_id)
# network = [net for net in cloud_driver.ex_list_networks() if
# net.id == network_id ][0]
# instance = [node for node in cloud_driver.list_nodes() if
# node.id == instance_id][0]
node = get_node_by_id(ctx, cloud_driver, instance_id)
network = get_network_by_id(ctx, cloud_driver, network_id)
ctx.logger.info('Checking if there is a nic for '
'vm: {0} with id: {1} in network {2} with id: {3}'
.format(node.name, network.name, instance_id, network_id,))
nic_exists = get_nic_by_node_and_network_id(ctx, cloud_driver, node,
network_id)
#ctx.logger.info('Adding a NIC to VM {0} in Network {1}'.format(
# node.name, network.name))
if nic_exists is not None:
ctx.logger.info('No need to connect network {0}, '
'already connected to nic {1}'
.format(network.name, nic_exists.id))
return False
cloud_driver.ex_attach_nic_to_node(node=node, network=network)
#ctx.runtime_properties['nic_id'] = result.id
return True
def attach_volume(ctx, **kwargs):
""" Attach a volume to virtual machine.
"""
cloud_driver = get_cloud_driver(ctx)
server_id = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
volume_id = ctx.target.instance.runtime_properties.get(
CLOUDSTACK_ID_PROPERTY, None)
server = get_vm_by_id(ctx, cloud_driver, server_id)
volume = get_volume_by_id(cloud_driver, volume_id)
if server is None:
raise NonRecoverableError('Server with id {0} not found'
.format(server_id))
if volume is None:
raise NonRecoverableError('Volume with id {0} not found'
.format(volume_id))
cloud_driver.attach_volume(node=server,
volume=volume)
def create_vpn_gateway(**kwargs):
"""
Creates a VPN Gateway for a VPC.
"""
cloud_driver = get_cloud_driver(ctx)
vpc_id = ctx.target.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
vpc = get_vpc_by_id(cloud_driver, vpc_id)
if not vpc:
raise NonRecoverableError("Could not find VPC id={0}".format(vpc_id))
if not are_vpc_routers_running(cloud_driver, vpc.id):
return ctx.operation.retry(message="VPC Routers not running, waiting...", retry_after=5)
exists = vpn_gateway_exists_for_vpc(cloud_driver, vpc_id)
use_external = ctx.source.node.properties[USE_EXTERNAL_RESOURCE_PROPERTY]
if (not exists) and (not use_external):
vpn_gateway = cloud_driver.ex_create_vpn_gateway(vpc)
ctx.logger.info("Created VPN Gateway id={0} vpc_id={1}".format(vpn_gateway.id, vpc_id))
elif exists and use_external:
vpn_gateway = get_vpn_gateway_by_vpc(cloud_driver, vpc_id)
ctx.logger.info("Using VPN Gateway id={0}".format(vpn_gateway.id))
elif exists and (not use_external):
raise NonRecoverableError("VPN Gateway already exists vpc_id={0}".format(vpc_id))
elif (not exists) and use_external:
raise NonRecoverableError("Could not find VPN Gateway vpc_id={0}".format(vpc_id))
ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = vpn_gateway.id
ctx.source.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = VPN_GATEWAY_CLOUDSTACK_TYPE
def connect_floating_ip(ctx, **kwargs):
cloud_driver = get_cloud_driver(ctx)
network_config = ctx.source.node.properties['network']
default_network_config = network_config['default_network']
default_net = get_network(cloud_driver, default_network_config)
ctx.logger.debug('reading portmap configuration.')
portmaps = ctx.source.node.properties['portmaps']
if not portmaps:
raise NonRecoverableError('Relation defined but no portmaps set'
' either remove relation or'
' define the portmaps')
server_id = ctx.source.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY]
floating_ip_id = ctx.target.instance.runtime_properties[
CLOUDSTACK_ID_PROPERTY]
# TODO Needs more elegant solution, problem only seen on VPC with CS4.3
# TODO Should be fixed in Cloudstack
ctx.logger.info('Sleeping for 15 secs so router can stabilize, '
'so we wont have to wait for ARP timeouts '
'when reusing public IPs')
sleep(15)
for portmap in portmaps:
protocol = portmap.get(['protocol'][0], None)
pub_port = portmap.get(['public_port'][0], None)
pub_end_port = portmap.get(['public_end_port'][0], None)
priv_port = portmap.get(['private_port'][0], None)
priv_end_port = portmap.get(['private_end_port'][0], None)
# If not specified assume closed
open_fw = portmap.get(['open_firewall'][0], False)
if pub_port is None:
raise NonRecoverableError('Please specify the public_port')
elif pub_end_port is None:
pub_end_port = pub_port
if priv_port is None:
raise NonRecoverableError('Please specify the private_port')
elif priv_end_port is None:
priv_end_port = priv_port
if protocol is None:
raise NonRecoverableError('Please specify the protocol TCP or UDP')
node = get_vm_by_id(ctx, cloud_driver, server_id)
public_ip = get_public_ip_by_id(ctx, cloud_driver, floating_ip_id)
try:
ctx.logger.info('Creating portmap for node: {0}:{1}-{2} on'
' {3}:{4}-{5}'.
format(node.name, priv_port, priv_end_port,
public_ip.address, pub_port, pub_end_port))
cloud_driver.ex_create_port_forwarding_rule(
node=node,
address=public_ip,
protocol=protocol,
public_port=pub_port,
public_end_port=pub_end_port,
private_port=priv_port,
private_end_port=priv_end_port,
openfirewall=open_fw,
network_id=default_net.id)
except Exception as e:
ctx.logger.warn('Port forward creation failed: '
'{0}'.format(str(e)))
return False
return True
def create(ctx, **kwargs):
network_ids = get_cloudstack_ids_of_connected_nodes_by_cloudstack_type(
ctx, NETWORK_CLOUDSTACK_TYPE)
provider_context = provider(ctx)
ctx.logger.info('Network IDs: {0}'.format(network_ids))
# Cloudstack does not support _underscore in vm-name
server_config = {
'name': get_resource_id(ctx, SERVER_CLOUDSTACK_TYPE).replace('_', '-')
}
server_config.update(copy.deepcopy(ctx.node.properties['server']))
ctx.logger.info("Initializing {0} cloud driver"
.format(Provider.CLOUDSTACK))
cloud_driver = get_cloud_driver(ctx)
# TODO Currently a generated network name (resource_id) \
# TODO is not support for the default network
network_config = ctx.node.properties['network']
name = server_config['name']
image_id = server_config['image_id']
size_name = server_config['size']
zone = server_config.get(['zone'][0], None)
if zone is not None:
location = get_location(cloud_driver, zone)
else:
location = None
# server keypair handling
# Cloudstack does not have id's for keys, just unique names which we store
# as id.
keypair_id = get_cloudstack_ids_of_connected_nodes_by_cloudstack_type(
ctx, KEYPAIR_CLOUDSTACK_TYPE)
if 'key_name' in server_config:
if keypair_id:
raise NonRecoverableError("server can't both have the "
'"key_name" nested property and be '
'connected to a keypair via a '
'relationship at the same time')
elif keypair_id:
# TODO pointfix, this must be UTF8,
# otherwise cloudstack interface breaks
keyname = keypair_id[0].encode('UTF8')
server_config['key_name'] = keyname
elif provider_context.agents_keypair:
server_config['key_name'] = provider_context.agents_keypair['name']
print ('provider ')
else:
raise NonRecoverableError(
'server must have a keypair, yet no keypair was connected to the '
'server node, the "key_name" nested property'
"wasn't used, and there is no agent keypair in the provider "
"context")
keypair_name = server_config['key_name']
default_security_group = network_config.get(['default_security_group'][0],
None)
default_network = network_config.get(['default_network'][0], None)
ip_address = network_config.get(['ip_address'][0], None)
external_id = ctx.instance.runtime_properties.get(
[CLOUDSTACK_ID_PROPERTY][0], None)
if external_id is not None:
if get_vm_by_id(ctx, cloud_driver, ctx.instance.runtime_properties[
CLOUDSTACK_ID_PROPERTY]):
ctx.logger.info('VM already created, skipping creation')
return
ctx.logger.info('Getting service_offering: {0}'.format(size_name))
sizes = [size for size in cloud_driver.list_sizes()
if size.name == size_name]
if sizes is None:
raise RuntimeError(
'Could not find service_offering with name {0}'.format(size_name))
size = sizes[0]
ctx.logger.info('Getting required image with ID {0}'.format(image_id))
images = [template for template in cloud_driver.list_images()
if image_id == template.id]
if images is None:
raise RuntimeError('Could not find image with ID {0}'.format(image_id))
image = images[0]
# TODO add check if default network is really existing!
if default_network is None:
if default_security_group is None:
raise RuntimeError("We need either a default_security_group "
"or default_network, "
"none specified")
if default_network is not None:
if default_security_group is not None:
raise RuntimeError("We need either a default_security_group "
"or default_network, "
"both are specified")
if default_network is not None:
_create_in_network(ctx=ctx,
cloud_driver=cloud_driver,
name=name,
image=image,
size=size,
keypair_name=keypair_name,
network_ids=network_ids,
default_network=default_network,
ip_address=ip_address,
location=location)
if default_security_group is not None:
ctx.logger.info('Creating this VM in default_security_group.'.
format(default_security_group))
ctx.logger.info("Creating VM with the following details: {0}".format(
server_config))
_create_in_security_group(
ctx=ctx,
cloud_driver=cloud_driver,
name=name,
image=image,
size=size,
keypair_name=keypair_name,
default_security_group_name=default_security_group,
ip_address=ip_address,
location=location)
def create(ctx, **kwargs):
""" Create network with rules.
"""
cloud_driver = get_cloud_driver(ctx)
network = {
'description': None,
'name': get_resource_id(ctx, NETWORK_CLOUDSTACK_TYPE),
}
ctx.logger.debug('reading network configuration.')
network.update(copy.deepcopy(ctx.node.properties['network']))
network_name = network['name']
zone = network['zone']
location = get_location(cloud_driver, zone)
netoffer = network['service_offering']
network_offering = get_network_offering(cloud_driver, netoffer)
existing_net = network_exists(cloud_driver, network_name)
# TODO, bit messy below, should be reviewed.
if 'vpc' in network:
if network['vpc']:
vpc = get_vpc(cloud_driver, network['vpc'])
ctx.logger.info('DEBUG: VPC id: {0} '.format(vpc.id))
else:
vpc = None
if not existing_net and ctx.node.properties[
USE_EXTERNAL_RESOURCE_PROPERTY] is False:
if vpc:
ctx.logger.info('Creating network: {0} in VPC with ID: {1}'.
format(network_name, vpc.id))
net = cloud_driver.ex_create_network(
display_text=network_name,
name=network_name,
network_offering=network_offering,
location=location,
gateway=network.get(['gateway'][0], None),
netmask=network.get(['netmask'][0], None),
vpc_id=vpc.id)
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = net.id
ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY] = \
net.name
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
NETWORK_CLOUDSTACK_TYPE
# Create ACL for the network if it's is part of a VPC
acl_list = create_acl_list(cloud_driver, network_name,
vpc.id, net.id)
if 'firewall' in ctx.node.properties:
firewall_config = ctx.node.properties['firewall']
for acl in firewall_config:
acl_cidr = acl.get('cidr')
acl_protocol = acl.get('protocol')
acl_ports = acl.get('ports')
acl_type = acl.get('type')
for port in acl_ports:
create_acl(cloud_driver, acl_protocol, acl_list.id,
acl_cidr, port, port, acl_type)
else:
ctx.logger.info('Creating network: {0}'.format(network_name))
net = cloud_driver.ex_create_network(
display_text=network_name,
name=network_name,
gateway=network.get(['gateway'][0], None),
netmask=network.get(['netmask'][0], None),
network_offering=network_offering,
location=location,)
ctx.logger.info('Created Network: {0}'.format(net.name))
# Create egress rules only as they are part of a network,
# ingress rules are bound to a floating/public_ip so,
# this will get arranged on the floating ip relationship
_create_egress_rules(ctx, cloud_driver, net.id)
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = net.id
ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY] = \
net.name
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
NETWORK_CLOUDSTACK_TYPE
elif existing_net and ctx.node.properties[
USE_EXTERNAL_RESOURCE_PROPERTY] is False:
net = get_network(cloud_driver, network_name)
ctx.logger.info('Using existing network: {0}'.
format(network_name))
_create_egress_rules(ctx, cloud_driver, net.id)
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = net.id
ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY] = \
net.name
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
NETWORK_CLOUDSTACK_TYPE
elif existing_net and ctx.node.properties[
USE_EXTERNAL_RESOURCE_PROPERTY] is True:
net = get_network(cloud_driver, network_name)
ctx.logger.warn('Using existing network: {0} while use'
'_external_resource'
' is set to False, no egress rules will '
'be configured'.format(network_name))
ctx.instance.runtime_properties[CLOUDSTACK_ID_PROPERTY] = net.id
ctx.instance.runtime_properties[CLOUDSTACK_NAME_PROPERTY] = \
net.name
ctx.instance.runtime_properties[CLOUDSTACK_TYPE_PROPERTY] = \
NETWORK_CLOUDSTACK_TYPE
def create(ctx, **kwargs):
""" Create network with rules.
"""
cloud_driver = get_cloud_driver(ctx)
network = {
'description': None,
'name': ctx.node_id,
}
ctx.logger.debug('reading network configuration.')
network.update(ctx.properties['network'])
network_name = network['name']
zone = network['zone']
location = get_location(cloud_driver, zone)
netoffer = network['service_offering']
network_offering = get_network_offering(cloud_driver, netoffer)
if 'vpc' in network:
if network['vpc']:
vpc = get_vpc_id(cloud_driver, network['vpc'])
ctx.logger.info('DEBUG: VPC id: '.format(vpc.id))
else:
vpc = None
ctx.logger.info('Current node {0}{1}'.format(ctx.node_id, ctx.properties))
ctx['network_id'] = ctx.node_id
if not _network_exists(cloud_driver, network_name):
if vpc:
ctx.logger.info('creating network: {0} in VPC with ID: {1}'.
format(network_name, vpc.id))
net = cloud_driver.ex_create_network(
display_text=network_name,
name=network_name,
network_offering=network_offering,
location=location,
gateway=network['gateway'],
netmask=network['netmask'],
vpc_id=vpc.id)
# Create ACL for the network if it's is part of a VPC
acl_list = create_acl_list(cloud_driver, network_name,
vpc.id, net.id)
if 'firewall' in ctx.properties:
firewall_config = ctx.properties['firewall']
for acl in firewall_config:
acl_cidr = acl.get('cidr')
acl_protocol = acl.get('protocol')
acl_ports = acl.get('ports')
acl_type = acl.get('type')
for port in acl_ports:
create_acl(cloud_driver, acl_protocol, acl_list.id,
acl_cidr, port, port, acl_type)
else:
ctx.logger.info('creating network: {0}'.format(network_name))
net = cloud_driver.ex_create_network(
display_text=network_name,
name=network_name,
network_offering=network_offering,
location=location)
if 'firewall' in ctx.properties:
firewall_config = ctx.properties['firewall']
for rule in firewall_config:
rule_cidr = rule.get('cidr')
rule_protocol = rule.get('protocol')
rule_ports = rule.get('ports')
for port in rule_ports:
_create_egress_rules(cloud_driver, net.id,
rule_cidr,
rule_protocol,
port, port)
else:
ctx.logger.info('using existing management network {0}'.
format(network_name))
net = get_network(cloud_driver, network_name)
ctx['network_id'] = net.id
ctx['network_name'] = net.name
