def update_dynamic_ip(mail, token, host, domain, address):
try:
dns = DNSimple(email=mail, api_token=token)
results = dns.records(domain)
response = None
found = False
for result in results:
record = result['record']
record_name = record['name']
record_content = record['content'].rstrip()
record_id = record['id']
if record_name == host:
if record_content == address:
response = None
found = True
else:
record_data = { 'content' : address, 'record_type' : 'A' }
dns.update_record(domain, record_id, record_data)
response = "Updating host {0}.{1} with id {2} to address '{3}' from address '{4}'".format(record_name, domain, record_id, address, record_content)
found = True)
if not found:
record = { "name" : host, "record_type" : "A", "content" : address, "ttl" : 900 }
dns.add_record(domain, record)
response = "New record created for {0}.{1} with address {2}".format(host, domain, address)
except DNSimpleException as e:
response = "Error when updating dynamic address ({0})".format(e)
return response
def delete_record(data):
dns = DNSimple(api_token=data['dnsimple_token'],
account_id=data['dnsimple_account'])
if 'absent' in data['state']:
for n in dns.records(data['domain']):
if data['name'] == n['record']['name']:
dns.delete_record(data['domain'], n['record']['id'])
return (True, None, 'record deleted')
return (False, None, 'no record deleted')
class DNSimpleProvider(object):
def __init__(self, account_id, api_token):
self.dnsimple_client = DNSimple(api_token=api_token, account_id=account_id)
def cname_record_exists(self, domain, name):
records = self.dnsimple_client.records(domain)
fqdn = "{}.{}".format(name, domain)
try:
def rfilter(x):
return x.get('record').get('type') == "CNAME" and ("{}.{}".format(x.get('record').get('name'), x.get('record').get('zone_id')) == fqdn)
record = list(filter(rfilter, records))[0]
return record
except DNSimpleException as e:
return {}
except IndexError as e:
return {}
def cname_record_add(self, domain, name, content):
try:
return {'result': True, 'data': self.dnsimple_client.add_record(domain, {'type': 'CNAME', 'name': name, 'content': content})}
except DNSimpleException as e:
return {'result': False, 'data': str(e)}
def cname_record_update(self, domain, name, content):
records = self.dnsimple_client.records(domain)
fqdn = "{}.{}".format(name, domain)
try:
def rfilter(x):
return x.get('record').get('type') == "CNAME" and ("{}.{}".format(x.get('record').get('name'), x.get('record').get('zone_id')) == fqdn)
record_id = list(filter(rfilter, records))[0].get('record').get('id')
log.error(list(filter(rfilter, records))[0].get('record'))
return {'result': True, 'data': self.dnsimple_client.update_record(domain, record_id, {'content': content})}
except DNSimpleException as e:
return {'result': False, 'data': str(e)}
except IndexError:
return {'result': False, 'data': 'record not found'}
def subdomain_in_dnsimple(subdomain):
dns = DNSimple(username=settings.DNSIMPLE_USERNAME, password=settings.DNSIMPLE_PASSWORD)
try:
raspi_records = dns.records('raspi.tw')
except:
return None
raspi_dns_records = list()
for raspi_record in raspi_records:
if raspi_record['record']['name'] == subdomain:
t=dict()
t['id'] = raspi_record['record']['id']
t['name'] = raspi_record['record']['name']
t['record_type'] = raspi_record['record']['record_type']
t['content'] = raspi_record['record']['content']
raspi_dns_records.append(t)
return raspi_dns_records
def subdomain_in_dnsimple(subdomain):
dns = DNSimple(username=settings.DNSIMPLE_USERNAME,
password=settings.DNSIMPLE_PASSWORD)
try:
raspi_records = dns.records('raspi.tw')
except:
return None
raspi_dns_records = list()
for raspi_record in raspi_records:
if raspi_record['record']['name'] == subdomain:
t = dict()
t['id'] = raspi_record['record']['id']
t['name'] = raspi_record['record']['name']
t['record_type'] = raspi_record['record']['record_type']
t['content'] = raspi_record['record']['content']
raspi_dns_records.append(t)
return raspi_dns_records
def dnsimple_set_ip(api_token, list_records, domain, subdomain, **kwargs):
dns = DNSimple(api_token=api_token)
records = [x['record'] for x in dns.records(domain)]
if list_records:
print_records(records)
return
subdomain_record = None
for rec in records:
if subdomain == rec['name']:
subdomain_record = rec
break
if subdomain_record is None:
create_subdomain(dns, domain, subdomain)
else:
update_subdomain(dns, domain, subdomain_record)
class DNS:
def __init__(self, context, domain='telephone.org'):
self.context = context
self.domain = domain
creds = self.context.secrets['dns.dnsimple']
self.api = DNSimple(
username=creds['email'],
password=creds['password']
)
def get(self, kind='A', name='', content='', **kwargs):
recs = self.api.records(self.domain)
recs = [r['record'] for r in recs]
if kind:
recs = [r for r in recs if r['record_type'] == kind.upper()]
if name:
recs = [r for r in recs if r['name'].lower() == name.lower()]
if content:
recs = [r for r in recs if r['content'] == content]
return recs
def add(self, kind='A', name='', content='', **kwargs):
recs = self.get(kind, name, content, **kwargs)
if recs:
print('record exists, do not recreate')
return False
if not recs:
print('record does not exist, creating')
data = dict(
record_type=kind.upper(),
name=name,
content=content
)
data.update(**kwargs)
return self.api.add_record(self.domain, data)
def delete(self, kind='A', name='', content='', **kwargs):
recs = self.get(kind, name, content, **kwargs)
for record_id in [rec['id'] for rec in recs]:
self.api.delete_record(self.domain, record_id)
print('{} records deleted'.format(len(recs)))
def create_record(data):
nonexistant = False
record = {
'type': data['type'],
'name': data['name'],
'content': data['content'],
'ttl': data['ttl']
}
dns = DNSimple(api_token=data['dnsimple_token'],
account_id=data['dnsimple_account'])
if 'present' in data['state']:
for n in dns.records(data['domain']):
if record['name'] == n['record']['name']:
res = dns.update_record(data['domain'], n['record']['id'],
record)
nonexistant = False
return (True, res['record']['id'], 'record updated')
else:
nonexistant = True
if nonexistant:
res = dns.add_record(data['domain'], record)
return (True, res['record']['id'], 'record added')
return (False, "{}", 'no record added')
def test_domain_token_auth(self):
# FIXME: Needs proper/publishable credentials/domain to work on sandbox
dns = DNSimple(domain_token='DOMAIN_TOKEN', sandbox=True)
with self.assertRaises(DNSimpleException):
self.assertTrue(type(dns.domains()) is list)
self.assertTrue(type(dns.records('DOMAIN')) is list)
def main():
module = AnsibleModule(
argument_spec = dict(
account_email = dict(required=False),
account_api_token = dict(required=False, no_log=True),
domain = dict(required=False),
record = dict(required=False),
record_ids = dict(required=False, type='list'),
type = dict(required=False, choices=['A', 'ALIAS', 'CNAME', 'MX', 'SPF', 'URL', 'TXT', 'NS', 'SRV', 'NAPTR', 'PTR', 'AAAA', 'SSHFP', 'HINFO', 'POOL']),
ttl = dict(required=False, default=3600, type='int'),
value = dict(required=False),
priority = dict(required=False, type='int'),
state = dict(required=False, choices=['present', 'absent']),
solo = dict(required=False, type='bool'),
),
required_together = (
['record', 'value']
),
supports_check_mode = True,
)
if not HAS_DNSIMPLE:
module.fail_json(msg="dnsimple required for this module")
account_email = module.params.get('account_email')
account_api_token = module.params.get('account_api_token')
domain = module.params.get('domain')
record = module.params.get('record')
record_ids = module.params.get('record_ids')
record_type = module.params.get('type')
ttl = module.params.get('ttl')
value = module.params.get('value')
priority = module.params.get('priority')
state = module.params.get('state')
is_solo = module.params.get('solo')
if account_email and account_api_token:
client = DNSimple(email=account_email, api_token=account_api_token)
elif os.environ.get('DNSIMPLE_EMAIL') and os.environ.get('DNSIMPLE_API_TOKEN'):
client = DNSimple(email=os.environ.get('DNSIMPLE_EMAIL'), api_token=os.environ.get('DNSIMPLE_API_TOKEN'))
else:
client = DNSimple()
try:
# Let's figure out what operation we want to do
# No domain, return a list
if not domain:
domains = client.domains()
module.exit_json(changed=False, result=[d['domain'] for d in domains])
# Domain & No record
if domain and record is None and not record_ids:
domains = [d['domain'] for d in client.domains()]
if domain.isdigit():
dr = next((d for d in domains if d['id'] == int(domain)), None)
else:
dr = next((d for d in domains if d['name'] == domain), None)
if state == 'present':
if dr:
module.exit_json(changed=False, result=dr)
else:
if module.check_mode:
module.exit_json(changed=True)
else:
module.exit_json(changed=True, result=client.add_domain(domain)['domain'])
elif state == 'absent':
if dr:
if not module.check_mode:
client.delete(domain)
module.exit_json(changed=True)
else:
module.exit_json(changed=False)
else:
module.fail_json(msg="'%s' is an unknown value for the state argument" % state)
# need the not none check since record could be an empty string
if domain and record is not None:
records = [r['record'] for r in client.records(str(domain))]
if not record_type:
module.fail_json(msg="Missing the record type")
if not value:
module.fail_json(msg="Missing the record value")
rr = next((r for r in records if r['name'] == record and r['record_type'] == record_type and r['content'] == value), None)
if state == 'present':
changed = False
if is_solo:
# delete any records that have the same name and record type
same_type = [r['id'] for r in records if r['name'] == record and r['record_type'] == record_type]
if rr:
same_type = [rid for rid in same_type if rid != rr['id']]
if same_type:
if not module.check_mode:
for rid in same_type:
client.delete_record(str(domain), rid)
changed = True
if rr:
# check if we need to update
if rr['ttl'] != ttl or rr['prio'] != priority:
data = {}
if ttl: data['ttl'] = ttl
if priority: data['prio'] = priority
if module.check_mode:
module.exit_json(changed=True)
else:
module.exit_json(changed=True, result=client.update_record(str(domain), str(rr['id']), data)['record'])
else:
module.exit_json(changed=changed, result=rr)
else:
# create it
data = {
'name': record,
'record_type': record_type,
'content': value,
}
if ttl: data['ttl'] = ttl
if priority: data['prio'] = priority
if module.check_mode:
module.exit_json(changed=True)
else:
module.exit_json(changed=True, result=client.add_record(str(domain), data)['record'])
elif state == 'absent':
if rr:
if not module.check_mode:
client.delete_record(str(domain), rr['id'])
module.exit_json(changed=True)
else:
module.exit_json(changed=False)
else:
module.fail_json(msg="'%s' is an unknown value for the state argument" % state)
# Make sure these record_ids either all exist or none
if domain and record_ids:
current_records = [str(r['record']['id']) for r in client.records(str(domain))]
wanted_records = [str(r) for r in record_ids]
if state == 'present':
difference = list(set(wanted_records) - set(current_records))
if difference:
module.fail_json(msg="Missing the following records: %s" % difference)
else:
module.exit_json(changed=False)
elif state == 'absent':
difference = list(set(wanted_records) & set(current_records))
if difference:
if not module.check_mode:
for rid in difference:
client.delete_record(str(domain), rid)
module.exit_json(changed=True)
else:
module.exit_json(changed=False)
else:
module.fail_json(msg="'%s' is an unknown value for the state argument" % state)
except DNSimpleException:
e = get_exception()
module.fail_json(msg="Unable to contact DNSimple: %s" % e.message)
module.fail_json(msg="Unknown what you wanted me to do")
def test_domain_token_auth(self):
# FIXME: Needs proper/publishable credentials/domain to work on sandbox
dns = DNSimple(domain_token='DOMAIN_TOKEN', sandbox=True)
with self.assertRaises(DNSimpleException):
self.assertTrue(type(dns.domains()) is list)
self.assertTrue(type(dns.records('DOMAIN')) is list)
#chop the .conf off to get the fqdn
fqdn=del_file[:-5]
#grab just the subdomain portion from the fqdn
subdomain = fqdn.split('.')[0]
#get the base domain name out of the fqdn
base_domain = re.sub("^[^.]*\.(?=\w+\.\w+$)", "", fqdn)
#determine the site root
site_root = site_root_base+fqdn+"/"
#create DNSimple object
dns = DNSimple(email=dnsimple_email_address, api_token=dnsimple_api_token)
#read in all records of domain from dnsimple
records = dns.records(base_domain)
#declare variable for record it (to be determined below)
record_id = None
#iterate through the list of dictionary objects
for record in records:
#access the record key and the nested name key
record_name = record.get("record").get("name")
#see if what you just found matches the sub domain you're looking for
if record_name == subdomain:
#if it is, access the nested id key and store it
record_id = record.get("record").get("id")
break
'''
global shelf
shelf[last_ip_key] = ip
shelf.close()
if __name__ == '__main__':
# Retrieve current IP address
current_ip = get_current_ip_address()
previous_ip = unshelve_previous_ip_address(
) # retrieve last known IP address
# handle IP change.
if current_ip == previous_ip:
raise Exception("IP did not change since last update.")
else:
shelve_current_ip_address(current_ip) # store current IP address
# Fetch domain records using DNSimple API
dns = DNSimple()
records = dns.records(target_domain_name)
target_record = find_record(records, target_record_name)
new_record_data = {
'content': current_ip
} # could also contain time to live, etc.
print "Updating dom %s, rec %s with content: %s" % (
target_record['domain_id'], target_record['id'], current_ip)
dns.update_record(target_record['domain_id'], target_record['id'],
new_record_data)
#chop the .conf off to get the fqdn
fqdn = del_file[:-5]
#grab just the subdomain portion from the fqdn
subdomain = fqdn.split('.')[0]
#get the base domain name out of the fqdn
base_domain = re.sub("^[^.]*\.(?=\w+\.\w+$)", "", fqdn)
#determine the site root
site_root = site_root_base + fqdn + "/"
#create DNSimple object
dns = DNSimple(email=dnsimple_email_address, api_token=dnsimple_api_token)
#read in all records of domain from dnsimple
records = dns.records(base_domain)
#declare variable for record it (to be determined below)
record_id = None
#iterate through the list of dictionary objects
for record in records:
#access the record key and the nested name key
record_name = record.get("record").get("name")
#see if what you just found matches the sub domain you're looking for
if record_name == subdomain:
#if it is, access the nested id key and store it
record_id = record.get("record").get("id")
break
from urllib import request
from dnsimple import DNSimple
dns = DNSimple()
ip = request.urlopen('https://ifconfig.co/ip').read().decode('utf-8').rstrip()
data = {'content': ip}
domain = 'example.com' # Change this!
for item in dns.records(domain):
if item['record']['record_type'] == 'A':
if item['record']['content'] != ip:
old_ip = item['record']['content']
id = item['record']['id']
dns.update_record(domain, id, data)
print('Updated', old_ip, 'to', ip)
class DNSimpleV1():
"""class which uses dnsimple-python < 2"""
def __init__(self, account_email, account_api_token, sandbox, module):
"""init"""
self.module = module
self.account_email = account_email
self.account_api_token = account_api_token
self.sandbox = sandbox
self.dnsimple_client()
def dnsimple_client(self):
"""creates a dnsimple client object"""
if self.account_email and self.account_api_token:
self.client = DNSimple(sandbox=self.sandbox, email=self.account_email, api_token=self.account_api_token)
else:
self.client = DNSimple(sandbox=self.sandbox)
def get_all_domains(self):
"""returns a list of all domains"""
domain_list = self.client.domains()
return [d['domain'] for d in domain_list]
def get_domain(self, domain):
"""returns a single domain by name or id"""
try:
dr = self.client.domain(domain)['domain']
except DNSimpleException as e:
exception_string = str(e.args[0]['message'])
if re.match(r"^Domain .+ not found$", exception_string):
dr = None
else:
raise
return dr
def create_domain(self, domain):
"""create a single domain"""
return self.client.add_domain(domain)['domain']
def delete_domain(self, domain):
"""delete a single domain"""
self.client.delete(domain)
def get_records(self, domain, dnsimple_filter=None):
"""return dns ressource records which match a specified filter"""
return [r['record'] for r in self.client.records(str(domain), params=dnsimple_filter)]
def delete_record(self, domain, rid):
"""delete a single dns ressource record"""
self.client.delete_record(str(domain), rid)
def update_record(self, domain, rid, ttl=None, priority=None):
"""update a single dns ressource record"""
data = {}
if ttl:
data['ttl'] = ttl
if priority:
data['priority'] = priority
return self.client.update_record(str(domain), str(rid), data)['record']
def create_record(self, domain, name, record_type, content, ttl=None, priority=None):
"""create a single dns ressource record"""
data = {
'name': name,
'type': record_type,
'content': content,
}
if ttl:
data['ttl'] = ttl
if priority:
data['priority'] = priority
return self.client.add_record(str(domain), data)['record']
def shelve_current_ip_address(ip):
'''
Stores current IP address in a file using Python's Shelve.
:param ip: the current IP address to be stored in the file.
'''
global shelf
shelf[last_ip_key] = ip
shelf.close()
if __name__ == '__main__':
# Retrieve current IP address
current_ip = get_current_ip_address()
previous_ip = unshelve_previous_ip_address() # retrieve last known IP address
# handle IP change.
if current_ip == previous_ip:
raise Exception("IP did not change since last update.")
else:
shelve_current_ip_address(current_ip) # store current IP address
# Fetch domain records using DNSimple API
dns = DNSimple()
records = dns.records(target_domain_name)
target_record = find_record(records, target_record_name)
new_record_data = {'content': current_ip} # could also contain time to live, etc.
print "Updating dom %s, rec %s with content: %s" % (target_record['domain_id'], target_record['id'], current_ip)
dns.update_record(target_record['domain_id'], target_record['id'], new_record_data)
def main():
module = AnsibleModule(
argument_spec=dict(
account_email=dict(required=False),
account_api_token=dict(required=False, no_log=True),
domain=dict(required=False),
record=dict(required=False),
record_ids=dict(required=False, type='list'),
type=dict(required=False,
choices=[
'A', 'ALIAS', 'CNAME', 'MX', 'SPF', 'URL', 'TXT',
'NS', 'SRV', 'NAPTR', 'PTR', 'AAAA', 'SSHFP',
'HINFO', 'POOL'
]),
ttl=dict(required=False, default=3600, type='int'),
value=dict(required=False),
priority=dict(required=False, type='int'),
state=dict(required=False, choices=['present', 'absent']),
solo=dict(required=False, type='bool'),
),
required_together=(['record', 'value']),
supports_check_mode=True,
)
if not HAS_DNSIMPLE:
module.fail_json(msg="dnsimple required for this module")
account_email = module.params.get('account_email')
account_api_token = module.params.get('account_api_token')
domain = module.params.get('domain')
record = module.params.get('record')
record_ids = module.params.get('record_ids')
record_type = module.params.get('type')
ttl = module.params.get('ttl')
value = module.params.get('value')
priority = module.params.get('priority')
state = module.params.get('state')
is_solo = module.params.get('solo')
if account_email and account_api_token:
client = DNSimple(email=account_email, api_token=account_api_token)
elif os.environ.get('DNSIMPLE_EMAIL') and os.environ.get(
'DNSIMPLE_API_TOKEN'):
client = DNSimple(email=os.environ.get('DNSIMPLE_EMAIL'),
api_token=os.environ.get('DNSIMPLE_API_TOKEN'))
else:
client = DNSimple()
try:
# Let's figure out what operation we want to do
# No domain, return a list
if not domain:
domains = client.domains()
module.exit_json(changed=False,
result=[d['domain'] for d in domains])
# Domain & No record
if domain and record is None and not record_ids:
domains = [d['domain'] for d in client.domains()]
if domain.isdigit():
dr = next((d for d in domains if d['id'] == int(domain)), None)
else:
dr = next((d for d in domains if d['name'] == domain), None)
if state == 'present':
if dr:
module.exit_json(changed=False, result=dr)
else:
if module.check_mode:
module.exit_json(changed=True)
else:
module.exit_json(
changed=True,
result=client.add_domain(domain)['domain'])
elif state == 'absent':
if dr:
if not module.check_mode:
client.delete(domain)
module.exit_json(changed=True)
else:
module.exit_json(changed=False)
else:
module.fail_json(
msg="'%s' is an unknown value for the state argument" %
state)
# need the not none check since record could be an empty string
if domain and record is not None:
records = [r['record'] for r in client.records(str(domain))]
if not record_type:
module.fail_json(msg="Missing the record type")
if not value:
module.fail_json(msg="Missing the record value")
rr = next(
(r for r in records
if r['name'] == record and r['record_type'] == record_type
and r['content'] == value), None)
if state == 'present':
changed = False
if is_solo:
# delete any records that have the same name and record type
same_type = [
r['id'] for r in records if r['name'] == record
and r['record_type'] == record_type
]
if rr:
same_type = [
rid for rid in same_type if rid != rr['id']
]
if same_type:
if not module.check_mode:
for rid in same_type:
client.delete_record(str(domain), rid)
changed = True
if rr:
# check if we need to update
if rr['ttl'] != ttl or rr['prio'] != priority:
data = {}
if ttl:
data['ttl'] = ttl
if priority:
data['prio'] = priority
if module.check_mode:
module.exit_json(changed=True)
else:
module.exit_json(changed=True,
result=client.update_record(
str(domain), str(rr['id']),
data)['record'])
else:
module.exit_json(changed=changed, result=rr)
else:
# create it
data = {
'name': record,
'record_type': record_type,
'content': value,
}
if ttl:
data['ttl'] = ttl
if priority:
data['prio'] = priority
if module.check_mode:
module.exit_json(changed=True)
else:
module.exit_json(changed=True,
result=client.add_record(
str(domain), data)['record'])
elif state == 'absent':
if rr:
if not module.check_mode:
client.delete_record(str(domain), rr['id'])
module.exit_json(changed=True)
else:
module.exit_json(changed=False)
else:
module.fail_json(
msg="'%s' is an unknown value for the state argument" %
state)
# Make sure these record_ids either all exist or none
if domain and record_ids:
current_records = [
str(r['record']['id']) for r in client.records(str(domain))
]
wanted_records = [str(r) for r in record_ids]
if state == 'present':
difference = list(set(wanted_records) - set(current_records))
if difference:
module.fail_json(msg="Missing the following records: %s" %
difference)
else:
module.exit_json(changed=False)
elif state == 'absent':
difference = list(set(wanted_records) & set(current_records))
if difference:
if not module.check_mode:
for rid in difference:
client.delete_record(str(domain), rid)
module.exit_json(changed=True)
else:
module.exit_json(changed=False)
else:
module.fail_json(
msg="'%s' is an unknown value for the state argument" %
state)
except DNSimpleException as e:
module.fail_json(msg="Unable to contact DNSimple: %s" % e.message)
module.fail_json(msg="Unknown what you wanted me to do")
from dnsimple import DNSimple
import ipgetter
# Use email/api_token credentials
dns = DNSimple(email='*****@*****.**',
api_token='LMpfhsnUYhZQcWdGqG0x2B6LI4yidd5q')
domains = dns.domains()
# print(domains)
records = dns.records('lupu.online')
# print(records)
IP_ADDRESS = ipgetter.myip()
# print(IP_ADDRESS)
DOMAIN_ID = 247223
RECORD_ID = 5940312
DATA = {
'name': 'rpi',
'content': IP_ADDRESS,
'ttl': '3600',
'prio': None,
}
dns.update_record(DOMAIN_ID, RECORD_ID, DATA)
