­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ # 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. from libcloud.dns.base import Zone, Record, DNSDriver from libcloud.dns.types import ( Provider, RecordType, RecordError, ZoneDoesNotExistError, RecordDoesNotExistError, ) from libcloud.common.gandi import GandiResponse, BaseGandiDriver, GandiConnection __all__ = ["GandiDNSDriver"] TTL_MIN = 30 TTL_MAX = 2592000 # 30 days class NewZoneVersion: """ Changes to a zone in the Gandi DNS service need to be wrapped in a new version object. The changes are made to the new version, then that version is made active. In effect, this is a transaction. Any calls made inside this context manager will be applied to a new version id. If your changes are successful (and only if they are successful) they are activated. """ def __init__(self, driver, zone): self.driver = driver self.connection = driver.connection self.zone = zone def __enter__(self): zid = int(self.zone.id) self.connection.set_context({"zone_id": self.zone.id}) vid = self.connection.request("domain.zone.version.new", zid).object self.vid = vid return vid def __exit__(self, type, value, traceback): if not traceback: zid = int(self.zone.id) con = self.connection con.set_context({"zone_id": self.zone.id}) con.request("domain.zone.version.set", zid, self.vid).object class GandiDNSResponse(GandiResponse): exceptions = { 581042: ZoneDoesNotExistError, } class GandiDNSConnection(GandiConnection): responseCls = GandiDNSResponse class GandiDNSDriver(BaseGandiDriver, DNSDriver): """ API reference can be found at: http://doc.rpc.gandi.net/domain/reference.html """ type = Provider.GANDI name = "Gandi DNS" website = "http://www.gandi.net/domain" connectionCls = GandiDNSConnection RECORD_TYPE_MAP = { RecordType.A: "A", RecordType.AAAA: "AAAA", RecordType.CNAME: "CNAME", RecordType.LOC: "LOC", RecordType.MX: "MX", RecordType.NS: "NS", RecordType.SPF: "SPF", RecordType.SRV: "SRV", RecordType.TXT: "TXT", RecordType.WKS: "WKS", } def _to_zone(self, zone): return Zone( id=str(zone["id"]), domain=zone["name"], type="master", ttl=0, driver=self, extra={}, ) def _to_zones(self, zones): ret = [] for z in zones: ret.append(self._to_zone(z)) return ret def list_zones(self): zones = self.connection.request("domain.zone.list") return self._to_zones(zones.object) def get_zone(self, zone_id): zid = int(zone_id) self.connection.set_context({"zone_id": zone_id}) zone = self.connection.request("domain.zone.info", zid) return self._to_zone(zone.object) def create_zone(self, domain, type="master", ttl=None, extra=None): params = { "name": domain, } info = self.connection.request("domain.zone.create", params) return self._to_zone(info.object) def update_zone(self, zone, domain=None, type=None, ttl=None, extra=None): zid = int(zone.id) params = {"name": domain} self.connection.set_context({"zone_id": zone.id}) zone = self.connection.request("domain.zone.update", zid, params) return self._to_zone(zone.object) def delete_zone(self, zone): zid = int(zone.id) self.connection.set_context({"zone_id": zone.id}) res = self.connection.request("domain.zone.delete", zid) return res.object def _to_record(self, record, zone): extra = {"ttl": int(record["ttl"])} value = record["value"] if record["type"] == "MX": # Record is in the following form: # # e.g. 15 aspmx.l.google.com split = record["value"].split(" ") extra["priority"] = int(split[0]) value = split[1] return Record( id="{}:{}".format(record["type"], record["name"]), name=record["name"], type=self._string_to_record_type(record["type"]), data=value, zone=zone, driver=self, ttl=record["ttl"], extra=extra, ) def _to_records(self, records, zone): retval = [] for r in records: retval.append(self._to_record(r, zone)) return retval def list_records(self, zone): zid = int(zone.id) self.connection.set_context({"zone_id": zone.id}) records = self.connection.request("domain.zone.record.list", zid, 0) return self._to_records(records.object, zone) def get_record(self, zone_id, record_id): zid = int(zone_id) record_type, name = record_id.split(":", 1) filter_opts = {"name": name, "type": record_type} self.connection.set_context({"zone_id": zone_id}) records = self.connection.request("domain.zone.record.list", zid, 0, filter_opts).object if len(records) == 0: raise RecordDoesNotExistError(value="", driver=self, record_id=record_id) return self._to_record(records[0], self.get_zone(zone_id)) def _validate_record(self, record_id, name, record_type, data, extra): if len(data) > 1024: raise RecordError( "Record data must be <= 1024 characters", driver=self, record_id=record_id, ) if extra and "ttl" in extra: if extra["ttl"] < TTL_MIN: raise RecordError( "TTL must be at least 30 seconds", driver=self, record_id=record_id ) if extra["ttl"] > TTL_MAX: raise RecordError("TTL must not excdeed 30 days", driver=self, record_id=record_id) def create_record(self, name, zone, type, data, extra=None): self._validate_record(None, name, type, data, extra) zid = int(zone.id) create = {"name": name, "type": self.RECORD_TYPE_MAP[type], "value": data} if "ttl" in extra: create["ttl"] = extra["ttl"] with NewZoneVersion(self, zone) as vid: con = self.connection con.set_context({"zone_id": zone.id}) rec = con.request("domain.zone.record.add", zid, vid, create).object return self._to_record(rec, zone) def update_record(self, record, name, type, data, extra): self._validate_record(record.id, name, type, data, extra) filter_opts = {"name": record.name, "type": self.RECORD_TYPE_MAP[record.type]} update = {"name": name, "type": self.RECORD_TYPE_MAP[type], "value": data} if "ttl" in extra: update["ttl"] = extra["ttl"] zid = int(record.zone.id) with NewZoneVersion(self, record.zone) as vid: con = self.connection con.set_context({"zone_id": record.zone.id}) con.request("domain.zone.record.delete", zid, vid, filter_opts) res = con.request("domain.zone.record.add", zid, vid, update).object return self._to_record(res, record.zone) def delete_record(self, record): zid = int(record.zone.id) filter_opts = {"name": record.name, "type": self.RECORD_TYPE_MAP[record.type]} with NewZoneVersion(self, record.zone) as vid: con = self.connection con.set_context({"zone_id": record.zone.id}) count = con.request("domain.zone.record.delete", zid, vid, filter_opts).object if count == 1: return True raise RecordDoesNotExistError(value="No such record", driver=self, record_id=record.id)