| # 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. |
| """ |
| Point DNS Driver |
| """ |
| |
| __all__ = ["PointDNSException", "Redirect", "MailRedirect", "PointDNSDriver"] |
| |
| try: |
| import simplejson as json |
| except ImportError: |
| import json |
| |
| from libcloud.utils.py3 import httplib |
| from libcloud.common.types import ProviderError |
| from libcloud.common.types import MalformedResponseError |
| from libcloud.common.pointdns import PointDNSConnection |
| from libcloud.common.exceptions import BaseHTTPError |
| from libcloud.dns.types import Provider, RecordType |
| from libcloud.dns.types import ZoneDoesNotExistError |
| from libcloud.dns.types import RecordDoesNotExistError |
| from libcloud.dns.base import DNSDriver, Zone, Record |
| |
| |
| class PointDNSException(ProviderError): |
| def __init__(self, value, http_code, driver=None): |
| super(PointDNSException, self).__init__( |
| value=value, http_code=http_code, driver=driver |
| ) |
| self.args = (http_code, value) |
| |
| |
| class Redirect(object): |
| """ |
| Point DNS redirect. |
| """ |
| |
| def __init__(self, id, name, data, type, driver, zone, iframe=None, query=False): |
| """ |
| :param id: Redirect id. |
| :type id: ``str`` |
| |
| :param name: The FQDN for the record. |
| :type name: ``str`` |
| |
| :param data: The data field. (redirect_to) |
| :type data: ``str`` |
| |
| :param type: The type of redirects 301, 302 or 0 for iframes. |
| :type type: ``str`` |
| |
| :param driver: DNSDriver instance. |
| :type driver: :class:`DNSDriver` |
| |
| :param zone: Zone where redirect belongs. |
| :type zone: :class:`Zone` |
| |
| :param iframe: Title of iframe (optional). |
| :type iframe: ``str`` |
| |
| :param query: boolean Information about including query string when |
| redirecting. (optional). |
| :type query: ``bool`` |
| """ |
| self.id = str(id) if id else None |
| self.name = name |
| self.data = data |
| self.type = str(type) if type else None |
| self.driver = driver |
| self.zone = zone |
| self.iframe = iframe |
| self.query = query |
| |
| def update(self, data, name=None, type=None, iframe=None, query=None): |
| return self.driver.ex_update_redirect( |
| redirect=self, name=name, data=data, type=type, iframe=iframe, query=query |
| ) |
| |
| def delete(self): |
| return self.driver.ex_delete_redirect(redirect=self) |
| |
| def __repr__(self): |
| return "<PointDNSRedirect: name=%s, data=%s, type=%s ...>" % ( |
| self.name, |
| self.data, |
| self.type, |
| ) |
| |
| |
| class MailRedirect(object): |
| """ |
| Point DNS mail redirect. |
| """ |
| |
| def __init__(self, id, source, destination, zone, driver): |
| """ |
| :param id: MailRedirect id. |
| :type id: ``str`` |
| |
| :param source: The source address of mail redirect. |
| :type source: ``str`` |
| |
| :param destination: The destination address of mail redirect. |
| :type destination: ``str`` |
| |
| :param zone: Zone where mail redirect belongs. |
| :type zone: :class:`Zone` |
| |
| :param driver: DNSDriver instance. |
| :type driver: :class:`DNSDriver` |
| """ |
| self.id = str(id) if id else None |
| self.source = source |
| self.destination = destination |
| self.zone = zone |
| self.driver = driver |
| |
| def update(self, destination, source=None): |
| return self.driver.ex_update_mail_redirect( |
| mail_r=self, destination=destination, source=None |
| ) |
| |
| def delete(self): |
| return self.driver.ex_delete_mail_redirect(mail_r=self) |
| |
| def __repr__(self): |
| return "<PointDNSMailRedirect: source=%s, destination=%s,zone=%s ...>" % ( |
| self.source, |
| self.destination, |
| self.zone.id, |
| ) |
| |
| |
| class PointDNSDriver(DNSDriver): |
| type = Provider.POINTDNS |
| name = "Point DNS" |
| website = "https://pointhq.com/" |
| connectionCls = PointDNSConnection |
| |
| RECORD_TYPE_MAP = { |
| RecordType.A: "A", |
| RecordType.AAAA: "AAAA", |
| RecordType.ALIAS: "ALIAS", |
| RecordType.CNAME: "CNAME", |
| RecordType.MX: "MX", |
| RecordType.NS: "NS", |
| RecordType.PTR: "PTR", |
| RecordType.SRV: "SRV", |
| RecordType.SSHFP: "SSHFP", |
| RecordType.TXT: "TXT", |
| } |
| |
| def list_zones(self): |
| """ |
| Return a list of zones. |
| |
| :return: ``list`` of :class:`Zone` |
| """ |
| response = self.connection.request("/zones") |
| zones = self._to_zones(response.object) |
| return zones |
| |
| def list_records(self, zone): |
| """ |
| Return a list of records for the provided zone. |
| |
| :param zone: Zone to list records for. |
| :type zone: :class:`Zone` |
| |
| :return: ``list`` of :class:`Record` |
| """ |
| response = self.connection.request("/zones/%s/records" % zone.id) |
| records = self._to_records(response.object, zone) |
| return records |
| |
| def get_zone(self, zone_id): |
| """ |
| Return a Zone instance. |
| |
| :param zone_id: ID of the required zone |
| :type zone_id: ``str`` |
| |
| :rtype: :class:`Zone` |
| """ |
| try: |
| response = self.connection.request("/zones/%s" % zone_id) |
| except MalformedResponseError as e: |
| if e.body == "Not found": |
| raise ZoneDoesNotExistError( |
| driver=self, value="The zone doesn't exists", zone_id=zone_id |
| ) |
| raise e |
| |
| zone = self._to_zone(response.object) |
| return zone |
| |
| def get_record(self, zone_id, record_id): |
| """ |
| Return a Record instance. |
| |
| :param zone_id: ID of the required zone |
| :type zone_id: ``str`` |
| |
| :param record_id: ID of the required record |
| :type record_id: ``str`` |
| |
| :rtype: :class:`Record` |
| """ |
| try: |
| response = self.connection.request( |
| "/zones/%s/records/%s" % (zone_id, record_id) |
| ) |
| except MalformedResponseError as e: |
| if e.body == "Not found": |
| raise RecordDoesNotExistError( |
| value="Record doesn't exists", driver=self, record_id=record_id |
| ) |
| raise e |
| |
| record = self._to_record(response.object, zone_id=zone_id) |
| return record |
| |
| def create_zone(self, domain, type="master", ttl=None, extra=None): |
| """ |
| Create a new zone. |
| |
| :param domain: Zone domain name (e.g. example.com) |
| :type domain: ``str`` |
| |
| :param type: Zone type (All zones are master by design). |
| :type type: ``str`` |
| |
| :param ttl: TTL for new records. (optional) |
| :type ttl: ``int`` |
| |
| :param extra: Extra attributes (driver specific). (optional) |
| :type extra: ``dict`` |
| |
| :rtype: :class:`Zone` |
| """ |
| r_json = {"name": domain} |
| if ttl is not None: |
| r_json["ttl"] = ttl |
| if extra is not None: |
| r_json.update(extra) |
| r_data = json.dumps({"zone": r_json}) |
| try: |
| response = self.connection.request("/zones", method="POST", data=r_data) |
| except BaseHTTPError as e: |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| zone = self._to_zone(response.object) |
| return zone |
| |
| def create_record(self, name, zone, type, data, extra=None): |
| """ |
| Create a new record. |
| |
| :param name: Record name without the domain name (e.g. www). |
| Note: If you want to create a record for a base domain |
| name, you should specify empty string ('') for this |
| argument. |
| :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). (optional) |
| :type extra: ``dict`` |
| |
| :rtype: :class:`Record` |
| """ |
| r_json = {"name": name, "data": data, "record_type": type} |
| if extra is not None: |
| r_json.update(extra) |
| r_data = json.dumps({"zone_record": r_json}) |
| try: |
| response = self.connection.request( |
| "/zones/%s/records" % zone.id, method="POST", data=r_data |
| ) |
| except BaseHTTPError as e: |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| record = self._to_record(response.object, zone=zone) |
| return record |
| |
| def update_zone(self, zone, domain, type="master", ttl=None, extra=None): |
| """ |
| Update an existing zone. |
| |
| :param zone: Zone to update. |
| :type zone: :class:`Zone` |
| |
| :param domain: Zone domain name (e.g. example.com) |
| :type domain: ``str`` |
| |
| :param type: Zone type (All zones are master by design). |
| :type type: ``str`` |
| |
| :param ttl: TTL for new records. (optional) |
| :type ttl: ``int`` |
| |
| :param extra: Extra attributes (group, user-id). (optional) |
| :type extra: ``dict`` |
| |
| :rtype: :class:`Zone` |
| """ |
| r_json = {"name": domain} |
| if extra is not None: |
| r_json.update(extra) |
| r_data = json.dumps({"zone": r_json}) |
| try: |
| response = self.connection.request( |
| "/zones/%s" % zone.id, method="PUT", data=r_data |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| if isinstance(e, MalformedResponseError) and e.body == "Not found": |
| raise ZoneDoesNotExistError( |
| value="Zone doesn't exists", driver=self, zone_id=zone.id |
| ) |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| zone = self._to_zone(response.object) |
| return zone |
| |
| 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: Record name without the domain name (e.g. www). |
| Note: If you want to create a record for a base domain |
| name, you should specify empty string ('') for this |
| argument. |
| :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` |
| """ |
| zone = record.zone |
| r_json = {"name": name, "data": data, "record_type": type} |
| if extra is not None: |
| r_json.update(extra) |
| r_data = json.dumps({"zone_record": r_json}) |
| try: |
| response = self.connection.request( |
| "/zones/%s/records/%s" % (zone.id, record.id), method="PUT", data=r_data |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| if isinstance(e, MalformedResponseError) and e.body == "Not found": |
| raise RecordDoesNotExistError( |
| value="Record doesn't exists", driver=self, record_id=record.id |
| ) |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| record = self._to_record(response.object, zone=zone) |
| return record |
| |
| def delete_zone(self, zone): |
| """ |
| Delete a zone. |
| |
| Note: This will delete all the records belonging to this zone. |
| |
| :param zone: Zone to delete. |
| :type zone: :class:`Zone` |
| |
| :rtype: ``bool`` |
| """ |
| try: |
| self.connection.request("/zones/%s" % zone.id, method="DELETE") |
| except MalformedResponseError as e: |
| if e.body == "Not found": |
| raise ZoneDoesNotExistError( |
| driver=self, value="The zone doesn't exists", zone_id=zone.id |
| ) |
| raise e |
| return True |
| |
| def delete_record(self, record): |
| """ |
| Delete a record. |
| |
| :param record: Record to delete. |
| :type record: :class:`Record` |
| |
| :rtype: ``bool`` |
| """ |
| zone_id = record.zone.id |
| record_id = record.id |
| try: |
| self.connection.request( |
| "/zones/%s/records/%s" % (zone_id, record_id), method="DELETE" |
| ) |
| except MalformedResponseError as e: |
| if e.body == "Not found": |
| raise RecordDoesNotExistError( |
| value="Record doesn't exists", driver=self, record_id=record_id |
| ) |
| raise e |
| return True |
| |
| def ex_list_redirects(self, zone): |
| """ |
| :param zone: Zone to list redirects for. |
| :type zone: :class:`Zone` |
| |
| :rtype: ``list`` of :class:`Record` |
| """ |
| response = self.connection.request("/zones/%s/redirects" % zone.id) |
| redirects = self._to_redirects(response.object, zone) |
| return redirects |
| |
| def ex_list_mail_redirects(self, zone): |
| """ |
| :param zone: Zone to list redirects for. |
| :type zone: :class:`Zone` |
| |
| :rtype: ``list`` of :class:`MailRedirect` |
| """ |
| response = self.connection.request("/zones/%s/mail_redirects" % zone.id) |
| mail_redirects = self._to_mail_redirects(response.object, zone) |
| return mail_redirects |
| |
| def ex_create_redirect( |
| self, redirect_to, name, type, zone, iframe=None, query=None |
| ): |
| """ |
| :param redirect_to: The data field. (redirect_to) |
| :type redirect_to: ``str`` |
| |
| :param name: The FQDN for the record. |
| :type name: ``str`` |
| |
| :param type: The type of redirects 301, 302 or 0 for iframes. |
| :type type: ``str`` |
| |
| :param zone: Zone to list redirects for. |
| :type zone: :class:`Zone` |
| |
| :param iframe: Title of iframe (optional). |
| :type iframe: ``str`` |
| |
| :param query: boolean Information about including query string when |
| redirecting. (optional). |
| :type query: ``bool`` |
| |
| :rtype: :class:`Record` |
| """ |
| r_json = {"name": name, "redirect_to": redirect_to} |
| if type is not None: |
| r_json["redirect_type"] = type |
| if iframe is not None: |
| r_json["iframe_title"] = iframe |
| if query is not None: |
| r_json["redirect_query_string"] = query |
| r_data = json.dumps({"zone_redirect": r_json}) |
| try: |
| response = self.connection.request( |
| "/zones/%s/redirects" % zone.id, method="POST", data=r_data |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| redirect = self._to_redirect(response.object, zone=zone) |
| return redirect |
| |
| def ex_create_mail_redirect(self, destination, source, zone): |
| """ |
| :param destination: The destination address of mail redirect. |
| :type destination: ``str`` |
| |
| :param source: The source address of mail redirect. |
| :type source: ``str`` |
| |
| :param zone: Zone to list redirects for. |
| :type zone: :class:`Zone` |
| |
| :rtype: ``list`` of :class:`MailRedirect` |
| """ |
| r_json = {"destination_address": destination, "source_address": source} |
| r_data = json.dumps({"zone_mail_redirect": r_json}) |
| try: |
| response = self.connection.request( |
| "/zones/%s/mail_redirects" % zone.id, method="POST", data=r_data |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| mail_redirect = self._to_mail_redirect(response.object, zone=zone) |
| return mail_redirect |
| |
| def ex_get_redirect(self, zone_id, redirect_id): |
| """ |
| :param zone: Zone to list redirects for. |
| :type zone: :class:`Zone` |
| |
| :param redirect_id: Redirect id. |
| :type redirect_id: ``str`` |
| |
| :rtype: ``list`` of :class:`Redirect` |
| """ |
| try: |
| response = self.connection.request( |
| "/zones/%s/redirects/%s" % (zone_id, redirect_id) |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| if isinstance(e, MalformedResponseError) and e.body == "Not found": |
| raise PointDNSException( |
| value="Couldn't found redirect", |
| http_code=httplib.NOT_FOUND, |
| driver=self, |
| ) |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| redirect = self._to_redirect(response.object, zone_id=zone_id) |
| return redirect |
| |
| def ex_get_mail_redirects(self, zone_id, mail_r_id): |
| """ |
| :param zone: Zone to list redirects for. |
| :type zone: :class:`Zone` |
| |
| :param mail_r_id: Mail redirect id. |
| :type mail_r_id: ``str`` |
| |
| :rtype: ``list`` of :class:`MailRedirect` |
| """ |
| try: |
| response = self.connection.request( |
| "/zones/%s/mail_redirects/%s" % (zone_id, mail_r_id) |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| if isinstance(e, MalformedResponseError) and e.body == "Not found": |
| raise PointDNSException( |
| value="Couldn't found mail redirect", |
| http_code=httplib.NOT_FOUND, |
| driver=self, |
| ) |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| mail_redirect = self._to_mail_redirect(response.object, zone_id=zone_id) |
| return mail_redirect |
| |
| def ex_update_redirect( |
| self, redirect, redirect_to=None, name=None, type=None, iframe=None, query=None |
| ): |
| """ |
| :param redirect: Record to update |
| :type id: :class:`Redirect` |
| |
| :param redirect_to: The data field. (optional). |
| :type redirect_to: ``str`` |
| |
| :param name: The FQDN for the record. |
| :type name: ``str`` |
| |
| :param type: The type of redirects 301, 302 or 0 for iframes. |
| (optional). |
| :type type: ``str`` |
| |
| :param iframe: Title of iframe (optional). |
| :type iframe: ``str`` |
| |
| :param query: boolean Information about including query string when |
| redirecting. (optional). |
| :type query: ``bool`` |
| |
| :rtype: ``list`` of :class:`Redirect` |
| """ |
| zone_id = redirect.zone.id |
| r_json = {} |
| if redirect_to is not None: |
| r_json["redirect_to"] = redirect_to |
| if name is not None: |
| r_json["name"] = name |
| if type is not None: |
| r_json["record_type"] = type |
| if iframe is not None: |
| r_json["iframe_title"] = iframe |
| if query is not None: |
| r_json["redirect_query_string"] = query |
| r_data = json.dumps({"zone_redirect": r_json}) |
| try: |
| response = self.connection.request( |
| "/zones/%s/redirects/%s" % (zone_id, redirect.id), |
| method="PUT", |
| data=r_data, |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| if isinstance(e, MalformedResponseError) and e.body == "Not found": |
| raise PointDNSException( |
| value="Couldn't found redirect", |
| http_code=httplib.NOT_FOUND, |
| driver=self, |
| ) |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| redirect = self._to_redirect(response.object, zone=redirect.zone) |
| return redirect |
| |
| def ex_update_mail_redirect(self, mail_r, destination, source=None): |
| """ |
| :param mail_r: Mail redirect to update |
| :type mail_r: :class:`MailRedirect` |
| |
| :param destination: The destination address of mail redirect. |
| :type destination: ``str`` |
| |
| :param source: The source address of mail redirect. (optional) |
| :type source: ``str`` |
| |
| :rtype: ``list`` of :class:`MailRedirect` |
| """ |
| zone_id = mail_r.zone.id |
| r_json = {"destination_address": destination} |
| if source is not None: |
| r_json["source_address"] = source |
| r_data = json.dumps({"zone_redirect": r_json}) |
| try: |
| response = self.connection.request( |
| "/zones/%s/mail_redirects/%s" % (zone_id, mail_r.id), |
| method="PUT", |
| data=r_data, |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| if isinstance(e, MalformedResponseError) and e.body == "Not found": |
| raise PointDNSException( |
| value="Couldn't found mail redirect", |
| http_code=httplib.NOT_FOUND, |
| driver=self, |
| ) |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| mail_redirect = self._to_mail_redirect(response.object, zone=mail_r.zone) |
| return mail_redirect |
| |
| def ex_delete_redirect(self, redirect): |
| """ |
| :param mail_r: Redirect to delete |
| :type mail_r: :class:`Redirect` |
| |
| :rtype: ``bool`` |
| """ |
| zone_id = redirect.zone.id |
| redirect_id = redirect.id |
| try: |
| self.connection.request( |
| "/zones/%s/redirects/%s" % (zone_id, redirect_id), method="DELETE" |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| if isinstance(e, MalformedResponseError) and e.body == "Not found": |
| raise PointDNSException( |
| value="Couldn't found redirect", |
| http_code=httplib.NOT_FOUND, |
| driver=self, |
| ) |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| return True |
| |
| def ex_delete_mail_redirect(self, mail_r): |
| """ |
| :param mail_r: Mail redirect to update |
| :type mail_r: :class:`MailRedirect` |
| |
| :rtype: ``bool`` |
| """ |
| zone_id = mail_r.zone.id |
| mail_r_id = mail_r.id |
| try: |
| self.connection.request( |
| "/zones/%s/mail_redirects/%s" % (zone_id, mail_r_id), method="DELETE" |
| ) |
| except (BaseHTTPError, MalformedResponseError) as e: |
| if isinstance(e, MalformedResponseError) and e.body == "Not found": |
| raise PointDNSException( |
| value="Couldn't found mail redirect", |
| http_code=httplib.NOT_FOUND, |
| driver=self, |
| ) |
| raise PointDNSException(value=e.message, http_code=e.code, driver=self) |
| return True |
| |
| def _to_zones(self, data): |
| zones = [] |
| for zone in data: |
| _zone = self._to_zone(zone) |
| zones.append(_zone) |
| |
| return zones |
| |
| def _to_zone(self, data): |
| zone = data.get("zone") |
| id = zone.get("id") |
| name = zone.get("name") |
| ttl = zone.get("ttl") |
| extra = {"group": zone.get("group"), "user-id": zone.get("user-id")} |
| |
| # All zones are a primary ones by design, so they |
| # assume that are the master source of info about the |
| # zone, which is the case when domain DNS records |
| # points to PointDNS nameservers. |
| type = "master" |
| |
| return Zone(id=id, domain=name, type=type, ttl=ttl, driver=self, extra=extra) |
| |
| def _to_records(self, data, zone): |
| records = [] |
| for item in data: |
| record = self._to_record(item, zone=zone) |
| records.append(record) |
| return records |
| |
| def _to_record(self, data, zone_id=None, zone=None): |
| if not zone: # We need zone_id or zone |
| zone = self.get_zone(zone_id) |
| record = data.get("zone_record") |
| id = record.get("id") |
| name = record.get("name") |
| type = record.get("record_type") |
| data = record.get("data") |
| extra = { |
| "ttl": record.get("ttl"), |
| "zone_id": record.get("zone_id"), |
| "aux": record.get("aux"), |
| } |
| return Record( |
| id=id, |
| name=name, |
| type=type, |
| data=data, |
| zone=zone, |
| driver=self, |
| ttl=record.get("ttl", None), |
| extra=extra, |
| ) |
| |
| def _to_redirects(self, data, zone): |
| redirects = [] |
| for item in data: |
| redirect = self._to_redirect(item, zone=zone) |
| redirects.append(redirect) |
| return redirects |
| |
| def _to_redirect(self, data, zone_id=None, zone=None): |
| if not zone: # We need zone_id or zone |
| zone = self.get_zone(zone_id) |
| record = data.get("zone_redirect") |
| id = record.get("id") |
| name = record.get("name") |
| redirect_to = record.get("redirect_to") |
| type = record.get("redirect_type") |
| iframe = record.get("iframe_title") |
| query = record.get("redirect_query_string") |
| return Redirect( |
| id, name, redirect_to, type, self, zone, iframe=iframe, query=query |
| ) |
| |
| def _to_mail_redirects(self, data, zone): |
| mail_redirects = [] |
| for item in data: |
| mail_redirect = self._to_mail_redirect(item, zone=zone) |
| mail_redirects.append(mail_redirect) |
| return mail_redirects |
| |
| def _to_mail_redirect(self, data, zone_id=None, zone=None): |
| if not zone: # We need zone_id or zone |
| zone = self.get_zone(zone_id) |
| record = data.get("zone_mail_redirect") |
| id = record.get("id") |
| destination = record.get("destination_address") |
| source = record.get("source_address") |
| return MailRedirect(id, source, destination, zone, self) |