774 lines
28 KiB
Python
774 lines
28 KiB
Python
# 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)
|