File: //opt/saltstack/salt/lib/python3.10/site-packages/libcloud/dns/drivers/rackspace.py
# 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.
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"]
class RackspaceDNSResponse(OpenStack_1_1_Response):
"""
Rackspace DNS Response class.
"""
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))
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)
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
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"
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):
self.id = 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,
self.driver.name,
)
class RackspaceDNSDriver(DNSDriver, OpenStackDriverMixin):
name = "Rackspace DNS"
website = "http://www.rackspace.com/"
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": zone.id})
offset = 0
limit = 100
while True:
params = {
"showRecord": True,
"limit": limit,
"offset": offset,
}
response = self.connection.request(
action="/domains/%s" % (zone.id), 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": zone.id})
self.connection.async_request(action="/domains/%s" % (zone.id), 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 "foo.com" then a record
# name is "bar.foo.com"
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": zone.id})
response = self.connection.async_request(
action="/domains/%s/records" % (zone.id), 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(domain=record.zone.domain, name=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 record.data
self.connection.set_context({"resource": "record", "id": record.id})
self.connection.async_request(
action="/domains/{}/records/{}".format(record.zone.id, record.id),
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": zone.id})
self.connection.async_request(action="/domains/%s" % (zone.id), method="DELETE")
return True
def delete_record(self, record):
self.connection.set_context({"resource": "record", "id": record.id})
self.connection.async_request(
action="/domains/{}/records/{}".format(record.zone.id, record.id),
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": 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
)