def run(params):
access_key, secret_key = get_aws_credentials(params)
if (access_key and secret_key):
con = route53.connect_to_region('universal',
aws_access_key_id=access_key,
aws_secret_access_key=secret_key)
else:
con = route53.connect_to_region('universal')
if (access_key and secret_key):
cons3 = S3Connection(access_key, secret_key)
else:
cons3 = boto.connect_s3()
zone_name = params['<zone>']
filename = params['<file>']
bucketname = params['<bucket>']
if params['dump']:
dump(con, zone_name, filename)
elif params['load']:
load(con, zone_name, filename)
elif params['dumps3']:
dumps3(con, cons3, zone_name, bucketname)
else:
return 1
def action(self):
"""Creates the zone"""
conn = route53.connect_to_region(self.REGION)
comment = json.dumps(self.get_raw_tags())
hosted_zones = conn.get_all_hosted_zones()
for hosted_zone in hosted_zones['ListHostedZonesResponse'][
'HostedZones']:
if ('Comment' in hosted_zone['Config']
and hosted_zone['Config']['Comment'] == comment):
self.stack_outputs = {
'PrivateHostedZoneId': hosted_zone['Id'].split('/')[-1]
}
return
hosted_zone = conn.create_hosted_zone(
self.get_input('PrivateHostedZoneName'),
comment=comment,
private_zone=True,
vpc_id=self.get_input('VpcId'),
vpc_region=self.REGION)
hosted_zone_id = hosted_zone['CreateHostedZoneResponse']['HostedZone'][
'Id']
self.stack_outputs = {
'PrivateHostedZoneId': hosted_zone_id.split('/')[-1]
}
def __init__(self, config): conn = route53.connect_to_region(config["region"]) self.zone = conn.get_zone(config["zone"]) self.domain = config["zone"] self.stack = config["stack"] self.our_ip = config["our_ip"] self.ttl = config["ttl"]
def run(params):
access_key, secret_key = get_aws_credentials(params)
con = route53.connect_to_region('universal',
aws_access_key_id=access_key,
aws_secret_access_key=secret_key)
zone_name = params['<zone>']
filename = params['<file>']
vpc = {}
if params.get('--private'):
vpc['is_private'] = True
vpc['region'] = params.get('--vpc-region') or environ.get(
'AWS_DEFAULT_REGION')
vpc['id'] = params.get('--vpc-id')
if not vpc.get('region') or not vpc.get('id'):
exit_with_error(
"ERROR: Private zones require associated VPC Region and ID "
"(--vpc-region, --vpc-id)".format(zone_name))
else:
vpc['is_private'] = False
if params.get('dump'):
dump(con, zone_name, get_file(filename, 'w'), vpc=vpc)
elif params.get('load'):
load(con, zone_name, get_file(filename, 'r'), vpc=vpc)
else:
return 1
def action(self):
region = self.get_input('Region')
hosted_zone_name = self.get_input('PublicHostedZoneName')
app_lb_endpoint = self.get_input('AppServerLoadBalancerEndpoint')
app_lb_hosted_zone_id = self.get_input('AppServerLoadBalancerHostedZoneNameID') # NOQA
backward_compat_hosted_zone_name = self.get_input('BackwardCompatPublicHostedZoneName') # NOQA
backward_compat_app_lb_endpoint = self.get_input('BackwardCompatAppServerLoadBalancerEndpoint')
backward_compat_app_lb_hosted_zone_id = self.get_input('BackwardCompatAppServerLoadBalancerHostedZoneNameID') # NOQA
route53_conn = r53.connect_to_region(region,
profile_name=self.aws_profile)
public_hosted_zone = route53_conn.get_zone(hosted_zone_name)
record_sets = r53.record.ResourceRecordSets(route53_conn,
public_hosted_zone.id)
record_sets.add_change('UPSERT', hosted_zone_name, 'A',
alias_hosted_zone_id=app_lb_hosted_zone_id,
alias_dns_name=app_lb_endpoint,
alias_evaluate_target_health=True,
identifier='Primary',
failover='PRIMARY')
record_sets.commit()
backward_compat_hosted_zone = route53_conn.get_zone(backward_compat_hosted_zone_name)
backward_compat_record_sets = r53.record.ResourceRecordSets(route53_conn,
backward_compat_hosted_zone.id)
backward_compat_record_sets.add_change('UPSERT', backward_compat_hosted_zone_name, 'A',
alias_hosted_zone_id=backward_compat_app_lb_hosted_zone_id,
alias_dns_name=backward_compat_app_lb_endpoint,
alias_evaluate_target_health=True,
identifier='Primary',
failover='PRIMARY')
backward_compat_record_sets.commit()
def run(params):
access_key, secret_key = get_aws_credentials(params)
con = route53.connect_to_region('universal', aws_access_key_id=access_key, aws_secret_access_key=secret_key)
con_s3 = connect_s3(aws_access_key_id=access_key, aws_secret_access_key=secret_key)
zone_name = params['<zone>']
filename = params['<file>']
vpc = {}
if params.get('--private'):
vpc['is_private'] = True
vpc['region'] = params.get('--vpc-region') or environ.get('AWS_DEFAULT_REGION')
vpc['id'] = params.get('--vpc-id')
if not vpc.get('region') or not vpc.get('id'):
exit_with_error("ERROR: Private zones require associated VPC Region and ID "
"(--vpc-region, --vpc-id)".format(zone_name))
else:
vpc['is_private'] = False
if params.get('dump'):
dump(con, zone_name, get_file(filename, 'w'), vpc=vpc)
if params.get('--s3-bucket'):
up_to_s3(con_s3, params.get('<file>'), params.get('--s3-bucket'))
elif params.get('load'):
load(con, zone_name, get_file(filename, 'r'), vpc=vpc)
else:
return 1
def action(self):
region = self.get_input('Region')
conn = r53.connect_to_region(region, profile_name=self.aws_profile)
comment = json.dumps(self.get_raw_tags())
hosted_zones = conn.get_all_hosted_zones()
for hosted_zone in hosted_zones['ListHostedZonesResponse'][
'HostedZones']: # NOQA
if ('Comment' in hosted_zone['Config']
and hosted_zone['Config']['Comment'] == comment):
self.stack_outputs = {
'PrivateHostedZoneId': hosted_zone['Id'].split('/')[-1]
}
return
hosted_zone = conn.create_hosted_zone('{}.'.format(
self.get_input('PrivateHostedZoneName')),
comment=comment,
private_zone=True,
vpc_id=self.get_input('VpcId'),
vpc_region=region)
hosted_zone_id = hosted_zone['CreateHostedZoneResponse']['HostedZone'][
'Id'] # NOQA
self.stack_outputs = {
'PrivateHostedZoneId': hosted_zone_id.split('/')[-1]
} # NOQA
def action(self):
region = self.get_input('Region')
color = self.get_input('StackColor')
hosted_zone_name = self.get_input('PublicHostedZoneName')
app_lb_endpoint = self.get_input('AppServerLoadBalancerEndpoint')
app_lb_hosted_zone_id = self.get_input(
'AppServerLoadBalancerHostedZoneNameID')
backward_compat_hosted_zone_name = self.get_input(
'BackwardCompatPublicHostedZoneName')
backward_compat_app_lb_endpoint = self.get_input(
'BackwardCompatAppServerLoadBalancerEndpoint')
backward_compat_app_lb_hosted_zone_id = self.get_input(
'BackwardCompatAppServerLoadBalancerHostedZoneNameID')
route53_conn = r53.connect_to_region(region,
profile_name=self.aws_profile)
public_hosted_zone = route53_conn.get_zone(hosted_zone_name)
record_sets = r53.record.ResourceRecordSets(route53_conn,
public_hosted_zone.id)
record_sets.add_change('UPSERT', hosted_zone_name, 'A',
alias_hosted_zone_id=app_lb_hosted_zone_id,
alias_dns_name=app_lb_endpoint,
alias_evaluate_target_health=True,
identifier='Primary',
failover='PRIMARY')
record_sets.commit()
backward_compat_hosted_zone = route53_conn.get_zone(
backward_compat_hosted_zone_name)
backward_compat_record_sets = r53.record.ResourceRecordSets(
route53_conn, backward_compat_hosted_zone.id)
backward_compat_record_sets.add_change(
'UPSERT', backward_compat_hosted_zone_name, 'A',
alias_hosted_zone_id=backward_compat_app_lb_hosted_zone_id,
alias_dns_name=backward_compat_app_lb_endpoint,
alias_evaluate_target_health=True, identifier='Primary',
failover='PRIMARY')
backward_compat_record_sets.commit()
s3_conn = s3.connect_to_region(region,
profile_name=self.aws_profile,
calling_format=OrdinaryCallingFormat())
bucket = s3_conn.get_bucket('tile-cache.{}'.format(hosted_zone_name))
rules = s3.website.RoutingRules()
rules.add_rule(s3.website.RoutingRule(
s3.website.Redirect(
protocol='https',
http_redirect_code=302,
hostname='{}-tiles.{}'.format(color.lower(),
hosted_zone_name)),
s3.website.Condition(http_error_code=404)))
bucket.configure_website(suffix='index.html', error_key='error.html',
routing_rules=rules)
def create_domain(region, namespace, mappings, parameters, **kwargs):
conn = connect_to_region(region)
domain = kwargs.get('domain', parameters.get('BaseDomain'))
if not domain:
logger.error("domain argument or BaseDomain parameter not provided.")
return False
create_route53_zone(conn, domain)
return True
def run(params):
access_key, secret_key = get_aws_credentials(params)
con = route53.connect_to_region('universal', aws_access_key_id=access_key, aws_secret_access_key=secret_key)
zone_name = params['<zone>']
filename = params['<file>']
if params['dump']:
dump(con, zone_name, get_file(filename, 'w'))
elif params['load']:
load(con, zone_name, get_file(filename, 'r'))
else:
return 1
def set_service_dns(self, domain_name):
r53 = route53.connect_to_region(self.region)
dns_zone = None
for zone in r53.get_zones():
if domain_name == zone.name:
dns_zone = zone
if not dns_zone:
raise Exception(
'DNS Hosting for {0} not setup in Route53'.format(domain_name))
status = dns_zone.add_record(
'CNAME', '{0}.{1}'.format(self.app_name.strip(), domain_name),
self.app_load_balancer.dns_name)
return status
def set_instance_dns(self, instance_id, host_name, domain_name,
ip_address):
r53 = route53.connect_to_region(self.region)
dns_zone = None
for zone in r53.get_zones():
if domain_name == zone.name:
dns_zone = zone
if not dns_zone:
raise Exception(
'DNS Hosting for {0} not setup in Route53'.format(domain_name))
dns_name = "{0}.{1}.{2}".format(instance_id, host_name, domain_name)
dns_zone.add_record('A', dns_name, ip_address)
return dns_name
def run(self, terms, variables=None, **kwargs):
zoneid = terms[0]
recordtype = terms[1]
recordname = terms[2]
r53conn = route53.connect_to_region('universal',
aws_access_key_id=AWS_ACCESS_KEY_ID,
aws_secret_access_key=AWS_SECRET_ACCESS_KEY
)
records = r53conn.get_all_rrsets(zoneid,recordtype,recordname,maxitems=1)[0]
recordvalue = records.resource_records[0]
if recordvalue:
return [recordvalue]
return None
def create_cache_private_dns_record(self, cache_cluster_node_endpoint):
"""Create or update the private DNS entry for the cache cluster"""
route53_conn = r53.connect_to_region(self.region,
profile_name=self.aws_profile)
private_hosted_zone = route53_conn.get_zone(self.hosted_zone_name)
cache_dns_record_name = 'cache.service.{}.'.format(
self.hosted_zone_name)
cache_dns_record = private_hosted_zone.get_cname(cache_dns_record_name)
if not cache_dns_record:
private_hosted_zone.add_cname(cache_dns_record_name,
cache_cluster_node_endpoint, ttl=10)
elif cache_cluster_node_endpoint not in cache_dns_record.resource_records: # NOQA
private_hosted_zone.update_cname(cache_dns_record_name,
cache_cluster_node_endpoint,
ttl=10)
def run(self, terms, variables=None, **kwargs):
zoneid = terms[0]
recordtype = terms[1]
recordname = terms[2]
r53conn = route53.connect_to_region(
'universal',
aws_access_key_id=AWS_ACCESS_KEY_ID,
aws_secret_access_key=AWS_SECRET_ACCESS_KEY)
records = r53conn.get_all_rrsets(zoneid,
recordtype,
recordname,
maxitems=1)[0]
recordvalue = records.resource_records[0]
if recordvalue:
return [recordvalue]
return None
def set_elb_dns(self, domain_name):
elbo = elb.connect_to_region(self.region)
lb = elbo.get_all_load_balancers(
load_balancer_names=self.lb_name).pop()
r53 = route53.connect_to_region(self.region)
dns_zone = None
for zone in r53.get_zones():
if domain_name == zone.name:
dns_zone = zone
if not dns_zone:
raise Exception(
'DNS Hosting for {0} not setup in Route53'.format(domain_name))
status = dns_zone.add_record(
'CNAME', '{0}.{1}'.format(self.lb_name.strip(), domain_name),
lb.dns_name)
return status
def action(self):
region = self.get_input('Region')
hosted_zone_name = self.get_input('PublicHostedZoneName')
app_lb_endpoint = self.get_input('AppServerLoadBalancerEndpoint')
app_lb_hosted_zone_id = self.get_input(
'AppServerLoadBalancerHostedZoneNameID') # NOQA
backward_compat_hosted_zone_name = self.get_input(
'BackwardCompatPublicHostedZoneName') # NOQA
backward_compat_app_lb_endpoint = self.get_input(
'BackwardCompatAppServerLoadBalancerEndpoint')
backward_compat_app_lb_hosted_zone_id = self.get_input(
'BackwardCompatAppServerLoadBalancerHostedZoneNameID') # NOQA
route53_conn = r53.connect_to_region(region,
profile_name=self.aws_profile)
public_hosted_zone = route53_conn.get_zone(hosted_zone_name)
record_sets = r53.record.ResourceRecordSets(route53_conn,
public_hosted_zone.id)
record_sets.add_change('UPSERT',
hosted_zone_name,
'A',
alias_hosted_zone_id=app_lb_hosted_zone_id,
alias_dns_name=app_lb_endpoint,
alias_evaluate_target_health=True,
identifier='Primary',
failover='PRIMARY')
record_sets.commit()
backward_compat_hosted_zone = route53_conn.get_zone(
backward_compat_hosted_zone_name)
backward_compat_record_sets = r53.record.ResourceRecordSets(
route53_conn, backward_compat_hosted_zone.id)
backward_compat_record_sets.add_change(
'UPSERT',
backward_compat_hosted_zone_name,
'A',
alias_hosted_zone_id=backward_compat_app_lb_hosted_zone_id,
alias_dns_name=backward_compat_app_lb_endpoint,
alias_evaluate_target_health=True,
identifier='Primary',
failover='PRIMARY')
backward_compat_record_sets.commit()
def test_new_record():
node = get_node()
config = get_config()
r53 = route53.connect_to_region(node['region'])
zone = r53.create_zone(
config['name'],
private_zone=True,
vpc_id='1',
vpc_region=node['region'],
)
hosted_zone_module = HostedZone(node, config)
hostname = 'master0-123'
fqdn = hosted_zone_module.run(hostname)
assert fqdn == '.'.join([hostname, zone.name.lower()])
record = zone.get_a(fqdn)
assert record.resource_records == [node['metadata']['local-ipv4']]
def action(self):
"""Creates the zone"""
conn = route53.connect_to_region(self.REGION)
comment = json.dumps(self.get_raw_tags())
hosted_zones = conn.get_all_hosted_zones()
for hosted_zone in hosted_zones['ListHostedZonesResponse']['HostedZones']:
if ('Comment' in hosted_zone['Config'] and
hosted_zone['Config']['Comment'] == comment):
self.stack_outputs = {'PrivateHostedZoneId': hosted_zone['Id'].split('/')[-1]}
return
hosted_zone = conn.create_hosted_zone(self.get_input('PrivateHostedZoneName'),
comment=comment,
private_zone=True,
vpc_id=self.get_input('VpcId'),
vpc_region=self.REGION)
hosted_zone_id = hosted_zone['CreateHostedZoneResponse']['HostedZone']['Id']
self.stack_outputs = {'PrivateHostedZoneId': hosted_zone_id.split('/')[-1]}
def answer_dns_challenge(client, domain, challenge):
"""
Compute the required answer and set it in the DNS record
for the domain.
"""
authorization = "{}.{}".format(
base64.urlsafe_b64encode(
challenge.get("token")).decode("ascii").replace("=", ""),
base64.urlsafe_b64encode(
client.key.thumbprint()).decode("ascii").replace("=", ""))
dns_response = base64.urlsafe_b64encode(
hashlib.sha256(
authorization.encode()).digest()).decode("ascii").replace("=", "")
# Let's update the DNS on our R53 account
r53 = route53.connect_to_region(exec_region)
zone = r53.get_zone(domain['r53_zone'])
if zone == None:
LOG.error("Cannot find R53 zone {}, are you controling it ?".format(
domain['r53_zone']))
exit(1)
acme_domain = "_acme-challenge.{}".format(domain['name'])
record = zone.find_records(name=acme_domain, type="TXT")
if record:
delete_status = zone.delete_record(record)
add_status = zone.add_record("TXT", acme_domain, '"' + dns_response + '"')
dns_updated = wait_until_sync(add_status)
if dns_updated == False:
LOG.error(
"We updated R53 but the servers didn't sync within 10 seconds. Bailing out."
)
exit(1)
## Now, let's tell the ACME server that we are ready
challenge_response = challenges.DNS01Response(
key_authorization=authorization)
challenge_resource = client.answer_challenge(challenge, challenge_response)
def action(self):
region = self.get_input("Region")
hosted_zone_name = self.get_input("PublicHostedZoneName")
app_lb_endpoint = self.get_input("AppServerLoadBalancerEndpoint")
app_lb_hosted_zone_id = self.get_input("AppServerLoadBalancerHostedZoneNameID") # NOQA
route53_conn = r53.connect_to_region(region, profile_name=self.aws_profile)
public_hosted_zone = route53_conn.get_zone(hosted_zone_name)
record_sets = r53.record.ResourceRecordSets(route53_conn, public_hosted_zone.id)
record_sets.add_change(
"UPSERT",
hosted_zone_name,
"A",
alias_hosted_zone_id=app_lb_hosted_zone_id,
alias_dns_name=app_lb_endpoint,
alias_evaluate_target_health=True,
identifier="Primary",
failover="PRIMARY",
)
record_sets.commit()
def run(params):
dryrun = params.get('--dry-run')
if dryrun:
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s %(levelname)s [[DRY RUN]] %(message)s',
StreamHandler=sys.stdout)
else:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)s %(message)s',
StreamHandler=sys.stdout)
access_key, secret_key = get_aws_credentials(params)
con = route53.connect_to_region('universal',
aws_access_key_id=access_key,
aws_secret_access_key=secret_key)
zone_name = params['<zone>']
filename = params['<file>']
vpc = {}
if params.get('--private'):
vpc['is_private'] = True
vpc['region'] = params.get('--vpc-region') or environ.get(
'AWS_DEFAULT_REGION')
vpc['id'] = params.get('--vpc-id')
if not vpc.get('region') or not vpc.get('id'):
exit_with_error(
"ERROR: Private zones require associated VPC Region and ID "
"(--vpc-region, --vpc-id)".format(zone_name))
else:
vpc['is_private'] = False
if params.get('dump'):
dump(con, zone_name, get_file(filename, 'w'), vpc=vpc)
elif params.get('load'):
load(con, zone_name, get_file(filename, 'r'), vpc=vpc, dryrun=dryrun)
else:
return 1
def action(self):
region = self.get_input('Region')
conn = r53.connect_to_region(region, profile_name=self.aws_profile)
comment = json.dumps(self.get_raw_tags())
hosted_zones = conn.get_all_hosted_zones()
for hosted_zone in hosted_zones['ListHostedZonesResponse']['HostedZones']: # NOQA
if ('Comment' in hosted_zone['Config'] and
hosted_zone['Config']['Comment'] == comment):
self.stack_outputs = {
'PrivateHostedZoneId': hosted_zone['Id'].split('/')[-1]
}
return
hosted_zone = conn.create_hosted_zone(
'{}.'.format(self.get_input('PrivateHostedZoneName')),
comment=comment, private_zone=True, vpc_id=self.get_input('VpcId'),
vpc_region=region
)
hosted_zone_id = hosted_zone['CreateHostedZoneResponse']['HostedZone']['Id'] # NOQA
self.stack_outputs = {'PrivateHostedZoneId': hosted_zone_id.split('/')[-1]} # NOQA
def _get_zone(self) -> route53.zone.Zone:
r53_connection = route53.connect_to_region(self.node['region'])
zone = r53_connection.get_zone(self.config['name'])
if not zone:
raise Exception('Hosted Zone %s not found' % self.config['name'])
return zone
def route53_connect():
return route53.connect_to_region('us-west-2')
def connect(self):
self.connection = route53.connect_to_region(region_name=self.aws_region)
scalr_instance_index = os.environ.get('SCALR_INSTANCE_INDEX')
aws_dns_name = os.environ.get('AWS_DNS_NAME')
mongoInternalIP = os.environ.get('SCALR_INTERNAL_IP')
mongoReplicaDNSName = os.environ.get('MONGO_DNS_NAME')
mongoEnv = os.environ.get('MONGO_ENV')
def main():
print mongoReplicaDNSName
print aws_dns_name
print region
print mongoInternalIP
print mongoReplicaDNSName+"."+mongoEnv+"."+aws_dns_name
try:
conn_eu = route53.connect_to_region(region)
hostedZone = conn_eu.get_zone(aws_dns_name)
change_set = route53.record.ResourceRecordSets(conn_eu, hostedZone.id)
changes1 = change_set.add_change("UPSERT",mongoReplicaDNSName+"."+mongoEnv+"."+aws_dns_name, type="A",ttl=300)
changes1.add_value(mongoInternalIP)
change_set.commit()
##Add dns name to tag
conn_inst = ec2.connect_to_region(region,aws_access_key_id=aws_access_key,aws_secret_access_key=aws_secret_key)
instID=get_instance_metadata()['instance-id']
conn_inst.create_tags([instID], {"mngDNS": mongoReplicaDNSName+"."+mongoEnv+"."+aws_dns_name})
except Exception as e: print(e)
if __name__ == "__main__":
main();
clean_env()
self.conf = '%s/%s/%s.ini' % (os.getenv('AWS_CRED_DIR'),
acct_name, acct_name)
try:
boto.config.load_credential_file(self.conf)
except IOError, msg:
print >> sys.stderr, 'ERROR: %s' % msg
return False
if service == 's3':
self.conn = s3.connect_to_region(region)
if service == 'ec2':
self.conn = ec2.connect_to_region(region)
if service == 'rds':
self.conn = rds.connect_to_region(region)
if service == 'rds2':
self.conn = rds2.connect_to_region(region)
if service == 'elb':
self.conn = elb.connect_to_region(region)
if service == 'sqs':
self.conn = sqs.connect_to_region(region)
if service == 'emr':
self.conn = emr.connect_to_region(region)
if service == 'route53':
self.conn = route53.connect_to_region(region)
if service == 'iam':
self.conn = iam.connect_to_region('universal')
if not self.conn:
print >> sys.stderr, 'ERROR: Unknown service'
return False
return self.conn
def get_public_ip():
html = urllib2.urlopen(DDWRT_ROUTER_STATUS_PAGE).read()
p = re.compile(r"IP\: ([0-9\.]*)\</span")
f = p.search(html)
if f and len(f.groups()) > 0:
ip = f.groups()[0]
return ip
else:
print("Could not scrape IP address in router status page")
sys.exit(1)
wan_ip = get_public_ip()
print("Current WAN IP on Router: {}".format(wan_ip))
r53 = route53.connect_to_region('universal')
rec = r53.get_all_rrsets(AWS_R53_ZONE, 'A', AWS_R53_ZONE_RECORD, maxitems = 1)[0]
cur_ip = str(rec.resource_records[0])
if cur_ip == wan_ip:
print("Nothing to update - current IP {} configured for {} is still correct.".format(cur_ip, AWS_R53_ZONE_RECORD))
else:
print("IP for {} needs to be updated from {} to {} ...".format(AWS_R53_ZONE_RECORD, cur_ip, wan_ip))
try:
r53rr = ResourceRecordSets(r53, AWS_R53_ZONE)
d_record = r53rr.add_change('DELETE', AWS_R53_ZONE_RECORD, "A", 60)
d_record.add_value(cur_ip)
c_record = r53rr.add_change('CREATE', AWS_R53_ZONE_RECORD, 'A', 60)
c_record.add_value(wan_ip)
r53rr.commit()
def action(self):
region = self.get_input('Region')
color = self.get_input('StackColor')
hosted_zone_name = self.get_input('PublicHostedZoneName')
app_lb_endpoint = self.get_input('AppServerLoadBalancerEndpoint')
app_lb_hosted_zone_id = self.get_input(
'AppServerLoadBalancerHostedZoneNameID')
backward_compat_hosted_zone_name = self.get_input(
'BackwardCompatPublicHostedZoneName')
backward_compat_app_lb_endpoint = self.get_input(
'BackwardCompatAppServerLoadBalancerEndpoint')
backward_compat_app_lb_hosted_zone_id = self.get_input(
'BackwardCompatAppServerLoadBalancerHostedZoneNameID')
route53_conn = r53.connect_to_region(region,
profile_name=self.aws_profile)
public_hosted_zone = route53_conn.get_zone(hosted_zone_name)
record_sets = r53.record.ResourceRecordSets(route53_conn,
public_hosted_zone.id)
record_sets.add_change('UPSERT',
hosted_zone_name,
'A',
alias_hosted_zone_id=app_lb_hosted_zone_id,
alias_dns_name=app_lb_endpoint,
alias_evaluate_target_health=True,
identifier='Primary',
failover='PRIMARY')
record_sets.commit()
backward_compat_hosted_zone = route53_conn.get_zone(
backward_compat_hosted_zone_name)
backward_compat_record_sets = r53.record.ResourceRecordSets(
route53_conn, backward_compat_hosted_zone.id)
backward_compat_record_sets.add_change(
'UPSERT',
backward_compat_hosted_zone_name,
'A',
alias_hosted_zone_id=backward_compat_app_lb_hosted_zone_id,
alias_dns_name=backward_compat_app_lb_endpoint,
alias_evaluate_target_health=True,
identifier='Primary',
failover='PRIMARY')
backward_compat_record_sets.commit()
s3_conn = s3.connect_to_region(region,
profile_name=self.aws_profile,
calling_format=OrdinaryCallingFormat())
bucket = s3_conn.get_bucket('tile-cache.{}'.format(hosted_zone_name))
rules = s3.website.RoutingRules()
rules.add_rule(
s3.website.RoutingRule(
s3.website.Redirect(protocol='https',
http_redirect_code=302,
hostname='{}-tiles.{}'.format(
color.lower(), hosted_zone_name)),
s3.website.Condition(http_error_code=404)))
bucket.configure_website(suffix='index.html',
error_key='error.html',
routing_rules=rules)
def sync(users, groups, route53_zone, hesiod_domain, dry_run):
conn = r53.connect_to_region("us-east-1")
record_type = "TXT"
ttl = "60"
# suffix of . on zone if not supplied
if route53_zone[-1:] != ".":
route53_zone += "."
if hesiod_domain[-1:] != ".":
hesiod_domain += "."
# get existing hosted zones
zones = {}
results = conn.get_all_hosted_zones()
for r53zone in results["ListHostedZonesResponse"]["HostedZones"]:
zone_id = r53zone["Id"].replace("/hostedzone/", "")
zones[r53zone["Name"]] = zone_id
# ensure requested zone is hosted by route53
if not route53_zone in zones:
raise Exception("Zone %s does not exist in Route53" % route53_zone)
sets = conn.get_all_rrsets(zones[route53_zone])
# existing records
existing_records = set()
for rset in sets:
if rset.type == record_type:
if (
rset.name.endswith("group." + hesiod_domain)
or rset.name.endswith("gid." + hesiod_domain)
or rset.name.endswith("passwd." + hesiod_domain)
or rset.name.endswith("uid." + hesiod_domain)
or rset.name.endswith("grplist." + hesiod_domain)
or rset.name.endswith("ssh." + hesiod_domain)
):
value = "".join(rset.resource_records).replace('"', "")
existing_records.add(DNSRecord(str(rset.name), str(value)))
# new records
new_records = set()
for group in groups:
for record in group.dns_records(hesiod_domain, users):
new_records.add(record)
for user in users:
for record in user.dns_records(hesiod_domain):
new_records.add(record)
to_remove = existing_records - new_records
to_add = new_records - existing_records
if to_remove:
print "Deleting:"
for r in sorted(to_remove):
print r
print
else:
print "Nothing to delete."
if to_add:
print "Adding:"
for r in sorted(to_add):
print r
print
else:
print "Nothing to add."
if dry_run:
print "Dry run mode. Stopping."
return
# stop if nothing to do
if not to_remove and not to_add:
return
changes = ResourceRecordSets(conn, zones[route53_zone])
for record in to_remove:
removal = changes.add_change("DELETE", record.fqdn, record_type, ttl)
removal.add_value(txt_value(record.value))
for record in to_add:
addition = changes.add_change("CREATE", record.fqdn, record_type, ttl)
addition.add_value(txt_value(record.value))
try:
result = changes.commit()
status = Status(conn, result["ChangeResourceRecordSetsResponse"]["ChangeInfo"])
except r53.exception.DNSServerError, e:
raise Exception("Could not update DNS records.", e)
## JSON Response.
URL = 'http://ip.paddez.com/?json'
response = urllib.urlopen(URL)
data = json.loads(response.read())
REGION = 'eu-west-1'
DOMAIN = 'paddez.ninja'
OSLO = 'oslo.paddez.ninja'
RIGA = 'riga.paddez.ninja'
IP = data.get('ip')
## Route53 Connection and zones
r53 = aws.connect_to_region(REGION)
zone = r53.get_zone(DOMAIN)
apex = zone.get_a(DOMAIN)
oslo = zone.get_a(OSLO)
print oslo
print apex
addrs = ifaddresses('eth0')[AF_INET]
private_ip = addrs[0].get('addr')
# If the current public IP, does not match the record, UPSERT.
if(IP != apex.to_print()):
print zone.update_a(DOMAIN, IP)
# If the current private IP != the record, UPSERT
if(private_ip != oslo.to_print()):
