| # 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 |
| |
| |
| 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) |
| |
| 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']) |
| |
| 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) |
| |
| 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 |
| |
| 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 |
| |
| 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) |
| |
| 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) |
| |
| 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) |
| |
| 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') |
