def _to_aws_encoding(instring):
'''
A partial implememtation of the `AWS domain encoding`__ rules. The punycode section is
ignored for now, so you'll have to input any unicode characters already punycoded.
.. __: http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DomainNameFormat.html
The only breakage is that we don't permit ASCII 92 ('backslash') in domain names, even though
AWS seems to allow it, becuase it's used to introduce octal escapes, and I can't think of a
good way to allow it while still parsing those escapes. Imagine a domain name containing the
literal string '\134' - pathological to be sure, but allowed by AWS's rules. If someone
dislikes this restriction, feel free to update this function to correctly handle such madness.
Oh, and the idea of allowing '.' (period) within a domain component (e.g. not as a separator,
but as part of a field) is as stupid it sounds, and is also not supported by these functions.
Again, if you can figure out a sensible way to make it work, more power too you. If you
REALLY need this, just embed '\056' directly in your strings. I can't promise it won't break
your DNS out in the real world though.
'''
instring = instring.lower() # Always lowercase
send_as_is_get_the_same_back = list(range(97,
123)) # a-z is 97-122 inclusive
send_as_is_get_the_same_back += [
ord(n) for n in
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_', '.']
]
send_as_is_get_octal_back = [
ord(n) for n in [
'!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '/',
'\\', ':', ';', '<', '=', '>', '?', '@', '[', ']', '^', '`', '{',
'|', '}'
]
]
# Non-printable ASCII - AWS claims it's valid in DNS entries... YMMV
acceptable_points_which_must_be_octalized = list(range(
0, 33)) # 0-32 inclusive
# "Extended ASCII" stuff
acceptable_points_which_must_be_octalized += list(range(
127, 256)) # 127-255 inclusive
# ^^^ This, BTW, is incompatible with punycode as far as I can tell, since unicode only aligns
# with ASCII for the first 127 code-points... Oh well.
outlist = []
for char in instring:
point = ord(char)
octal = '\\{:03o}'.format(point)
if point in send_as_is_get_the_same_back:
outlist += [char]
elif point in send_as_is_get_octal_back:
outlist += [char]
elif point in acceptable_points_which_must_be_octalized:
outlist += [octal]
else:
raise SaltInvocationError(
"Invalid Route53 domain character seen (octal {0}) in string "
"{1}. Do you need to punycode it?".format(octal, instring))
ret = ''.join(outlist)
log.debug('Name after massaging is: {}'.format(ret))
return ret
def rr_absent(name,
HostedZoneId=None,
DomainName=None,
PrivateZone=False,
Name=None,
Type=None,
SetIdentifier=None,
region=None,
key=None,
keyid=None,
profile=None):
'''
Ensure the Route53 record is deleted.
name
The name of the state definition. This will be used for Name if the latter is
not provided.
HostedZoneId
The ID of the zone to delete the record from. Exclusive with DomainName.
DomainName
The domain name of the zone to delete the record from. Exclusive with HostedZoneId.
PrivateZone
Set to True if the RR to be removed is in a private zone, False if public.
Name
Name of the resource record.
Type
The record type (A, NS, MX, TXT, etc.)
SetIdentifier
Valid for Weighted, Latency, Geolocation, and Failover resource record sets only.
An identifier that differentiates among multiple resource record sets that have the same
combination of DNS name and type. The value of SetIdentifier must be unique for each
resource record set that has the same combination of DNS name and type. Omit SetIdentifier
for any other types of record sets.
region
The region to connect to.
key
Secret key to be used.
keyid
Access key to be used.
profile
Dict, or pillar key pointing to a dict, containing AWS region/key/keyid.
'''
Name = Name if Name else name
Name = _to_aws_encoding(Name)
if Type is None:
raise SaltInvocationError(
"'Type' is a required parameter when deleting resource records.")
ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
args = {
'Id': HostedZoneId,
'Name': DomainName,
'PrivateZone': PrivateZone,
'region': region,
'key': key,
'keyid': keyid,
'profile': profile
}
zone = __salt__['boto3_route53.find_hosted_zone'](**args)
if not zone:
ret['comment'] = 'Route 53 {} hosted zone {} not found'.format(
'private' if PrivateZone else 'public', DomainName)
log.info(ret['comment'])
return ret
zone = zone[0]
HostedZoneId = zone['HostedZone']['Id']
recordsets = __salt__['boto3_route53.get_resource_records'](
HostedZoneId=HostedZoneId,
StartRecordName=Name,
StartRecordType=Type,
region=region,
key=key,
keyid=keyid,
profile=profile)
if SetIdentifier and recordsets:
log.debug('Filter recordsets {} by SetIdentifier {}.'.format(
recordsets, SetIdentifier))
recordsets = [
r for r in recordsets if r.get('SetIdentifier') == SetIdentifier
]
log.debug('Resulted in recordsets {}.'.format(recordsets))
if not recordsets:
ret['comment'] = 'Route 53 resource record {} with type {} already absent.'.format(
Name, Type)
return ret
elif len(recordsets) > 1:
ret['comment'] = 'Given criteria matched more than one ResourceRecordSet.'
log.error(ret['comment'])
ret['result'] = False
return ret
ResourceRecordSet = recordsets[0]
if __opts__['test']:
ret['comment'] = 'Route 53 resource record {} with type {} would be deleted.'.format(
Name, Type)
ret['result'] = None
return ret
ChangeBatch = {
'Changes': [{
'Action': 'DELETE',
'ResourceRecordSet': ResourceRecordSet,
}]
}
if __salt__['boto3_route53.change_resource_record_sets'](
HostedZoneId=HostedZoneId,
ChangeBatch=ChangeBatch,
region=region,
key=key,
keyid=keyid,
profile=profile):
ret['comment'] = 'Route 53 resource record {} with type {} deleted.'.format(
Name, Type)
log.info(ret['comment'])
ret['changes']['old'] = ResourceRecordSet
ret['changes']['new'] = None
else:
ret['comment'] = 'Failed to delete Route 53 resource record {} with type {}.'.format(
Name, Type)
log.error(ret['comment'])
ret['result'] = False
return ret
def hosted_zone_present(name,
Name=None,
PrivateZone=False,
CallerReference=None,
Comment='',
VPCs=None,
region=None,
key=None,
keyid=None,
profile=None):
'''
Ensure a hosted zone exists with the given attributes.
name
The name of the state definition. This will be used as the 'CallerReference' param when
creating the hosted zone to help ensure idempotency.
Name
The name of the domain. This should be a fully-specified domain, and should terminate with a
period. This is the name you have registered with your DNS registrar. It is also the name
you will delegate from your registrar to the Amazon Route 53 delegation servers returned in
response to this request. If not provided, the value of name will be used.
PrivateZone
Set True if creating a private hosted zone. If true, then 'VPCs' is also required.
Comment
Any comments you want to include about the hosted zone.
CallerReference
A unique string that identifies the request and that allows create_hosted_zone() calls to be
retried without the risk of executing the operation twice. This helps ensure idempotency
across state calls, but can cause issues if a zone is deleted and then an attempt is made
to recreate it with the same CallerReference. If not provided, a unique UUID will be
generated at each state run, which can potentially lead to duplicate zones being created if
the state is run again while the previous zone creation is still in PENDING status (which
can occasionally take several minutes to clear). Maximum length of 128.
VPCs
A list of dicts, each dict composed of a VPCRegion, and either a VPCId or a VPCName.
Note that this param is ONLY used if PrivateZone == True
VPCId
When creating a private hosted zone, either the VPC ID or VPC Name to associate with is
required. Exclusive with VPCName.
VPCName
When creating a private hosted zone, either the VPC ID or VPC Name to associate with is
required. Exclusive with VPCId.
VPCRegion
When creating a private hosted zone, the region of the associated VPC is required. If
not provided, an effort will be made to determine it from VPCId or VPCName, if
possible. This will fail if a given VPCName exists in multiple regions visible to the
bound account, in which case you'll need to provide an explicit value for VPCRegion.
'''
Name = Name if Name else name
Name = _to_aws_encoding(Name)
ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
if not PrivateZone and VPCs:
raise SaltInvocationError(
"Parameter 'VPCs' is invalid when creating a public zone.")
if PrivateZone and not VPCs:
raise SaltInvocationError(
"Parameter 'VPCs' is required when creating a private zone.")
if VPCs:
if not isinstance(VPCs, list):
raise SaltInvocationError(
"Parameter 'VPCs' must be a list of dicts.")
for v in VPCs:
if not isinstance(v, dict) or not exactly_one(
(v.get('VPCId'), v.get('VPCName'))):
raise SaltInvocationError(
"Parameter 'VPCs' must be a list of dicts, each composed "
"of either a 'VPCId' or a 'VPCName', and optionally a "
"'VPCRegion', to help distinguish between multitple matches."
)
# Massage VPCs into something AWS will accept...
fixed_vpcs = []
if PrivateZone:
for v in VPCs:
VPCId = v.get('VPCId')
VPCName = v.get('VPCName')
VPCRegion = v.get('VPCRegion')
VPCs = __salt__['boto_vpc.describe_vpcs'](vpc_id=VPCId,
name=VPCName,
region=region,
key=key,
keyid=keyid,
profile=profile).get(
'vpcs', [])
if VPCRegion and VPCs:
VPCs = [v for v in VPCs if v['region'] == VPCRegion]
if not VPCs:
ret['comment'] = (
'A VPC matching given criteria (vpc: {0} / vpc_region: {1}) not '
'found.'.format(VPCName or VPCId, VPCRegion))
log.error(ret['comment'])
ret['result'] = False
return ret
if len(VPCs) > 1:
ret['comment'] = (
'Multiple VPCs matching given criteria (vpc: {0} / vpc_region: '
'{1}) found: {2}.'.format(
VPCName or VPCId, VPCRegion,
', '.join([v['id'] for v in VPCs])))
log.error(ret['comment'])
ret['result'] = False
return ret
vpc = VPCs[0]
if VPCName:
VPCId = vpc['id']
if not VPCRegion:
VPCRegion = vpc['region']
fixed_vpcs += [{'VPCId': VPCId, 'VPCRegion': VPCRegion}]
create = False
update_comment = False
add_vpcs = []
del_vpcs = []
args = {
'Name': Name,
'PrivateZone': PrivateZone,
'region': region,
'key': key,
'keyid': keyid,
'profile': profile
}
zone = __salt__['boto3_route53.find_hosted_zone'](**args)
if not zone:
create = True
# Grrrr - can only pass one VPC when initially creating a private zone...
# The rest have to be added (one-by-one) later in a separate step.
if len(fixed_vpcs) > 1:
add_vpcs = fixed_vpcs[1:]
fixed_vpcs = fixed_vpcs[:1]
CallerReference = CallerReference if CallerReference else str(
uuid.uuid4())
else:
# Currently the only modifiable traits about a zone are associated VPCs and the comment.
zone = zone[0]
if PrivateZone:
for z in zone.get('VPCs'):
if z not in fixed_vpcs:
del_vpcs += [z]
for z in fixed_vpcs:
if z not in zone.get('VPCs'):
add_vpcs += [z]
if zone['HostedZone']['Config'].get('Comment') != Comment:
update_comment = True
if not (create or add_vpcs or del_vpcs or update_comment):
ret['comment'] = 'Hostd Zone {0} already in desired state'.format(Name)
return ret
if create:
if __opts__['test']:
ret['comment'] = 'Route 53 {} hosted zone {} would be created.'.format(
'private' if PrivateZone else 'public', Name)
ret['result'] = None
return ret
vpc_id = fixed_vpcs[0].get('VPCId') if fixed_vpcs else None
vpc_region = fixed_vpcs[0].get('VPCRegion') if fixed_vpcs else None
newzone = __salt__['boto3_route53.create_hosted_zone'](
Name=Name,
CallerReference=CallerReference,
Comment=Comment,
PrivateZone=PrivateZone,
VPCId=vpc_id,
VPCRegion=vpc_region,
region=region,
key=key,
keyid=keyid,
profile=profile)
if newzone:
newzone = newzone[0]
ret['comment'] = 'Route 53 {} hosted zone {} successfully created'.format(
'private' if PrivateZone else 'public', Name)
log.info(ret['comment'])
ret['changes']['new'] = newzone
else:
ret['comment'] = 'Creation of Route 53 {} hosted zone {} failed'.format(
'private' if PrivateZone else 'public', Name)
log.error(ret['comment'])
ret['result'] = False
return ret
if update_comment:
if __opts__['test']:
ret['comment'] = 'Route 53 {} hosted zone {} comment would be updated.'.format(
'private' if PrivateZone else 'public', Name)
ret['result'] = None
return ret
r = __salt__['boto3_route53.update_hosted_zone_comment'](
Name=Name,
Comment=Comment,
PrivateZone=PrivateZone,
region=region,
key=key,
keyid=keyid,
profile=profile)
if r:
r = r[0]
msg = 'Route 53 {} hosted zone {} comment successfully updated'.format(
'private' if PrivateZone else 'public', Name)
log.info(msg)
ret['comment'] = ' '.join([ret['comment'], msg])
ret['changes']['old'] = zone
ret['changes']['new'] = dictupdate.update(
ret['changes'].get('new', {}), r)
else:
ret['comment'] = 'Update of Route 53 {} hosted zone {} comment failed'.format(
'private' if PrivateZone else 'public', Name)
log.error(ret['comment'])
ret['result'] = False
return ret
if add_vpcs or del_vpcs:
if __opts__['test']:
ret['comment'] = 'Route 53 {} hosted zone {} associated VPCs would be updated.'.format(
'private' if PrivateZone else 'public', Name)
ret['result'] = None
return ret
all_added = True
all_deled = True
for vpc in add_vpcs: # Add any new first to avoid the "can't delete last VPC" errors.
r = __salt__['boto3_route53.associate_vpc_with_hosted_zone'](
Name=Name,
VPCId=vpc['VPCId'],
VPCRegion=vpc['VPCRegion'],
region=region,
key=key,
keyid=keyid,
profile=profile)
if not r:
all_added = False
for vpc in del_vpcs:
r = __salt__['boto3_route53.disassociate_vpc_from_hosted_zone'](
Name=Name,
VPCId=vpc['VPCId'],
VPCRegion=vpc['VPCRegion'],
region=region,
key=key,
keyid=keyid,
profile=profile)
if not r:
all_deled = False
ret['changes']['old'] = zone
ret['changes']['new'] = __salt__['boto3_route53.find_hosted_zone'](
**args)
if all_added and all_deled:
msg = 'Route 53 {} hosted zone {} associated VPCs successfully updated'.format(
'private' if PrivateZone else 'public', Name)
log.info(msg)
ret['comment'] = ' '.join([ret['comment'], msg])
else:
ret['comment'] = 'Update of Route 53 {} hosted zone {} associated VPCs failed'.format(
'private' if PrivateZone else 'public', Name)
log.error(ret['comment'])
ret['result'] = False
return ret
return ret
def rr_present(name,
HostedZoneId=None,
DomainName=None,
PrivateZone=False,
Name=None,
Type=None,
SetIdentifier=None,
Weight=None,
Region=None,
GeoLocation=None,
Failover=None,
TTL=None,
ResourceRecords=None,
AliasTarget=None,
HealthCheckId=None,
TrafficPolicyInstanceId=None,
region=None,
key=None,
keyid=None,
profile=None):
'''
Ensure the Route53 record is present.
name
The name of the state definition. This will be used for Name if the latter is
not provided.
HostedZoneId
The ID of a zone to create the record in. Exclusive with DomainName.
DomainName
The domain name of a zone to create the record in. Exclusive with HostedZoneId.
PrivateZone
Set to True if the resource record should be in a private zone, False if public.
Name
Name of the Route 53 resource record being managed.
Type
The record type (A, NS, MX, TXT, etc.)
SetIdentifier
Valid for Weighted, Latency, Geolocation, and Failover resource record sets only.
An identifier that differentiates among multiple resource record sets that have the same
combination of DNS name and type. The value of SetIdentifier must be unique for each
resource record set that has the same combination of DNS name and type. Omit SetIdentifier
for any other types of record sets.
Weight
Valid for Weighted resource record sets only. Among resource record sets that have the
same combination of DNS name and type, a value that determines the proportion of DNS
queries that Amazon Route 53 responds to using the current resource record set. Amazon Route
53 calculates the sum of the weights for the resource record sets that have the same
combination of DNS name and type. Amazon Route 53 then responds to queries based on the
ratio of a resource's weight to the total.
Note the following:
- You must specify a value for the Weight element for every weighted resource record set.
- You can only specify one ResourceRecord per weighted resource record set.
- You can't create latency, failover, or geolocation resource record sets that have the
same values for the Name and Type elements as weighted resource record sets.
- You can create a maximum of 100 weighted resource record sets that have the same values
for the Name and Type elements.
- For weighted (but not weighted alias) resource record sets, if you set Weight to 0 for a
resource record set, Amazon Route 53 never responds to queries with the applicable value
for that resource record set. However, if you set Weight to 0 for all resource record
sets that have the same combination of DNS name and type, traffic is routed to all
resources with equal probability. The effect of setting Weight to 0 is different when
you associate health checks with weighted resource record sets. For more information,
see `Options for Configuring Amazon Route 53 Active-Active and Active-Passive Failover`__
in the Amazon Route 53 Developer Guide.
.. __: http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html
Region
Valid for Latency-based resource record sets only. The Amazon EC2 Region where the resource
that is specified in this resource record set resides. The resource typically is an AWS
resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP
address or a DNS domain name, depending on the record type.
GeoLocation
Geo location resource record sets only. A dict that lets you control how Route 53 responds
to DNS queries based on the geographic origin of the query. For example, if you want all
queries from Africa to be routed to a web server with an IP address of 192.0.2.111, create a
resource record set with a Type of A and a ContinentCode of AF.
ContinentCode
The two-letter code for the continent.
Valid values: AF | AN | AS | EU | OC | NA | SA
Constraint: Specifying ContinentCode with either CountryCode or SubdivisionCode
returns an InvalidInput error.
CountryCode
The two-letter code for the country.
SubdivisionCode
The code for the subdivision, for example, a state in the United States or a
province in Canada.
Notes
- Creating geolocation and geolocation alias resource record sets in private hosted zones
is not supported.
- If you create separate resource record sets for overlapping geographic regions (for
example, one resource record set for a continent and one for a country on the same
continent), priority goes to the smallest geographic region. This allows you to route
most queries for a continent to one resource and to route queries for a country on that
continent to a different resource.
- You can't create two geolocation resource record sets that specify the same geographic
location.
- The value * in the CountryCode element matches all geographic locations that aren't
specified in other geolocation resource record sets that have the same values for the
Name and Type elements.
- Geolocation works by mapping IP addresses to locations. However, some IP addresses
aren't mapped to geographic locations, so even if you create geolocation resource
record sets that cover all seven continents, Amazon Route 53 will receive some DNS
queries from locations that it can't identify. We recommend that you create a resource
record set for which the value of CountryCode is *, which handles both queries that
come from locations for which you haven't created geolocation resource record sets and
queries from IP addresses that aren't mapped to a location. If you don't create a *
resource record set, Amazon Route 53 returns a "no answer" response for queries from
those locations.
- You can't create non-geolocation resource record sets that have the same values for the
Name and Type elements as geolocation resource record sets.
TTL
The resource record cache time to live (TTL), in seconds.
Note the following:
- If you're creating an alias resource record set, omit TTL. Amazon Route 53 uses the
value of TTL for the alias target.
- If you're associating this resource record set with a health check (if you're adding
a HealthCheckId element), we recommend that you specify a TTL of 60 seconds or less so
clients respond quickly to changes in health status.
- All of the resource record sets in a group of weighted, latency, geolocation, or
failover resource record sets must have the same value for TTL.
- If a group of weighted resource record sets includes one or more weighted alias
resource record sets for which the alias target is an ELB load balancer, we recommend
that you specify a TTL of 60 seconds for all of the non-alias weighted resource record
sets that have the same name and type. Values other than 60 seconds (the TTL for load
balancers) will change the effect of the values that you specify for Weight.
ResourceRecords
A list, containing one or more values for the resource record. No single value can exceed
4,000 characters. For details on how to format values for different record types, see
`Supported DNS Resource Record Types`__ in the Amazon Route 53 Developer Guide.
.. __: http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html
Note: You can specify more than one value for all record types except CNAME and SOA.
It is also possible to pass "magic" strings as resource record values. This functionality
can easily be extended, but for the moment supports the following:
'magic:ec2_instance_tag:some_tag_name:some_string:some_instance_attr'
This tells salt to lookup an EC2 instance with a tag 'some_tag_name' which has the value
'some_string' and substitute the 'some_instance_attr' attribute of that instance as the
resource record value being evaluated.
This should work generally for any EC2 instance tags, as long as the instance attribute
being fetched is available to getattr(instance, 'attribute') as seen in the code below.
Anything else will most likely require this function to be extended to handle it.
The canonical use-case for this (at least at our site) is to query the Name tag (which
we always populate with the host's FQDN) to lookup the public or private IPs bound to the
instance, so we can then automgically create Route 53 records for them.
AliasTarget
The rules governing how to define an AliasTarget for the various supported use-cases are
obtuse beyond reason and attempting to paraphrase them (or even worse, cut-and-paste them
in their entirety) would be silly and counterproductive. If you need this feature, then
Read The Fine Materials at the `Boto 3 Route 53 page`__ and/or the `AWS Route 53 docs`__
and suss them for yourself - I sure won't claim to understand them partcularly well.
.. __: http://boto3.readthedocs.io/en/latest/reference/services/route53.html#Route53.Client.change_resource_record_sets
.. __: http://docs.aws.amazon.com/Route53/latest/APIReference/API_AliasTarget.html
region
The region to connect to.
key
Secret key to be used.
keyid
Access key to be used.
profile
Dict, or pillar key pointing to a dict, containing AWS region/key/keyid.
'''
Name = Name if Name else name
Name = _to_aws_encoding(Name)
if Type is None:
raise SaltInvocationError(
"'Type' is a required parameter when adding or updating"
"resource records.")
ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
args = {
'Id': HostedZoneId,
'Name': DomainName,
'PrivateZone': PrivateZone,
'region': region,
'key': key,
'keyid': keyid,
'profile': profile
}
zone = __salt__['boto3_route53.find_hosted_zone'](**args)
if not zone:
ret['comment'] = 'Route 53 {} hosted zone {} not found'.format(
'private' if PrivateZone else 'public', DomainName)
log.info(ret['comment'])
return ret
zone = zone[0]
HostedZoneId = zone['HostedZone']['Id']
# Convert any magic RR values to something AWS will understand, and otherwise clean them up.
fixed_rrs = []
for rr in ResourceRecords:
if rr.startswith('magic:'):
fields = rr.split(':')
if fields[1] == 'ec2_instance_tag':
if len(fields) != 5:
log.warning(
"Invalid magic RR value seen: '{}'. Passing as-is.".
format(rr))
fixed_rrs += [rr]
continue
tag_name = fields[2]
tag_value = fields[3]
instance_attr = fields[4]
good_states = ('pending', 'rebooting', 'running', 'stopping',
'stopped')
r = __salt__['boto_ec2.find_instances'](tags={
tag_name: tag_value
},
return_objs=True,
in_states=good_states,
region=region,
key=key,
keyid=keyid,
profile=profile)
if len(r) < 1:
ret['comment'] = 'No EC2 instance with tag {} == {} found'.format(
tag_name, tag_value)
log.error(ret['comment'])
ret['result'] = False
return ret
if len(r) > 1:
ret['comment'] = 'Multiple EC2 instances with tag {} == {} found'.format(
tag_name, tag_value)
log.error(ret['comment'])
ret['result'] = False
return ret
instance = r[0]
res = getattr(instance, instance_attr, None)
if res:
log.debug('Found {} {} for instance {}'.format(
instance_attr, res, instance.id))
fixed_rrs += [_to_aws_encoding(res)]
else:
ret['comment'] = 'Attribute {} not found on instance {}'.format(
instance_attr, instance.id)
log.error(ret['comment'])
ret['result'] = False
return ret
else:
ret['comment'] = (
'Unknown RR magic value seen: {}. Please extend the '
'boto3_route53 state module to add support for your preferred '
'incantation.'.format(fields[1]))
log.error(ret['comment'])
ret['result'] = False
return ret
else:
fixed_rrs += [rr]
ResourceRecords = [{'Value': rr} for rr in sorted(fixed_rrs)]
recordsets = __salt__['boto3_route53.get_resource_records'](
HostedZoneId=HostedZoneId,
StartRecordName=Name,
StartRecordType=Type,
region=region,
key=key,
keyid=keyid,
profile=profile)
if SetIdentifier and recordsets:
log.debug('Filter recordsets {} by SetIdentifier {}.'.format(
recordsets, SetIdentifier))
recordsets = [
r for r in recordsets if r.get('SetIdentifier') == SetIdentifier
]
log.debug('Resulted in recordsets {}.'.format(recordsets))
create = False
update = False
updatable = [
'SetIdentifier', 'Weight', 'Region', 'GeoLocation', 'Failover', 'TTL',
'AliasTarget', 'HealthCheckId', 'TrafficPolicyInstanceId'
]
if not recordsets:
create = True
if __opts__['test']:
ret['comment'] = 'Route 53 resource record {} with type {} would be added.'.format(
Name, Type)
ret['result'] = None
return ret
elif len(recordsets) > 1:
ret['comment'] = 'Given criteria matched more than one ResourceRecordSet.'
log.error(ret['comment'])
ret['result'] = False
return ret
else:
rrset = recordsets[0]
for u in updatable:
if locals().get(u) != rrset.get(u):
update = True
break
if ResourceRecords != sorted(rrset.get('ResourceRecords'),
key=lambda x: x['Value']):
update = True
if not create and not update:
ret['comment'] = (
'Route 53 resource record {} with type {} is already in the desired state.'
''.format(Name, Type))
log.info(ret['comment'])
return ret
else:
if __opts__['test']:
ret['comment'] = 'Route 53 resource record {} with type {} would be updated.'.format(
Name, Type)
ret['result'] = None
return ret
ResourceRecordSet = {
'Name': Name,
'Type': Type,
'ResourceRecords': ResourceRecords
}
for u in updatable:
ResourceRecordSet.update({u: locals().get(u)
}) if locals().get(u) else None
ChangeBatch = {
'Changes': [{
'Action': 'UPSERT',
'ResourceRecordSet': ResourceRecordSet,
}]
}
if __salt__['boto3_route53.change_resource_record_sets'](
HostedZoneId=HostedZoneId,
ChangeBatch=ChangeBatch,
region=region,
key=key,
keyid=keyid,
profile=profile):
ret['comment'] = 'Route 53 resource record {} with type {} {}.'.format(
Name, Type, 'created' if create else 'updated')
log.info(ret['comment'])
if create:
ret['changes']['old'] = None
else:
ret['changes']['old'] = rrset
ret['changes']['new'] = ResourceRecordSet
else:
ret['comment'] = 'Failed to {} Route 53 resource record {} with type {}.'.format(
'create' if create else 'update', Name, Type)
log.error(ret['comment'])
ret['result'] = False
return ret
def hosted_zone_present(name,
domain_name=None,
private_zone=False,
comment='',
vpc_id=None,
vpc_name=None,
vpc_region=None,
region=None,
key=None,
keyid=None,
profile=None):
'''
Ensure a hosted zone exists with the given attributes. Note that most
things cannot be modified once a zone is created - it must be deleted and
re-spun to update these attributes:
- private_zone (AWS API limitation).
- comment (the appropriate call exists in the AWS API and in boto3, but
has not, as of this writing, been added to boto2).
- vpc_id (same story - we really need to rewrite this module with boto3)
- vpc_name (really just a pointer to vpc_id anyway).
- vpc_region (again, supported in boto3 but not boto2).
name
The name of the state definition. This will be used as the 'caller_ref'
param if/when creating the hosted zone.
domain_name
The name of the domain. This should be a fully-specified domain, and
should terminate with a period. This is the name you have registered
with your DNS registrar. It is also the name you will delegate from your
registrar to the Amazon Route 53 delegation servers returned in response
to this request. Defaults to the value of name if not provided.
comment
Any comments you want to include about the hosted zone.
private_zone
Set True if creating a private hosted zone.
vpc_id
When creating a private hosted zone, either the VPC ID or VPC Name to
associate with is required. Exclusive with vpe_name. Ignored if passed
for a non-private zone.
vpc_name
When creating a private hosted zone, either the VPC ID or VPC Name to
associate with is required. Exclusive with vpe_id. Ignored if passed
for a non-private zone.
vpc_region
When creating a private hosted zone, the region of the associated VPC is
required. If not provided, an effort will be made to determine it from
vpc_id or vpc_name, if possible. If this fails, you'll need to provide
an explicit value for this option. Ignored if passed for a non-private
zone.
'''
domain_name = domain_name if domain_name else name
ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
# First translaste vpc_name into a vpc_id if possible
if private_zone:
if not exactly_one((vpc_name, vpc_id)):
raise SaltInvocationError('Either vpc_name or vpc_id is required '
'when creating a private zone.')
vpcs = __salt__['boto_vpc.describe_vpcs'](vpc_id=vpc_id,
name=vpc_name,
region=region,
key=key,
keyid=keyid,
profile=profile).get(
'vpcs', [])
if vpc_region and vpcs:
vpcs = [v for v in vpcs if v['region'] == vpc_region]
if not vpcs:
msg = ('Private zone requested but a VPC matching given criteria '
'not found.')
log.error(msg)
ret['result'] = False
ret['comment'] = msg
return ret
if len(vpcs) > 1:
msg = ('Private zone requested but multiple VPCs matching given '
'criteria found: {0}.'.format([v['id'] for v in vpcs]))
log.error(msg)
return None
vpc = vpcs[0]
if vpc_name:
vpc_id = vpc['id']
if not vpc_region:
vpc_region = vpc['region']
# Next, see if it (or they) exist at all, anywhere?
deets = __salt__['boto_route53.describe_hosted_zones'](
domain_name=domain_name,
region=region,
key=key,
keyid=keyid,
profile=profile)
create = False
if not deets:
create = True
else: # Something exists - now does it match our criteria?
if (json.loads(deets['HostedZone']['Config']['PrivateZone']) !=
private_zone):
create = True
else:
if private_zone:
for v, d in deets.get('VPCs', {}).items():
if (d['VPCId'] == vpc_id and d['VPCRegion'] == vpc_region):
create = False
break
else:
create = True
if not create:
ret['comment'] = 'Hostd Zone {0} already in desired state'.format(
domain_name)
else:
# Until we get modifies in place with boto3, the best option is to
# attempt creation and let route53 tell us if we're stepping on
# toes. We can't just fail, because some scenarios (think split
# horizon DNS) require zones with identical names but different
# settings...
log.info('A Hosted Zone with name {0} already exists, but with '
'different settings. Will attempt to create the one '
'requested on the assumption this is what is desired. '
'This may fail...'.format(domain_name))
if create:
if __opts__['test']:
ret['comment'] = 'Route53 Hosted Zone {0} set to be added.'.format(
domain_name)
ret['result'] = None
return ret
res = __salt__['boto_route53.create_hosted_zone'](
domain_name=domain_name,
caller_ref=name,
comment=comment,
private_zone=private_zone,
vpc_id=vpc_id,
vpc_region=vpc_region,
region=region,
key=key,
keyid=keyid,
profile=profile)
if res:
msg = 'Hosted Zone {0} successfully created'.format(domain_name)
log.info(msg)
ret['comment'] = msg
ret['changes']['old'] = None
ret['changes']['new'] = res
else:
ret['comment'] = 'Creating Hosted Zone {0} failed'.format(
domain_name)
ret['result'] = False
return ret