def is_in_dnsaas(ip):
if not settings.ENABLE_DNSAAS_INTEGRATION:
return False
dnsaas_client = DNSaaS()
url = dnsaas_client.build_url('records',
get_params=[('ip', ip), ('type', 'A')])
return len(dnsaas_client.get_api_result(url)) > 0
def clean_dns(cls, instances, **kwargs):
"""
Clean DNS entries for each instance if DNSaaS integration is enabled.
"""
if not settings.ENABLE_DNSAAS_INTEGRATION:
raise DNSaaSIntegrationNotEnabledError()
dnsaas = DNSaaS()
# TODO: transaction?
for instance in instances:
ips = list(
instance.ipaddresses.exclude(is_management=True).values_list(
'address', flat=True))
if not ips:
logger.info('No IPs for %s - skipping cleaning DNS entries',
instance)
continue
records = dnsaas.get_dns_records(ips)
if len(records) > settings.DEPLOYMENT_MAX_DNS_ENTRIES_TO_CLEAN:
raise Exception(
'Cannot clean {} entries for {} - clean it manually'.format(
len(records), instance))
for record in records:
logger.warning('Deleting %s (%s / %s / %s) DNS record',
record['pk'], record['type'], record['name'],
record['content'])
if dnsaas.delete_dns_record(record['pk']):
raise Exception() # TODO
def delete_dns_record(instance, *args, **kwargs):
if not _should_send_dnsaas_request(instance):
return
DNSaaS().send_ipaddress_data({
'address': instance.address,
'hostname': instance.hostname,
'action': 'delete'
})
def update_dns_record(instance, created, *args, **kwargs):
if not _should_send_dnsaas_request(instance):
return
keys = ['address', 'hostname']
data_to_send = {
'old': {key: instance._previous_state[key]
for key in keys},
'new': {key: instance.__dict__[key]
for key in keys},
'service_uid': _get_connected_service_uid(instance)
}
data_to_send['action'] = 'add' if created else 'update'
if data_to_send['old']['hostname'] is not None:
DNSaaS().send_ipaddress_data(data_to_send)
def update_dns_record(instance, created, *args, **kwargs):
if not _should_send_dnsaas_request(instance):
return
keys = ['address', 'hostname']
old = {key: instance._previous_state[key] for key in keys}
new = {key: instance.__dict__[key] for key in keys}
if old != new and old['hostname'] is not None:
data_to_send = {
'old': old,
'new': new,
'service_uid': _get_connected_service_uid(instance),
'action': 'add' if created else 'update'
}
DNSaaS().send_ipaddress_data(data_to_send)
def create_dns_entries(cls, instances, **kwargs):
if not settings.ENABLE_DNSAAS_INTEGRATION:
raise DNSaaSIntegrationNotEnabledError()
dnsaas = DNSaaS()
# TODO: transaction?
for instance in instances:
# TODO: use dedicated param instead of history_kwargs
ip = kwargs['history_kwargs'][instance.pk]['ip']
dnsaas.create_dns_record(record={
'name': instance.hostname,
'type': RecordType.a.id,
'content': ip,
'ptr': True,
},
service=instance.service)
def test_user_get_info_when_dnsaas_user_has_no_perm(self):
class RequestStub():
status_code = 202
request = RequestStub()
dns = DNSaaS()
result = dns._response2result(request)
self.assertEqual(
result,
{
'non_field_errors':
[_("Your request couldn't be handled, try later.")]
},
)
def __init__(self, *args, **kwargs):
if not settings.ENABLE_DNSAAS_INTEGRATION:
raise DNSaaSIntegrationNotEnabledError()
self.dnsaas = DNSaaS()
return super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.dns = DNSaaS()
def setUp(self):
self.dnsaas = DNSaaS()
def setUp(self, mocked):
mocked.return_value = 'token'
self.dnsaas = DNSaaS()
def handle(self, *args, **options):
dnsaas_client = DNSaaS()
domains = self.get_domains(dnsaas_client)
self.update_from_domains(domains)
self.get_records(dnsaas_client)