304 lines
10 KiB
Python
304 lines
10 KiB
Python
# Licensed to the Apache Software Foundation (ASF) under one or more
|
|
# contributor license agreements. See the NOTICE file distributed with
|
|
# this work for additional information regarding copyright ownership.
|
|
# The ASF licenses this file to You under the Apache License, Version 2.0
|
|
# (the "License"); you may not use this file except in compliance with
|
|
# the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""
|
|
Digital Ocean DNS Driver
|
|
"""
|
|
|
|
__all__ = [
|
|
'DigitalOceanDNSDriver'
|
|
]
|
|
|
|
import json
|
|
|
|
from libcloud.utils.py3 import httplib
|
|
|
|
from libcloud.common.digitalocean import DigitalOcean_v2_BaseDriver
|
|
from libcloud.common.digitalocean import DigitalOcean_v2_Connection
|
|
from libcloud.dns.types import Provider, RecordType
|
|
from libcloud.dns.base import DNSDriver, Zone, Record
|
|
|
|
|
|
class DigitalOceanDNSDriver(DigitalOcean_v2_BaseDriver, DNSDriver):
|
|
connectionCls = DigitalOcean_v2_Connection
|
|
type = Provider.DIGITAL_OCEAN
|
|
name = "DigitalOcean"
|
|
website = 'https://www.digitalocean.com'
|
|
|
|
RECORD_TYPE_MAP = {
|
|
RecordType.NS: 'NS',
|
|
RecordType.A: 'A',
|
|
RecordType.AAAA: 'AAAA',
|
|
RecordType.CNAME: 'CNAME',
|
|
RecordType.MX: 'MX',
|
|
RecordType.TXT: 'TXT',
|
|
RecordType.SRV: 'SRV',
|
|
}
|
|
|
|
def list_zones(self):
|
|
"""
|
|
Return a list of zones.
|
|
|
|
:return: ``list`` of :class:`Zone`
|
|
"""
|
|
data = self._paginated_request('/v2/domains', 'domains')
|
|
return list(map(self._to_zone, data))
|
|
|
|
def list_records(self, zone):
|
|
"""
|
|
Return a list of records for the provided zone.
|
|
|
|
:param zone: Zone to list records for.
|
|
:type zone: :class:`Zone`
|
|
|
|
:return: ``list`` of :class:`Record`
|
|
"""
|
|
data = self._paginated_request('/v2/domains/%s/records' % (zone.id),
|
|
'domain_records')
|
|
# TODO: Not use list comprehension to add zone to record for proper data map
|
|
# functionality? This passes a reference to zone for each data currently
|
|
# to _to_record which returns a Record. map() does not take keywords
|
|
return list(map(self._to_record, data, [zone for z in data]))
|
|
|
|
def get_zone(self, zone_id):
|
|
"""
|
|
Return a Zone instance.
|
|
|
|
:param zone_id: ID of the required zone
|
|
:type zone_id: ``str``
|
|
|
|
:rtype: :class:`Zone`
|
|
"""
|
|
data = self.connection.request('/v2/domains/%s' %
|
|
(zone_id)).object['domain']
|
|
|
|
return self._to_zone(data)
|
|
|
|
def get_record(self, zone_id, record_id):
|
|
"""
|
|
Return a Record instance.
|
|
|
|
:param zone_id: ID of the required zone
|
|
:type zone_id: ``str``
|
|
|
|
:param record_id: ID of the required record
|
|
:type record_id: ``str``
|
|
|
|
:rtype: :class:`Record`
|
|
"""
|
|
data = self.connection.request('/v2/domains/%s/records/%s' % (zone_id,
|
|
record_id)).object['domain_record']
|
|
|
|
# TODO: Any way of not using get_zone which polls the API again
|
|
# without breaking the DNSDriver.get_record parameters?
|
|
return self._to_record(data, self.get_zone(zone_id))
|
|
|
|
def create_zone(self, domain, type='master', ttl=None, extra=None):
|
|
"""
|
|
Create a new zone.
|
|
|
|
:param domain: Zone domain name (e.g. example.com)
|
|
:type domain: ``str``
|
|
|
|
:param type: Zone type (master / slave) (does nothing).
|
|
:type type: ``str``
|
|
|
|
:param ttl: TTL for new records. (does nothing)
|
|
:type ttl: ``int``
|
|
|
|
:param extra: Extra attributes (to set ip). (optional)
|
|
Note: This can be used to set the default A record with
|
|
{"ip" : "IP.AD.DR.ESS"} otherwise 127.0.0.1 is used
|
|
:type extra: ``dict``
|
|
|
|
:rtype: :class:`Zone`
|
|
"""
|
|
params = {'name': domain}
|
|
try:
|
|
params['ip_address'] = extra['ip']
|
|
except Exception:
|
|
params['ip_address'] = '127.0.0.1'
|
|
|
|
res = self.connection.request('/v2/domains', data=json.dumps(params),
|
|
method='POST')
|
|
|
|
return Zone(id=res.object['domain']['name'],
|
|
domain=res.object['domain']['name'],
|
|
type='master', ttl=1800, driver=self, extra={})
|
|
|
|
def create_record(self, name, zone, type, data, extra=None):
|
|
"""
|
|
Create a new record.
|
|
|
|
:param name: Record name without the domain name (e.g. www).
|
|
Note: If you want to create a record for a base domain
|
|
name, you should specify empty string ('') for this
|
|
argument.
|
|
:type name: ``str``
|
|
|
|
:param zone: Zone where the requested record is created.
|
|
:type zone: :class:`Zone`
|
|
|
|
:param type: DNS record type (A, AAAA, ...).
|
|
:type type: :class:`RecordType`
|
|
|
|
:param data: Data for the record (depends on the record type).
|
|
:type data: ``str``
|
|
|
|
:param extra: Extra attributes for MX and SRV. (Depends on record)
|
|
{"priority" : 0, "port" : 443, "weight" : 100}
|
|
:type extra: ``dict``
|
|
|
|
:rtype: :class:`Record`
|
|
"""
|
|
params = {
|
|
"type": self.RECORD_TYPE_MAP[type],
|
|
"name": name,
|
|
"data": data
|
|
}
|
|
if extra:
|
|
try:
|
|
params['priority'] = extra['priority']
|
|
except KeyError:
|
|
params['priority'] = None
|
|
try:
|
|
params['port'] = extra['port']
|
|
except KeyError:
|
|
params['port'] = None
|
|
try:
|
|
params['weight'] = extra['weight']
|
|
except KeyError:
|
|
params['weight'] = None
|
|
|
|
if 'ttl' in extra:
|
|
params['ttl'] = extra['ttl']
|
|
|
|
res = self.connection.request('/v2/domains/%s/records' % zone.id,
|
|
data=json.dumps(params),
|
|
method='POST')
|
|
|
|
return Record(id=res.object['domain_record']['id'],
|
|
name=res.object['domain_record']['name'],
|
|
type=type, data=data, zone=zone,
|
|
ttl=res.object['domain_record'].get('ttl', None),
|
|
driver=self, extra=extra)
|
|
|
|
def update_record(self, record, name=None, type=None,
|
|
data=None, extra=None):
|
|
"""
|
|
Update an existing record.
|
|
|
|
:param record: Record to update.
|
|
:type record: :class:`Record`
|
|
|
|
:param name: Record name without the domain name (e.g. www). (Ignored)
|
|
Note: The value is pulled from the record being updated
|
|
:type name: ``str``
|
|
|
|
:param type: DNS record type (A, AAAA, ...). (Ignored)
|
|
Note: Updating records does not support changing type
|
|
so this value is ignored
|
|
:type type: :class:`RecordType`
|
|
|
|
:param data: Data for the record (depends on the record type).
|
|
:type data: ``str``
|
|
|
|
:param extra: (optional) Extra attributes (driver specific).
|
|
:type extra: ``dict``
|
|
|
|
:rtype: :class:`Record`
|
|
"""
|
|
params = {
|
|
"type": record.type,
|
|
"name": record.name,
|
|
"data": data
|
|
}
|
|
if data is None:
|
|
params['data'] = record.data
|
|
if extra:
|
|
try:
|
|
params['priority'] = extra['priority']
|
|
except KeyError:
|
|
params['priority'] = None
|
|
try:
|
|
params['port'] = extra['port']
|
|
except KeyError:
|
|
params['port'] = None
|
|
try:
|
|
params['weight'] = extra['weight']
|
|
except KeyError:
|
|
params['weight'] = None
|
|
|
|
if 'ttl' in extra:
|
|
params['ttl'] = extra['ttl']
|
|
|
|
res = self.connection.request('/v2/domains/%s/records/%s' %
|
|
(record.zone.id, record.id),
|
|
data=json.dumps(params),
|
|
method='PUT')
|
|
|
|
return Record(id=res.object['domain_record']['id'],
|
|
name=res.object['domain_record']['name'],
|
|
type=record.type, data=data, zone=record.zone,
|
|
ttl=res.object['domain_record'].get('ttl', None),
|
|
driver=self, extra=extra)
|
|
|
|
def delete_zone(self, zone):
|
|
"""
|
|
Delete a zone.
|
|
|
|
Note: This will delete all the records belonging to this zone.
|
|
|
|
:param zone: Zone to delete.
|
|
:type zone: :class:`Zone`
|
|
|
|
:rtype: ``bool``
|
|
"""
|
|
params = {}
|
|
|
|
res = self.connection.request('/v2/domains/%s' % zone.id,
|
|
params=params, method='DELETE')
|
|
|
|
return res.status == httplib.NO_CONTENT
|
|
|
|
def delete_record(self, record):
|
|
"""
|
|
Delete a record.
|
|
|
|
:param record: Record to delete.
|
|
:type record: :class:`Record`
|
|
|
|
:rtype: ``bool``
|
|
"""
|
|
params = {}
|
|
|
|
res = self.connection.request('/v2/domains/%s/records/%s' % (
|
|
record.zone.id, record.id),
|
|
params=params,
|
|
method='DELETE')
|
|
return res.status == httplib.NO_CONTENT
|
|
|
|
def _to_record(self, data, zone=None):
|
|
extra = {'port': data['port'], 'priority': data['priority'],
|
|
'weight': data['weight']}
|
|
return Record(id=data['id'], name=data['name'],
|
|
type=self._string_to_record_type(data['type']),
|
|
data=data['data'], zone=zone, ttl=data.get('ttl', None),
|
|
driver=self, extra=extra)
|
|
|
|
def _to_zone(self, data):
|
|
extra = {'zone_file': data['zone_file']}
|
|
return Zone(id=data['name'], domain=data['name'], type='master',
|
|
ttl=data['ttl'], driver=self, extra=extra)
|