# 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.
"""
PowerDNS Driver
"""
import json
from libcloud.common.base import ConnectionKey, JsonResponse
from libcloud.common.exceptions import BaseHTTPError
from libcloud.common.types import InvalidCredsError, MalformedResponseError
from libcloud.dns.base import DNSDriver, Zone, Record
from libcloud.dns.types import ZoneDoesNotExistError, ZoneAlreadyExistsError
from libcloud.dns.types import Provider, RecordType
from libcloud.utils.py3 import httplib
__all__ = [
'PowerDNSDriver',
]
class PowerDNSResponse(JsonResponse):
def success(self):
i = int(self.status)
return 200 <= i <= 299
def parse_error(self):
if self.status == httplib.UNAUTHORIZED:
raise InvalidCredsError('Invalid provider credentials')
try:
body = self.parse_body()
except MalformedResponseError as e:
body = '%s: %s' % (e.value, e.body)
try:
errors = [body['error']]
except TypeError:
# parse_body() gave us a simple string, not a dict.
return '%s (HTTP Code: %d)' % (body, self.status)
try:
errors.append(body['errors'])
except KeyError:
# The PowerDNS API does not return the "errors" list all the time.
pass
return '%s (HTTP Code: %d)' % (' '.join(errors), self.status)
class PowerDNSConnection(ConnectionKey):
responseCls = PowerDNSResponse
def add_default_headers(self, headers):
headers['X-API-Key'] = self.key
return headers
[docs]class PowerDNSDriver(DNSDriver):
type = Provider.POWERDNS
name = 'PowerDNS'
website = 'https://www.powerdns.com/'
connectionCls = PowerDNSConnection
RECORD_TYPE_MAP = {
RecordType.A: 'A',
RecordType.AAAA: 'AAAA',
RecordType.AFSDB: 'AFSDB',
RecordType.CERT: 'CERT',
RecordType.CNAME: 'CNAME',
RecordType.DNSKEY: 'DNSKEY',
RecordType.DS: 'DS',
RecordType.HINFO: 'HINFO',
RecordType.KEY: 'KEY',
RecordType.LOC: 'LOC',
RecordType.MX: 'MX',
RecordType.NAPTR: 'NAPTR',
RecordType.NS: 'NS',
RecordType.NSEC: 'NSEC',
RecordType.OPENPGPKEY: 'OPENPGPKEY',
RecordType.PTR: 'PTR',
RecordType.RP: 'RP',
RecordType.RRSIG: 'RRSIG',
RecordType.SOA: 'SOA',
RecordType.SPF: 'SPF',
RecordType.SSHFP: 'SSHFP',
RecordType.SRV: 'SRV',
RecordType.TLSA: 'TLSA',
RecordType.TXT: 'TXT',
}
def __init__(self, key, secret=None, secure=False, host=None, port=None,
api_version='experimental', **kwargs):
"""
PowerDNS Driver defaulting to using PowerDNS 3.x API (ie
"experimental").
:param key: API key or username to used (required)
:type key: ``str``
:param secure: Whether to use HTTPS or HTTP. Note: Off by default
for PowerDNS.
:type secure: ``bool``
:param host: Hostname used for connections.
:type host: ``str``
:param port: Port used for connections.
:type port: ``int``
:param api_version: Specifies the API version to use.
``experimental`` and ``v1`` are the only valid
options. Defaults to using ``experimental``
(optional)
:type api_version: ``str``
:return: ``None``
"""
# libcloud doesn't really have a concept of "servers". We'll just use
# localhost for now.
self.ex_server = 'localhost'
if api_version == 'experimental':
# PowerDNS 3.x has no API root prefix.
self.api_root = ''
elif api_version == 'v1':
# PowerDNS 4.x has an '/api/v1' root prefix.
self.api_root = '/api/v1'
else:
raise NotImplementedError('Unsupported API version: %s' %
api_version)
super(PowerDNSDriver, self).__init__(key=key, secure=secure,
host=host, port=port,
**kwargs)
[docs] def create_record(self, name, zone, type, data, extra=None):
"""
Create a new record.
There are two PowerDNS-specific quirks here. Firstly, this method will
silently clobber any pre-existing records that might already exist. For
example, if PowerDNS already contains a "test.example.com" A record,
and you create that record using this function, then the old A record
will be replaced with your new one.
Secondly, PowerDNS requires that you provide a ttl for all new records.
In other words, the "extra" parameter must be ``{'ttl':
<some-integer>}`` at a minimum.
:param name: FQDN of the new record, for example "www.example.com".
: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 (driver specific, e.g. 'ttl').
Note that PowerDNS *requires* a ttl value for every
record.
:type extra: ``dict``
:rtype: :class:`Record`
"""
extra = extra or {}
action = '%s/servers/%s/zones/%s' % (self.api_root, self.ex_server,
zone.id)
if extra is None or extra.get('ttl', None) is None:
raise ValueError('PowerDNS requires a ttl value for every record')
if self._pdns_version() == 3:
record = {
'content': data,
'disabled': False,
'name': name,
'ttl': extra['ttl'],
'type': type,
}
payload = {
'rrsets': [
{
'name': name,
'type': type,
'changetype': 'REPLACE',
'records': [record]
}
]
}
elif self._pdns_version() == 4:
record = {
'content': data,
'disabled': extra.get('disabled', False),
'set-ptr': False,
}
payload = {
'rrsets': [
{
'name': name,
'type': type,
'changetype': 'REPLACE',
'ttl': extra['ttl'],
'records': [record],
}
]
}
if 'comment' in extra:
payload['rrsets'][0]['comments'] = extra['comment']
try:
self.connection.request(action=action, data=json.dumps(payload),
method='PATCH')
except BaseHTTPError as e:
if e.code == httplib.UNPROCESSABLE_ENTITY and \
e.message.startswith('Could not find domain'):
raise ZoneDoesNotExistError(zone_id=zone.id, driver=self,
value=e.message)
raise e
return Record(id=None, name=name, data=data,
type=type, zone=zone, driver=self, ttl=extra['ttl'])
[docs] def create_zone(self, domain, type=None, ttl=None, extra={}):
"""
Create a new zone.
There are two PowerDNS-specific quirks here. Firstly, the "type" and
"ttl" parameters are ignored (no-ops). The "type" parameter is simply
not implemented, and PowerDNS does not have an ability to set a
zone-wide default TTL. (TTLs must be set per-record.)
Secondly, PowerDNS requires that you provide a list of nameservers for
the zone upon creation. In other words, the "extra" parameter must be
``{'nameservers': ['ns1.example.org']}`` at a minimum.
:param name: Zone domain name (e.g. example.com)
:type name: ``str``
:param domain: Zone type (master / slave). (optional). Note that the
PowerDNS driver does nothing with this parameter.
:type domain: :class:`Zone`
:param ttl: TTL for new records. (optional). Note that the PowerDNS
driver does nothing with this parameter.
:type ttl: ``int``
:param extra: Extra attributes (driver specific).
For example, specify
``extra={'nameservers': ['ns1.example.org']}`` to set
a list of nameservers for this new zone.
:type extra: ``dict``
:rtype: :class:`Zone`
"""
action = '%s/servers/%s/zones' % (self.api_root, self.ex_server)
if extra is None or extra.get('nameservers', None) is None:
msg = 'PowerDNS requires a list of nameservers for every new zone'
raise ValueError(msg)
payload = {'name': domain, 'kind': 'Native'}
payload.update(extra)
zone_id = domain + '.'
try:
self.connection.request(action=action, data=json.dumps(payload),
method='POST')
except BaseHTTPError as e:
if e.code == httplib.UNPROCESSABLE_ENTITY and \
e.message.startswith("Domain '%s' already exists" % domain):
raise ZoneAlreadyExistsError(zone_id=zone_id, driver=self,
value=e.message)
raise e
return Zone(id=zone_id, domain=domain, type=None, ttl=None,
driver=self, extra=extra)
[docs] def delete_record(self, record):
"""
Use this method to delete a record.
:param record: record to delete
:type record: `Record`
:rtype: ``bool``
"""
action = '%s/servers/%s/zones/%s' % (self.api_root, self.ex_server,
record.zone.id)
payload = {'rrsets': [{'name': record.name,
'type': record.type,
'changetype': 'DELETE',
}]
}
try:
self.connection.request(action=action, data=json.dumps(payload),
method='PATCH')
except BaseHTTPError:
# I'm not sure if we should raise a ZoneDoesNotExistError here. The
# base DNS API only specifies that we should return a bool. So,
# let's ignore this code for now.
# if e.code == httplib.UNPROCESSABLE_ENTITY and \
# e.message.startswith('Could not find domain'):
# raise ZoneDoesNotExistError(zone_id=zone.id, driver=self,
# value=e.message)
# raise e
return False
return True
[docs] def delete_zone(self, zone):
"""
Use this method to delete a zone.
:param zone: zone to delete
:type zone: `Zone`
:rtype: ``bool``
"""
action = '%s/servers/%s/zones/%s' % (self.api_root, self.ex_server,
zone.id)
try:
self.connection.request(action=action, method='DELETE')
except BaseHTTPError:
# I'm not sure if we should raise a ZoneDoesNotExistError here. The
# base DNS API only specifies that we should return a bool. So,
# let's ignore this code for now.
# if e.code == httplib.UNPROCESSABLE_ENTITY and \
# e.message.startswith('Could not find domain'):
# raise ZoneDoesNotExistError(zone_id=zone.id, driver=self,
# value=e.message)
# raise e
return False
return True
[docs] def get_zone(self, zone_id):
"""
Return a Zone instance.
(Note that PowerDNS does not support per-zone TTL defaults, so all Zone
objects will have ``ttl=None``.)
:param zone_id: name of the required zone with the trailing period, for
example "example.com.".
:type zone_id: ``str``
:rtype: :class:`Zone`
:raises: ZoneDoesNotExistError: If no zone could be found.
"""
action = '%s/servers/%s/zones/%s' % (self.api_root, self.ex_server,
zone_id)
try:
response = self.connection.request(action=action, method='GET')
except BaseHTTPError as e:
if e.code == httplib.UNPROCESSABLE_ENTITY:
raise ZoneDoesNotExistError(zone_id=zone_id, driver=self,
value=e.message)
raise e
return self._to_zone(response.object)
[docs] def list_records(self, zone):
"""
Return a list of all records for the provided zone.
:param zone: Zone to list records for.
:type zone: :class:`Zone`
:return: ``list`` of :class:`Record`
"""
action = '%s/servers/%s/zones/%s' % (self.api_root, self.ex_server,
zone.id)
try:
response = self.connection.request(action=action, method='GET')
except BaseHTTPError as e:
if e.code == httplib.UNPROCESSABLE_ENTITY and \
e.message.startswith('Could not find domain'):
raise ZoneDoesNotExistError(zone_id=zone.id, driver=self,
value=e.message)
raise e
return self._to_records(response, zone)
[docs] def list_zones(self):
"""
Return a list of zones.
:return: ``list`` of :class:`Zone`
"""
action = '%s/servers/%s/zones' % (self.api_root, self.ex_server)
response = self.connection.request(action=action, method='GET')
return self._to_zones(response)
[docs] def update_record(self, record, name, type, data, extra=None):
"""
Update an existing record.
:param record: Record to update.
:type record: :class:`Record`
:param name: FQDN of the new record, for example "www.example.com".
:type name: ``str``
: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: (optional) Extra attributes (driver specific).
:type extra: ``dict``
:rtype: :class:`Record`
"""
action = '%s/servers/%s/zones/%s' % (self.api_root, self.ex_server,
record.zone.id)
if extra is None or extra.get('ttl', None) is None:
raise ValueError('PowerDNS requires a ttl value for every record')
if self._pdns_version() == 3:
updated_record = {
'content': data,
'disabled': False,
'name': name,
'ttl': extra['ttl'],
'type': type,
}
payload = {
'rrsets': [
{
'name': record.name,
'type': record.type,
'changetype': 'DELETE',
},
{
'name': name,
'type': type,
'changetype': 'REPLACE',
'records': [updated_record]
}
]
}
elif self._pdns_version() == 4:
disabled = False
if "disabled" in extra:
disabled = extra['disabled']
updated_record = {
'content': data,
'disabled': disabled,
'set-ptr': False,
}
payload = {
'rrsets': [{
'name': name,
'type': type,
'changetype': 'REPLACE',
'ttl': extra['ttl'],
'records': [updated_record],
}]
}
if 'comment' in extra:
payload["rrsets"][0]["comments"] = extra['comment']
try:
self.connection.request(action=action, data=json.dumps(payload),
method='PATCH')
except BaseHTTPError as e:
if e.code == httplib.UNPROCESSABLE_ENTITY and \
e.message.startswith('Could not find domain'):
raise ZoneDoesNotExistError(zone_id=record.zone.id,
driver=self, value=e.message)
raise e
return Record(id=None, name=name, data=data, type=type,
zone=record.zone, driver=self, ttl=extra['ttl'])
def _to_zone(self, item):
extra = {}
for e in ['kind', 'dnssec', 'account', 'masters', 'serial',
'notified_serial', 'last_check']:
extra[e] = item[e]
# XXX: we have to hard-code "ttl" to "None" here because PowerDNS does
# not support per-zone ttl defaults. However, I don't know what "type"
# should be; probably not None.
return Zone(id=item['id'], domain=item['name'], type=None,
ttl=None, driver=self, extra=extra)
def _to_zones(self, items):
zones = []
for item in items.object:
zones.append(self._to_zone(item))
return zones
def _to_record(self, item, zone, record=None):
if record is None:
data = item['content']
else:
data = record['content']
return Record(id=None, name=item['name'], data=data,
type=item['type'], zone=zone, driver=self,
ttl=item['ttl'])
def _to_records(self, items, zone):
records = []
if self._pdns_version() == 3:
for item in items.object['records']:
records.append(self._to_record(item, zone))
elif self._pdns_version() == 4:
for item in items.object['rrsets']:
for record in item['records']:
records.append(self._to_record(item, zone, record))
return records
def _pdns_version(self):
if self.api_root == '':
return 3
elif self.api_root == '/api/v1':
return 4
raise ValueError('PowerDNS version has not been declared')