def associate(self, args=None, **_):
""" Associates an Elastic IP created by Cloudify with an EC2 Instance
that was also created by Cloudify.
"""
instance_id = self.source_resource_id
elasticip = self.target_resource_id
associate_args = dict(instance_id=instance_id, public_ip=elasticip)
if constants.ELASTICIP['ALLOCATION_ID'] in \
ctx.target.instance.runtime_properties:
associate_args.pop('public_ip')
associate_args.update({
constants.ELASTICIP['ALLOCATION_ID']:
ctx.target.instance.runtime_properties[
constants.ELASTICIP['ALLOCATION_ID']]
})
associate_args = utils.update_args(associate_args, args)
try:
self.execute(self.client.associate_address,
associate_args,
raise_on_falsy=True)
except (exception.EC2ResponseError, exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
return True
def associate(self, args=None, **_):
""" Associates an Elastic IP created by Cloudify with an EC2 Instance
that was also created by Cloudify.
"""
instance_id = self.source_resource_id
elasticip = self.target_resource_id
associate_args = dict(instance_id=instance_id, public_ip=elasticip)
if constants.ELASTICIP['ALLOCATION_ID'] in \
ctx.target.instance.runtime_properties:
associate_args.pop('public_ip')
associate_args.update(
{constants.ELASTICIP['ALLOCATION_ID']:
ctx.target.instance.runtime_properties[
constants.ELASTICIP['ALLOCATION_ID']]})
associate_args = utils.update_args(associate_args, args)
try:
self.execute(self.client.associate_address, associate_args,
raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
return True
def disassociate(self, args=None, **_):
""" Disassocates an Elastic IP created by Cloudify from an EC2 Instance
that was also created by Cloudify.
"""
elasticip = self.target_resource_id
elasticip_object = self.get_target_resource()
if not elasticip_object:
raise NonRecoverableError(
'no matching elastic ip in account: {0}'.format(elasticip))
disassociate_args = dict(
public_ip=elasticip_object.public_ip,
association_id=elasticip_object.association_id)
disassociate_args = utils.update_args(disassociate_args, args)
try:
self.execute(self.client.disassociate_address,
disassociate_args,
raise_on_falsy=True)
except (exception.EC2ResponseError, exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
return True
def disassociate(self, args=None, **_):
""" Disassocates an ENI created by Cloudify from an EC2 Instance
that was also created by Cloudify.
"""
attachment_id = \
ctx.source.instance.runtime_properties.pop('attachment_id')
detach_args = dict(attachment_id=attachment_id)
detach_args = utils.update_args(detach_args, args)
try:
output = self.execute(self.client.detach_network_interface,
detach_args,
raise_on_falsy=True)
except (exception.EC2ResponseError, exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
if not output:
ctx.source.instance.runtime_properties['attachment_id'] = \
attachment_id
raise RecoverableError('Failed to detach network interface {0} '
'from instance {1}'.format(
self.source_resource_id,
self.target_resource_id))
return output
def associate(self, args=None, **_):
""" Associates an ENI created by Cloudify with an EC2 Instance
that was also created by Cloudify.
"""
network_interface_id = self.source_resource_id
instance_id = self.target_resource_id
attachment_args = dict(network_interface_id=network_interface_id,
instance_id=instance_id,
device_index=1)
attachment_args = utils.update_args(attachment_args, args)
try:
output = self.execute(self.client.attach_network_interface,
attachment_args,
raise_on_falsy=True)
except (exception.EC2ResponseError, exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
if not output:
raise RecoverableError(
'Failed to attach eni {0} to instance {1}'.format(
self.source_resource_id, self.target_resource_id))
network_interface = self.get_source_resource()
ctx.source.instance.runtime_properties['attachment_id'] = \
network_interface.attachment.id
return output
def delete(self, args=None, **_):
delete_args = dict(group_id=self.resource_id)
delete_args = utils.update_args(delete_args, args)
return self.execute(self.client.delete_security_group,
delete_args,
raise_on_falsy=True)
def create(self, args):
create_args = self.generate_create_args()
create_args = utils.update_args(create_args, args)
dhcp_options = self.execute(self.client.create_dhcp_options,
create_args, raise_on_falsy=True)
self.resource_id = dhcp_options.id
return True
def create(self, args=None):
'''Override for resource create operation'''
if ctx.operation.retry_number == 0:
# Create the resource
create_args = utils.update_args(
self._generate_creation_args(), args)
subnet = self.execute(self.client.create_subnet,
create_args, raise_on_falsy=True)
self.resource_id = subnet.id
else:
# Get the resource object
subnet = self.get_resource()
# If the operation is still pending, set the ID and retry
if hasattr(subnet, 'state'):
ctx.logger.debug('AWS resource {0} returned a state of "{1}"'
.format(self.resource_id, subnet.state))
if subnet.state == 'pending':
set_external_resource_id(self.resource_id, ctx.instance)
return ctx.operation.retry(
message='Waiting to verify that AWS resource {0} '
'has been added to your account.'.format(self.resource_id))
else:
ctx.logger.warn('AWS resource {0} returned an '
'unexpected response (missing state)'
.format(self.resource_id))
return False
return True
def create(self, args=None, **_):
"""Creates an EC2 security group.
"""
name = utils.get_resource_id()
create_args = dict(
name=name,
description=ctx.node.properties['description'],
vpc_id=self._get_connected_vpc()
)
create_args = utils.update_args(create_args, args)
try:
security_group = self.execute(
self.client.create_security_group, create_args,
raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
self.resource_id = security_group.id
return True
def associate(self, args):
associate_args = dict(dhcp_options_id=self.source_resource_id,
vpc_id=self.target_resource_id)
associate_args = utils.update_args(associate_args, args)
return self.execute(self.client.associate_dhcp_options,
associate_args,
raise_on_falsy=True)
def create_snapshot(self, args=None, **_):
""" Create a snapshot of an EBS Volume
"""
volume_id = \
utils.get_external_resource_id_or_raise(
'create snapshot', ctx.instance)
ctx.logger.info(
'Trying to create a snapshot of EBS volume {0}.'.format(volume_id))
snapshot_desc = \
unicode(datetime.datetime.now()) + \
ctx.instance.runtime_properties[constants.EXTERNAL_RESOURCE_ID]
create_args = dict(volume_id=volume_id, description=snapshot_desc)
create_args = utils.update_args(create_args, args)
try:
new_snapshot = self.execute(self.client.create_snapshot,
create_args,
raise_on_falsy=True)
except (exception.EC2ResponseError, exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
if constants.EBS['VOLUME_SNAPSHOT_ATTRIBUTE'] not in \
ctx.instance.runtime_properties:
ctx.instance.runtime_properties[
constants.EBS['VOLUME_SNAPSHOT_ATTRIBUTE']] = list()
ctx.instance.runtime_properties[
constants.EBS['VOLUME_SNAPSHOT_ATTRIBUTE']].append(new_snapshot.id)
return True
def create(self, args=None, **_):
"""Creates an EC2 security group.
"""
name = utils.get_resource_id()
create_args = dict(name=name,
description=ctx.node.properties['description'],
vpc_id=self._get_connected_vpc())
create_args = utils.update_args(create_args, args)
if ctx.operation.retry_number == 0 and constants.EXTERNAL_RESOURCE_ID \
not in ctx.instance.runtime_properties:
try:
security_group = self.execute(
self.client.create_security_group,
create_args,
raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
utils.set_external_resource_id(security_group.id,
ctx.instance,
external=False)
self.resource_id = \
ctx.instance.runtime_properties[constants.EXTERNAL_RESOURCE_ID]
security_group = self.get_resource()
if not security_group:
return False
self._create_group_rules(security_group)
return True
def _create_elb(self, args):
create_args = self._create_elb_params()
create_args = utils.update_args(create_args, args)
try:
lb = self.execute(self.client.create_load_balancer, create_args,
raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError,
exception.BotoClientError) as e:
raise RecoverableError('Load Balancer not created '
'{0}'.format(str(e)))
if not lb:
raise NonRecoverableError(
'Load Balancer not created. While the create '
'request was completed'
' successfully, verifying the load balancer '
'afterwards has failed')
ctx.instance.runtime_properties['elb_name'] = create_args['name']
self.resource_id = create_args['name']
return lb
def associate(self, args=None, **_):
""" Associates an ENI created by Cloudify with an EC2 Instance
that was also created by Cloudify.
"""
network_interface_id = self.source_resource_id
instance_id = self.target_resource_id
attachment_args = dict(network_interface_id=network_interface_id,
instance_id=instance_id,
device_index=1)
attachment_args = utils.update_args(attachment_args, args)
try:
output = self.execute(self.client.attach_network_interface,
attachment_args,
raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
if not output:
raise RecoverableError(
'Failed to attach eni {0} to instance {1}'
.format(self.source_resource_id,
self.target_resource_id)
)
network_interface = self.get_source_resource()
ctx.source.instance.runtime_properties['attachment_id'] = \
network_interface.attachment.id
return output
def disassociate(self, args=None, **_):
""" Disassocates an ENI created by Cloudify from an EC2 Instance
that was also created by Cloudify.
"""
attachment_id = \
ctx.source.instance.runtime_properties.pop('attachment_id')
detach_args = dict(attachment_id=attachment_id)
detach_args = utils.update_args(detach_args, args)
try:
output = self.execute(self.client.detach_network_interface,
detach_args, raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
if not output:
ctx.source.instance.runtime_properties['attachment_id'] = \
attachment_id
raise RecoverableError(
'Failed to detach network interface {0} '
'from instance {1}'
.format(
self.source_resource_id,
self.target_resource_id
)
)
return output
def associate(self, args=None, **_):
elb_name = self.target_resource_id
instance_id = self.source_resource_id
ctx.logger.info('Attemping to add instance: {0} to elb {1}'
.format(instance_id, elb_name))
associate_args = dict(
load_balancer_name=elb_name,
instances=[instance_id])
associate_args = utils.update_args(associate_args, args)
try:
self.execute(self.client.register_instances, associate_args,
raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError,
exception.BotoClientError) as e:
raise NonRecoverableError('Instance not added to Load '
'Balancer {0}'.format(str(e)))
ctx.logger.info(
'Instance {0} added to Load Balancer {1}.'
.format(instance_id, elb_name))
self._add_instance_to_elb_list_in_properties(instance_id)
return True
def create_snapshot(self, args=None, **_):
""" Create a snapshot of an EBS Volume
"""
volume_id = \
utils.get_external_resource_id_or_raise(
'create snapshot', ctx.instance)
ctx.logger.info(
'Trying to create a snapshot of EBS volume {0}.'
.format(volume_id))
snapshot_desc = \
unicode(datetime.datetime.now()) + \
ctx.instance.runtime_properties[constants.EXTERNAL_RESOURCE_ID]
create_args = dict(volume_id=volume_id, description=snapshot_desc)
create_args = utils.update_args(create_args, args)
try:
new_snapshot = self.execute(self.client.create_snapshot,
create_args, raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
if constants.EBS['VOLUME_SNAPSHOT_ATTRIBUTE'] not in \
ctx.instance.runtime_properties:
ctx.instance.runtime_properties[
constants.EBS['VOLUME_SNAPSHOT_ATTRIBUTE']] = list()
ctx.instance.runtime_properties[
constants.EBS['VOLUME_SNAPSHOT_ATTRIBUTE']].append(new_snapshot.id)
return True
def create(self, args=None, **_):
"""This allocates an Elastic IP in the connected account."""
ctx.logger.debug('Attempting to allocate elasticip.')
provider_variables = utils.get_provider_variables()
create_args = {}
domain = ctx.node.properties.get(
constants.ELASTICIP['ELASTIC_IP_DOMAIN_PROPERTY']) or \
provider_variables.get(constants.ELASTICIP['VPC_DOMAIN'])
if domain:
create_args[constants.ELASTICIP['ELASTIC_IP_DOMAIN_PROPERTY']] = \
constants.ELASTICIP['VPC_DOMAIN']
create_args = utils.update_args(create_args, args)
try:
address_object = self.execute(self.client.allocate_address,
create_args, raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
if constants.ELASTICIP['VPC_DOMAIN'] in address_object.domain:
ctx.instance.runtime_properties[constants.ELASTICIP[
'ALLOCATION_ID']] = address_object.allocation_id
self.allocation_id = address_object.allocation_id
self.resource_id = address_object.public_ip
return True
def disassociate(self, args=None, **_):
""" Detaches an EBS Volume created by Cloudify from an EC2 Instance
that was also created by Cloudify.
"""
volume_id = self.source_resource_id
instance_id = self.target_resource_id
volume_object = self.get_source_resource()
if not volume_object:
raise NonRecoverableError(
'EBS volume {0} not found in account.'.format(volume_id))
disassociate_args = dict(
volume_id=volume_id,
instance_id=instance_id,
device=ctx.source.node.properties['device']
)
disassociate_args = utils.update_args(disassociate_args, args)
return self.execute(self.client.detach_volume, disassociate_args,
raise_on_falsy=True)
def create(self, args=None, **_):
"""This allocates an Elastic IP in the connected account."""
ctx.logger.debug('Attempting to allocate elasticip.')
provider_variables = utils.get_provider_variables()
create_args = {}
domain = ctx.node.properties.get(
constants.ELASTICIP['ELASTIC_IP_DOMAIN_PROPERTY']) or \
provider_variables.get(constants.ELASTICIP['VPC_DOMAIN'])
if domain:
create_args[constants.ELASTICIP['ELASTIC_IP_DOMAIN_PROPERTY']] = \
constants.ELASTICIP['VPC_DOMAIN']
create_args = utils.update_args(create_args, args)
try:
address_object = self.execute(self.client.allocate_address,
create_args,
raise_on_falsy=True)
except (exception.EC2ResponseError, exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
if constants.ELASTICIP['VPC_DOMAIN'] in address_object.domain:
ctx.instance.runtime_properties[constants.ELASTICIP[
'ALLOCATION_ID']] = address_object.allocation_id
self.allocation_id = address_object.allocation_id
self.resource_id = address_object.public_ip
return True
def disassociate(self, args=None, **_):
""" Disassocates an Elastic IP created by Cloudify from an EC2 Instance
that was also created by Cloudify.
"""
elasticip = self.target_resource_id
elasticip_object = self.get_target_resource()
if not elasticip_object:
raise NonRecoverableError(
'no matching elastic ip in account: {0}'.format(elasticip))
disassociate_args = dict(
public_ip=elasticip_object.public_ip,
association_id=elasticip_object.association_id
)
disassociate_args = utils.update_args(disassociate_args, args)
try:
self.execute(self.client.disassociate_address,
disassociate_args, raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
return True
def create(self, args):
create_args = self.generate_create_args()
create_args = utils.update_args(create_args, args)
dhcp_options = self.execute(self.client.create_dhcp_options,
create_args,
raise_on_falsy=True)
self.resource_id = dhcp_options.id
return True
def associate(self, args=None):
associate_args = dict(route_table_id=self.source_resource_id,
subnet_id=self.target_resource_id)
associate_args = utils.update_args(associate_args, args)
self.association_id = \
self.execute(self.client.associate_route_table,
associate_args, raise_on_falsy=True)
return True
def create(self, args):
create_args = self.generate_create_args()
create_args = utils.update_args(create_args, args)
ctx.instance.runtime_properties['vpc_id'] = create_args['vpc_id']
network_acl = self.execute(self.client.create_network_acl,
create_args, raise_on_falsy=True)
self.resource_id = network_acl.id
return True
def associate(self, args):
associate_args = dict(
dhcp_options_id=self.source_resource_id,
vpc_id=self.target_resource_id
)
associate_args = utils.update_args(associate_args, args)
return self.execute(self.client.associate_dhcp_options,
associate_args, raise_on_falsy=True)
def create(self, args=None):
'''Override for resource create operation'''
create_args = utils.update_args(self._generate_creation_args(), args)
subnet = self.execute(self.client.create_subnet,
create_args,
raise_on_falsy=True)
self.resource_id = subnet.id
return True
def disassociate(self, args):
disassociate_args = dict(
subnet_id=self.target_resource_id,
vpc_id=ctx.source.instance.runtime_properties['vpc_id']
)
disassociate_args = utils.update_args(disassociate_args, args)
return self.execute(self.client.disassociate_network_acl,
disassociate_args, raise_on_falsy=True)
def associate(self, args):
assoicate_args = dict(network_acl_id=self.source_resource_id,
subnet_id=self.target_resource_id)
assoicate_args = utils.update_args(assoicate_args, args)
self.association_id = \
self.execute(self.client.associate_network_acl,
assoicate_args, raise_on_falsy=True)
return True
def create(self, args=None):
create_args = utils.update_args(self._generate_creation_args(), args)
route_table = \
self.execute(self.client.create_route_table,
create_args, raise_on_falsy=True)
self.resource_id = route_table.id
for route in self.routes:
self.create_route(route_table.id, route, ctx.instance)
return True
def create(self, args=None):
'''Override for resource create operation'''
create_args = utils.update_args(
self._generate_creation_args(), args)
subnet = self.execute(self.client.create_subnet,
create_args, raise_on_falsy=True)
self.resource_id = subnet.id
return True
def disassociate(self, args):
disassociate_args = dict(
subnet_id=self.target_resource_id,
vpc_id=ctx.source.instance.runtime_properties['vpc_id'])
disassociate_args = utils.update_args(disassociate_args, args)
return self.execute(self.client.disassociate_network_acl,
disassociate_args,
raise_on_falsy=True)
def create(self, args):
create_args = self.generate_create_args()
create_args = utils.update_args(create_args, args)
ctx.instance.runtime_properties['vpc_id'] = create_args['vpc_id']
network_acl = self.execute(self.client.create_network_acl,
create_args,
raise_on_falsy=True)
self.resource_id = network_acl.id
return True
def create(self, args):
create_args = dict(type=ctx.node.properties['type'],
ip_address=ctx.node.properties['ip_address'],
bgp_asn=ctx.node.properties['bgp_asn'])
create_args = utils.update_args(create_args, args)
gateway = self.execute(self.client.create_customer_gateway,
create_args,
raise_on_falsy=True)
self.resource_id = gateway.id
return True
def create(self, args):
create_args = dict(type=ctx.node.properties['type'],
availability_zone=ctx.node.properties.get(
'availability_zone', None))
create_args = utils.update_args(create_args, args)
gateway = self.execute(self.client.create_vpn_gateway,
create_args,
raise_on_falsy=True)
self.resource_id = gateway.id
return True
def create(self, args=None):
create_args = utils.update_args(self._generate_creation_args(),
args)
route_table = \
self.execute(self.client.create_route_table,
create_args, raise_on_falsy=True)
self.resource_id = route_table.id
for route in self.routes:
self.create_route(route_table.id, route, ctx.instance)
return True
def associate(self, args=None):
associate_args = dict(
route_table_id=self.source_resource_id,
subnet_id=self.target_resource_id
)
associate_args = utils.update_args(associate_args, args)
self.association_id = \
self.execute(self.client.associate_route_table,
associate_args, raise_on_falsy=True)
return True
def associate(self, args):
assoicate_args = dict(
network_acl_id=self.source_resource_id,
subnet_id=self.target_resource_id
)
assoicate_args = utils.update_args(assoicate_args, args)
self.association_id = \
self.execute(self.client.associate_network_acl,
assoicate_args, raise_on_falsy=True)
return True
def delete(self, args=None, **_):
"""Deletes a keypair."""
key_pair_name = utils.get_external_resource_id_or_raise(
'delete key pair', ctx.instance)
delete_args = {'key_name': key_pair_name}
delete_args = utils.update_args(delete_args, args)
return self.execute(self.client.delete_key_pair,
delete_args,
raise_on_falsy=True)
def create(self, args):
create_args = dict(
type=ctx.node.properties['type'],
availability_zone=ctx.node.properties.get(
'availability_zone', None)
)
create_args = utils.update_args(create_args, args)
gateway = self.execute(self.client.create_vpn_gateway,
create_args, raise_on_falsy=True)
self.resource_id = gateway.id
return True
def disassociate(self, args):
self.delete_routes()
disassociate_args = dict(
vpc_peering_connection_id=self.source_vpc_peering_connection_id
)
disassociate_args = utils.update_args(
disassociate_args,
args)
return self.execute(self.client.delete_vpc_peering_connection,
disassociate_args, raise_on_falsy=True)
def create(self, args):
create_args = dict(
type=ctx.node.properties['type'],
ip_address=ctx.node.properties['ip_address'],
bgp_asn=ctx.node.properties['bgp_asn']
)
create_args = utils.update_args(create_args, args)
gateway = self.execute(self.client.create_customer_gateway,
create_args, raise_on_falsy=True)
self.resource_id = gateway.id
return True
def delete(self, args=None, **_):
network_interface_id = self.resource_id
delete_args = dict(network_interface_id=network_interface_id)
delete_args = utils.update_args(delete_args, args)
output = self.execute(self.client.delete_network_interface,
delete_args,
raise_on_falsy=True)
return output
def delete(self, args):
for route in self.routes:
self.delete_route(ctx.instance.runtime_properties.get(
constants.EXTERNAL_RESOURCE_ID),
route,
route_table_ctx_instance=ctx.instance)
delete_args = dict(route_table_id=ctx.instance.runtime_properties.get(
constants.EXTERNAL_RESOURCE_ID))
delete_args = utils.update_args(delete_args, args)
return self.execute(self.client.delete_route_table,
delete_args,
raise_on_falsy=True)
def delete(self, args=None, **_):
network_interface_id = self.resource_id
delete_args = dict(network_interface_id=network_interface_id)
delete_args = utils.update_args(delete_args, args)
output = self.execute(self.client.delete_network_interface,
delete_args,
raise_on_falsy=True)
return output
def delete(self, args=None, **_):
"""Deletes a keypair."""
key_pair_name = utils.get_external_resource_id_or_raise(
'delete key pair', ctx.instance)
delete_args = {
'key_name': key_pair_name
}
delete_args = utils.update_args(delete_args, args)
return self.execute(self.client.delete_key_pair,
delete_args, raise_on_falsy=True)
def associate(self, args=None, **_):
volume_id = \
utils.get_external_resource_id_or_raise(
'attach volume', ctx.source.instance)
instance_id = \
utils.get_external_resource_id_or_raise(
'attach volume', ctx.target.instance)
if ctx.source.node.properties[constants.ZONE] not in \
ctx.target.instance.runtime_properties.get('placement'):
ctx.logger.info(
'Volume Zone {0} and Instance Zone {1} do not match. '
'This may lead to an error.'.format(
ctx.source.node.properties[constants.ZONE],
ctx.target.instance.runtime_properties
.get('placement')
)
)
volume_object = self.get_source_resource()
if not volume_object:
raise NonRecoverableError(
'EBS volume {0} not found in account.'.format(volume_id))
if constants.EBS['VOLUME_CREATING'] in volume_object.update():
return False
elif constants.EBS['VOLUME_AVAILABLE'] not in volume_object.update():
raise NonRecoverableError(
'Cannot attach Volume {0} because it is in state {1}.'
.format(volume_object.id, volume_object.status))
associate_args = dict(
volume_id=volume_id,
instance_id=instance_id,
device=ctx.source.node.properties['device']
)
associate_args = utils.update_args(associate_args, args)
out = self.execute(self.client.attach_volume,
associate_args,
raise_on_falsy=True)
volume = associate_args.get('volume_id')
self.target_resource_id = associate_args.get('instance_id')
device = associate_args.get('device')
ctx.source.instance.runtime_properties['device'] = device
ctx.target.instance.runtime_properties[
'{0}-device'.format(volume)] = device
return out
def create(self, args=None, **_):
create_args = ctx.node.properties['parameters']
list_of_subnets = \
utils.get_target_external_resource_ids(
'cloudify.aws.relationships.connected_to_subnet', ctx.instance
)
if not list_of_subnets:
ctx.logger.debug('There is no relationship of type '
'cloudify.aws.relationships.connected_to_subnet '
'The user is expected to provide a '
'parameters.subnet_id property.')
elif len(list_of_subnets) == 1:
ctx.logger.info('Setting subnet ID to {0}'
.format(list_of_subnets[0]))
create_args.update({'subnet_id': list_of_subnets[0]})
elif len(list_of_subnets) > 1 \
or len(list_of_subnets) == 1 and \
ctx.node.properties['parameters'].get('subnet_id') is not None:
raise NonRecoverableError(
'More than one subnet was specified. '
'A network interface can only exist in one subnet.'
)
list_of_groups = \
utils.get_target_external_resource_ids(
'cloudify.aws.relationships.connected_to_security_group',
ctx.instance
)
if list_of_groups:
create_args.update({'groups': list_of_groups})
create_args = utils.update_args(create_args, args)
ctx.logger.info(
'Attempting to create Network Interface with these API '
'parameters: {0}.'
.format(create_args))
try:
network_interface = self.execute(
self.client.create_network_interface,
create_args, raise_on_falsy=True)
except (exception.EC2ResponseError,
exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
self.resource_id = network_interface.id
return True
def disassociate(self, args):
if self.routes:
for route in self.routes:
args = self.generate_route_args(self.vpn_connection_id, route)
if self.execute(
self.client.delete_vpn_connection_route,
args, raise_on_falsy=True):
ctx.source.instance.runtime_properties['routes'].remove(
route)
disassociate_args = dict(vpn_connection_id=self.vpn_connection_id)
disassociate_args = utils.update_args(disassociate_args, args)
return self.execute(self.client.delete_vpn_connection,
disassociate_args, raise_on_falsy=True)
def disassociate(self, args):
if self.routes:
for route in self.routes:
args = self.generate_route_args(self.vpn_connection_id, route)
if self.execute(self.client.delete_vpn_connection_route,
args,
raise_on_falsy=True):
ctx.source.instance.runtime_properties['routes'].remove(
route)
disassociate_args = dict(vpn_connection_id=self.vpn_connection_id)
disassociate_args = utils.update_args(disassociate_args, args)
return self.execute(self.client.delete_vpn_connection,
disassociate_args,
raise_on_falsy=True)
def create(self, args=None, **_):
create_args = ctx.node.properties['parameters']
list_of_subnets = \
utils.get_target_external_resource_ids(
'cloudify.aws.relationships.connected_to_subnet', ctx.instance
)
if not list_of_subnets:
ctx.logger.debug('There is no relationship of type '
'cloudify.aws.relationships.connected_to_subnet '
'The user is expected to provide a '
'parameters.subnet_id property.')
elif len(list_of_subnets) == 1:
ctx.logger.info('Setting subnet ID to {0}'.format(
list_of_subnets[0]))
create_args.update({'subnet_id': list_of_subnets[0]})
elif len(list_of_subnets) > 1 \
or len(list_of_subnets) == 1 and \
ctx.node.properties['parameters'].get('subnet_id') is not None:
raise NonRecoverableError(
'More than one subnet was specified. '
'A network interface can only exist in one subnet.')
list_of_groups = \
utils.get_target_external_resource_ids(
'cloudify.aws.relationships.connected_to_security_group',
ctx.instance
)
if list_of_groups:
create_args.update({'groups': list_of_groups})
create_args = utils.update_args(create_args, args)
ctx.logger.info(
'Attempting to create Network Interface with these API '
'parameters: {0}.'.format(create_args))
try:
network_interface = self.execute(
self.client.create_network_interface,
create_args,
raise_on_falsy=True)
except (exception.EC2ResponseError, exception.BotoServerError) as e:
raise NonRecoverableError('{0}'.format(str(e)))
self.resource_id = network_interface.id
return True
def delete(self, args=None, **_):
delete_args = dict(name=ctx.node.properties['elb_name'])
delete_args = utils.update_args(delete_args, args)
try:
self.execute(self.client.delete_load_balancer,
delete_args,
raise_on_falsy=True)
except (exception.EC2ResponseError, exception.BotoServerError,
exception.BotoClientError) as e:
raise NonRecoverableError('Load Balancer {0} not deleted.'.format(
str(e)))
return True
def _get_instance_parameters(self, args=None):
"""The parameters to the run_instance boto call.
:returns parameters dictionary
"""
provider_variables = utils.get_provider_variables()
attached_group_ids = \
utils.get_target_external_resource_ids(
constants.INSTANCE_SECURITY_GROUP_RELATIONSHIP,
ctx.instance)
if provider_variables.get(constants.AGENTS_SECURITY_GROUP):
attached_group_ids.append(
provider_variables[constants.AGENTS_SECURITY_GROUP])
parameters = \
provider_variables.get(constants.AGENTS_AWS_INSTANCE_PARAMETERS)
parameters.update({
'image_id': ctx.node.properties['image_id'],
'instance_type': ctx.node.properties['instance_type'],
'security_group_ids': attached_group_ids,
'key_name': self._get_instance_keypair(provider_variables)
})
network_interfaces_collection = \
self._get_network_interfaces(
parameters.get('network_interfaces', []))
if network_interfaces_collection:
parameters.update({
'network_interfaces': network_interfaces_collection
})
else:
parameters.update({
'subnet_id': self._get_instance_subnet(provider_variables)
})
parameters.update(ctx.node.properties['parameters'])
parameters = self._handle_userdata(parameters)
parameters = utils.update_args(parameters, args)
parameters['block_device_map'] = \
self._create_block_device_mapping(
parameters.get('block_device_map', {})
)
return parameters
def delete(self, args):
for route in self.routes:
self.delete_route(
ctx.instance.runtime_properties.get(
constants.EXTERNAL_RESOURCE_ID),
route,
route_table_ctx_instance=ctx.instance
)
delete_args = dict(
route_table_id=ctx.instance.runtime_properties.get(
constants.EXTERNAL_RESOURCE_ID
)
)
delete_args = utils.update_args(delete_args, args)
return self.execute(self.client.delete_route_table,
delete_args, raise_on_falsy=True)
def create(self, args=None, **_):
"""Creates an EBS volume.
"""
create_volume_args = dict(size=ctx.node.properties['size'],
zone=ctx.node.properties[constants.ZONE])
create_volume_args = utils.update_args(create_volume_args, args)
new_volume = self.execute(self.client.create_volume,
create_volume_args,
raise_on_falsy=True)
ctx.instance.runtime_properties[constants.ZONE] = new_volume.zone
self.resource_id = new_volume.id
return True
def create(self, args):
create_args = dict(
cidr_block=ctx.node.properties['cidr_block'],
instance_tenancy=ctx.node.properties['instance_tenancy']
)
create_args = utils.update_args(
create_args,
args)
vpc = self.execute(self.client.create_vpc,
create_args, raise_on_falsy=True)
self.resource_id = vpc.id
utils.set_external_resource_id(vpc.id, ctx.instance)
ctx.instance.runtime_properties['default_dhcp_options_id'] = \
vpc.dhcp_options_id
return True
