Source code for libcloud.dns.drivers.rackspace

# 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
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.
import copy

from libcloud.dns.base import Zone, Record, DNSDriver
from libcloud.dns.types import Provider, RecordType, ZoneDoesNotExistError, RecordDoesNotExistError
from libcloud.utils.py3 import httplib
from libcloud.utils.misc import get_new_obj, merge_valid_keys
from libcloud.common.base import PollingConnection
from libcloud.common.types import LibcloudError
from libcloud.common.openstack import OpenStackDriverMixin
from libcloud.common.rackspace import AUTH_URL
from libcloud.common.exceptions import BaseHTTPError
from libcloud.compute.drivers.openstack import OpenStack_1_1_Response, OpenStack_1_1_Connection

__all__ = ["RackspaceDNSResponse", "RackspaceDNSConnection"]

VALID_ZONE_EXTRA_PARAMS = ["email", "comment", "ns1"]
VALID_RECORD_EXTRA_PARAMS = ["ttl", "comment", "priority", "created", "updated"]

[docs]class RackspaceDNSResponse(OpenStack_1_1_Response): """ Rackspace DNS Response class. """
[docs] def parse_error(self): status = int(self.status) context = self.connection.context body = self.parse_body() if status == httplib.NOT_FOUND: if context["resource"] == "zone": raise ZoneDoesNotExistError(value="", driver=self, zone_id=context["id"]) elif context["resource"] == "record": raise RecordDoesNotExistError(value="", driver=self, record_id=context["id"]) if body: if "code" and "message" in body: err = "{} - {} ({})".format(body["code"], body["message"], body["details"]) return err elif "validationErrors" in body: errors = [m for m in body["validationErrors"]["messages"]] err = "Validation errors: %s" % ", ".join(errors) return err raise LibcloudError("Unexpected status code: %s" % (status))
[docs]class RackspaceDNSConnection(OpenStack_1_1_Connection, PollingConnection): """ Rackspace DNS Connection class. """ responseCls = RackspaceDNSResponse XML_NAMESPACE = None poll_interval = 2.5 timeout = 30 auth_url = AUTH_URL _auth_version = "2.0" def __init__(self, *args, **kwargs): self.region = kwargs.pop("region", None) super().__init__(*args, **kwargs)
[docs] def get_poll_request_kwargs(self, response, context, request_kwargs): job_id = response.object["jobId"] kwargs = {"action": "/status/%s" % (job_id), "params": {"showDetails": True}} return kwargs
[docs] def has_completed(self, response): status = response.object["status"] if status == "ERROR": data = response.object["error"] if "code" and "message" in data: message = "{} - {} ({})".format( data["code"], data["message"], data["details"], ) else: message = data["message"] raise LibcloudError(message, driver=self.driver) return status == "COMPLETED"
[docs] def get_endpoint(self): if "2.0" in self._auth_version: ep = self.service_catalog.get_endpoint( name="cloudDNS", service_type="rax:dns", region=None ) else: raise LibcloudError("Auth version %s not supported" % (self._auth_version)) public_url = ep.url # This is a nasty hack, but because of how global auth and old accounts # work, there is no way around it. if self.region == "us": # Old UK account, which only has us endpoint in the catalog public_url = public_url.replace("https://lon.dns.api", "https://dns.api") if self.region == "uk": # Old US account, which only has uk endpoint in the catalog public_url = public_url.replace("https://dns.api", "https://lon.dns.api") return public_url
class RackspacePTRRecord: def __init__(self, id, ip, domain, driver, extra=None): = str(id) if id else None self.ip = ip self.type = RecordType.PTR self.domain = domain self.driver = driver self.extra = extra or {} def update(self, domain, extra=None): return self.driver.ex_update_ptr_record(record=self, domain=domain, extra=extra) def delete(self): return self.driver.ex_delete_ptr_record(record=self) def __repr__(self): return "<{}: ip={}, domain={}, provider={} ...>".format( self.__class__.__name__, self.ip, self.domain,, ) class RackspaceDNSDriver(DNSDriver, OpenStackDriverMixin): name = "Rackspace DNS" website = "" type = Provider.RACKSPACE connectionCls = RackspaceDNSConnection def __init__(self, key, secret=None, secure=True, host=None, port=None, region="us", **kwargs): valid_regions = self.list_regions() if region not in valid_regions: raise ValueError("Invalid region: %s" % (region)) OpenStackDriverMixin.__init__(self, **kwargs) super().__init__(key=key, secret=secret, host=host, port=port, region=region) RECORD_TYPE_MAP = { RecordType.A: "A", RecordType.AAAA: "AAAA", RecordType.CNAME: "CNAME", RecordType.MX: "MX", RecordType.NS: "NS", RecordType.PTR: "PTR", RecordType.SRV: "SRV", RecordType.TXT: "TXT", } @classmethod def list_regions(cls): return ["us", "uk"] def iterate_zones(self): offset = 0 limit = 100 while True: params = { "limit": limit, "offset": offset, } response = self.connection.request(action="/domains", params=params).object zones_list = response["domains"] for item in zones_list: yield self._to_zone(item) if _rackspace_result_has_more(response, len(zones_list), limit): offset += limit else: break def iterate_records(self, zone): self.connection.set_context({"resource": "zone", "id":}) offset = 0 limit = 100 while True: params = { "showRecord": True, "limit": limit, "offset": offset, } response = self.connection.request( action="/domains/%s" % (, params=params ).object records_list = response["recordsList"] records = records_list["records"] for item in records: record = self._to_record(data=item, zone=zone) yield record if _rackspace_result_has_more(records_list, len(records), limit): offset += limit else: break def get_zone(self, zone_id): self.connection.set_context({"resource": "zone", "id": zone_id}) response = self.connection.request(action="/domains/%s" % (zone_id)) zone = self._to_zone(data=response.object) return zone def get_record(self, zone_id, record_id): zone = self.get_zone(zone_id=zone_id) self.connection.set_context({"resource": "record", "id": record_id}) response = self.connection.request( action="/domains/{}/records/{}".format(zone_id, record_id) ).object record = self._to_record(data=response, zone=zone) return record def create_zone(self, domain, type="master", ttl=None, extra=None): extra = extra if extra else {} # Email address is required if "email" not in extra: raise ValueError('"email" key must be present in extra dictionary') payload = { "name": domain, "emailAddress": extra["email"], "recordsList": {"records": []}, } if ttl: payload["ttl"] = ttl if "comment" in extra: payload["comment"] = extra["comment"] data = {"domains": [payload]} response = self.connection.async_request(action="/domains", method="POST", data=data) zone = self._to_zone(data=response.object["response"]["domains"][0]) return zone def update_zone(self, zone, domain=None, type=None, ttl=None, extra=None): # Only ttl, comment and email address can be changed extra = extra if extra else {} if domain: raise LibcloudError("Domain cannot be changed", driver=self) data = {} if ttl: data["ttl"] = int(ttl) if "email" in extra: data["emailAddress"] = extra["email"] if "comment" in extra: data["comment"] = extra["comment"] type = type if type else zone.type ttl = ttl if ttl else zone.ttl self.connection.set_context({"resource": "zone", "id":}) self.connection.async_request(action="/domains/%s" % (, method="PUT", data=data) merged = merge_valid_keys( params=copy.deepcopy(zone.extra), valid_keys=VALID_ZONE_EXTRA_PARAMS, extra=extra, ) updated_zone = get_new_obj( obj=zone, klass=Zone, attributes={"type": type, "ttl": ttl, "extra": merged} ) return updated_zone def create_record(self, name, zone, type, data, extra=None): # Name must be a FQDN - e.g. if domain is "" then a record # name is "" extra = extra if extra else {} name = self._to_full_record_name(domain=zone.domain, name=name) data = {"name": name, "type": self.RECORD_TYPE_MAP[type], "data": data} if "ttl" in extra: data["ttl"] = int(extra["ttl"]) if "priority" in extra: data["priority"] = int(extra["priority"]) payload = {"records": [data]} self.connection.set_context({"resource": "zone", "id":}) response = self.connection.async_request( action="/domains/%s/records" % (, data=payload, method="POST" ).object record = self._to_record(data=response["response"]["records"][0], zone=zone) return record def update_record(self, record, name=None, type=None, data=None, extra=None): # Only data, ttl, and comment attributes can be modified, but name # attribute must always be present. extra = extra if extra else {} name = self._to_full_record_name(, payload = {"name": name} if data: payload["data"] = data if "ttl" in extra: payload["ttl"] = extra["ttl"] if "comment" in extra: payload["comment"] = extra["comment"] type = type if type is not None else record.type data = data if data else self.connection.set_context({"resource": "record", "id":}) self.connection.async_request( action="/domains/{}/records/{}".format(,, method="PUT", data=payload, ) merged = merge_valid_keys( params=copy.deepcopy(record.extra), valid_keys=VALID_RECORD_EXTRA_PARAMS, extra=extra, ) updated_record = get_new_obj( obj=record, klass=Record, attributes={"type": type, "data": data, "driver": self, "extra": merged}, ) return updated_record def delete_zone(self, zone): self.connection.set_context({"resource": "zone", "id":}) self.connection.async_request(action="/domains/%s" % (, method="DELETE") return True def delete_record(self, record): self.connection.set_context({"resource": "record", "id":}) self.connection.async_request( action="/domains/{}/records/{}".format(,, method="DELETE", ) return True def ex_iterate_ptr_records(self, device): """ Return a generator to iterate over existing PTR Records. The ``device`` should be an instance of one of these: :class:`libcloud.compute.base.Node` :class:`libcloud.loadbalancer.base.LoadBalancer` And it needs to have the following ``extra`` fields set: service_name - the service catalog name for the device uri - the URI pointing to the GET endpoint for the device Those are automatically set for you if you got the device from the Rackspace driver for that service. For example: server = rs_compute.ex_get_node_details(id) ptr_iter = rs_dns.ex_list_ptr_records(server) loadbalancer = rs_lbs.get_balancer(id) ptr_iter = rs_dns.ex_list_ptr_records(loadbalancer) Note: the Rackspace DNS API docs indicate that the device 'href' is optional, but testing does not bear this out. It throws a 400 Bad Request error if you do not pass in the 'href' from the server or loadbalancer. So ``device`` is required. :param device: the device that owns the IP :rtype: ``generator`` of :class:`RackspacePTRRecord` """ _check_ptr_extra_fields(device) params = {"href": device.extra["uri"]} service_name = device.extra["service_name"] # without a valid context, the 404 on empty list will blow up # in the error-handling code self.connection.set_context({"resource": "ptr_records"}) try: response = self.connection.request( action="/rdns/%s" % (service_name), params=params ).object records = response["records"] link = dict(rel=service_name, **params) for item in records: record = self._to_ptr_record(data=item, link=link) yield record except BaseHTTPError as exc: # 404 just means empty list if exc.code == 404: return raise def ex_get_ptr_record(self, service_name, record_id): """ Get a specific PTR record by id. :param service_name: the service catalog name of the linked device(s) i.e. cloudLoadBalancers or cloudServersOpenStack :param record_id: the id (i.e. PTR-12345) of the PTR record :rtype: instance of :class:`RackspacePTRRecord` """ self.connection.set_context({"resource": "record", "id": record_id}) response = self.connection.request( action="/rdns/{}/{}".format(service_name, record_id) ).object item = next(iter(response["recordsList"]["records"])) return self._to_ptr_record(data=item, link=response["link"]) def ex_create_ptr_record(self, device, ip, domain, extra=None): """ Create a PTR record for a specific IP on a specific device. The ``device`` should be an instance of one of these: :class:`libcloud.compute.base.Node` :class:`libcloud.loadbalancer.base.LoadBalancer` And it needs to have the following ``extra`` fields set: service_name - the service catalog name for the device uri - the URI pointing to the GET endpoint for the device Those are automatically set for you if you got the device from the Rackspace driver for that service. For example: server = rs_compute.ex_get_node_details(id) rs_dns.create_ptr_record(server, ip, domain) loadbalancer = rs_lbs.get_balancer(id) rs_dns.create_ptr_record(loadbalancer, ip, domain) :param device: the device that owns the IP :param ip: the IP for which you want to set reverse DNS :param domain: the fqdn you want that IP to represent :param extra: a ``dict`` with optional extra values: ttl - the time-to-live of the PTR record :rtype: instance of :class:`RackspacePTRRecord` """ _check_ptr_extra_fields(device) if extra is None: extra = {} # the RDNS API reverse the name and data fields for PTRs # the record name *should* be the ip and the data the fqdn data = {"name": domain, "type": RecordType.PTR, "data": ip} if "ttl" in extra: data["ttl"] = extra["ttl"] payload = { "recordsList": {"records": [data]}, "link": { "content": "", "href": device.extra["uri"], "rel": device.extra["service_name"], }, } response = self.connection.async_request(action="/rdns", method="POST", data=payload).object item = next(iter(response["response"]["records"])) return self._to_ptr_record(data=item, link=payload["link"]) def ex_update_ptr_record(self, record, domain=None, extra=None): """ Update a PTR record for a specific IP on a specific device. If you need to change the domain or ttl, use this API to update the record by deleting the old one and creating a new one. :param record: the original :class:`RackspacePTRRecord` :param domain: the fqdn you want that IP to represent :param extra: a ``dict`` with optional extra values: ttl - the time-to-live of the PTR record :rtype: instance of :class:`RackspacePTRRecord` """ if domain is not None and domain == record.domain: domain = None if extra is not None: extra = dict(extra) for key in extra: if key in record.extra and record.extra[key] == extra[key]: del extra[key] if domain is None and not extra: # nothing to do, it already matches return record _check_ptr_extra_fields(record) ip = record.ip self.ex_delete_ptr_record(record) # records have the same metadata in 'extra' as the original device # so you can pass the original record object in instead return self.ex_create_ptr_record(record, ip, domain, extra=extra) def ex_delete_ptr_record(self, record): """ Delete an existing PTR Record :param record: the original :class:`RackspacePTRRecord` :rtype: ``bool`` """ _check_ptr_extra_fields(record) self.connection.set_context({"resource": "record", "id":}) self.connection.async_request( action="/rdns/%s" % (record.extra["service_name"]), method="DELETE", params={"href": record.extra["uri"], "ip": record.ip}, ) return True def _to_zone(self, data): id = data["id"] domain = data["name"] type = "master" ttl = data.get("ttl", 0) extra = {} if "emailAddress" in data: extra["email"] = data["emailAddress"] if "comment" in data: extra["comment"] = data["comment"] zone = Zone(id=str(id), domain=domain, type=type, ttl=int(ttl), driver=self, extra=extra) return zone def _to_record(self, data, zone): id = data["id"] fqdn = data["name"] name = self._to_partial_record_name(domain=zone.domain, name=fqdn) type = self._string_to_record_type(data["type"]) record_data = data["data"] extra = {"fqdn": fqdn} for key in VALID_RECORD_EXTRA_PARAMS: if key in data: extra[key] = data[key] record = Record( id=str(id), name=name, type=type, data=record_data, zone=zone, driver=self, ttl=extra.get("ttl", None), extra=extra, ) return record def _to_ptr_record(self, data, link): id = data["id"] ip = data["data"] domain = data["name"] extra = {"uri": link["href"], "service_name": link["rel"]} for key in VALID_RECORD_EXTRA_PARAMS: if key in data: extra[key] = data[key] record = RackspacePTRRecord(id=str(id), ip=ip, domain=domain, driver=self, extra=extra) return record def _to_full_record_name(self, domain, name): """ Build a FQDN from a domain and record name. :param domain: Domain name. :type domain: ``str`` :param name: Record name. :type name: ``str`` """ if name: name = "{}.{}".format(name, domain) else: name = domain return name def _to_partial_record_name(self, domain, name): """ Remove domain portion from the record name. :param domain: Domain name. :type domain: ``str`` :param name: Full record name (fqdn). :type name: ``str`` """ if name == domain: # Map "root" record names to None to be consistent with other # drivers return None # Strip domain portion name = name.replace(".%s" % (domain), "") return name def _ex_connection_class_kwargs(self): kwargs = self.openstack_connection_kwargs() kwargs["region"] = self.region return kwargs def _rackspace_result_has_more(response, result_length, limit): # If rackspace returns less than the limit, then we've reached the end of # the result set. if result_length < limit: return False # Paginated results return links to the previous and next sets of data, but # 'next' only exists when there is more to get. for item in response.get("links", ()): if item["rel"] == "next": return True return False def _check_ptr_extra_fields(device_or_record): if not ( hasattr(device_or_record, "extra") and isinstance(device_or_record.extra, dict) and device_or_record.extra.get("uri") is not None and device_or_record.extra.get("service_name") is not None ): raise LibcloudError( "Can't create PTR Record for %s because it " "doesn't have a 'uri' and 'service_name' in " "'extra'" % device_or_record )