def delete_record(self, record):
"""
Delete a record.
:param record: Record to delete.
:type record: :class:`Record`
:rtype: ``bool``
"""
action = '/Record.Remove'
data = {'domain_id': record.zone.id, 'record_id': record.id}
try:
self._make_request(action=action, method='POST', data=data)
except DNSPodException:
e = sys.exc_info()[1]
if e.message in RECORD_DOES_NOT_EXIST_ERRORS_MSGS:
raise RecordDoesNotExistError(record_id=record.id,
driver=self,
value='')
elif e.message in ZONE_DOES_NOT_EXIST_ERROR_MSGS:
raise ZoneDoesNotExistError(zone_id=record.zone.id,
driver=self,
value='')
else:
raise e
return True
def get_record(self, zone_id, record_id):
zone = self.get_zone(zone_id=zone_id)
record_type, name = record_id.split(':', 1)
if name:
full_name = ".".join((name, zone.domain))
else:
full_name = zone.domain
self.connection.set_context({'zone_id': zone_id})
params = urlencode({
'name': full_name,
'type': record_type,
'maxitems': '1'
})
uri = API_ROOT + 'hostedzone/' + zone_id + '/rrset?' + params
data = self.connection.request(uri).object
record = self._to_records(data=data, zone=zone)[0]
# A cute aspect of the /rrset filters is that they are more pagination
# hints than filters!!
# So will return a result even if its not what you asked for.
record_type_num = self._string_to_record_type(record_type)
if record.name != name or record.type != record_type_num:
raise RecordDoesNotExistError(value='',
driver=self,
record_id=record_id)
return record
def parse_error(self):
status = int(self.status)
if status == 401:
if not self.body:
raise InvalidCredsError(str(self.status) + ': ' + self.error)
else:
raise InvalidCredsError(self.body)
elif status == 404:
context = self.connection.context
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'])
elif status != 503:
try:
body = ET.XML(self.body)
except:
raise MalformedResponseError('Failed to parse XML',
body=self.body)
errors = []
for error in findall(element=body, xpath='error'):
errors.append(error.text)
raise ZerigoError(code=status, errors=errors)
return self.body
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 status == httplib.CONFLICT:
if context['resource'] == 'zone':
raise ZoneAlreadyExistsError(value=context['value'],
driver=self,
zone_id=None)
elif context['resource'] == 'record':
raise RecordAlreadyExistsError(value=context['value'],
driver=self,
record_id=None)
if body:
if 'code' and 'message' in body:
err = '%s - %s (%s)' % (body['code'], body['message'],
body['errors'][0]['message'])
return err
raise LibcloudError('Unexpected status code: %s' % (status))
def delete_record(self, record):
"""
Delete a record.
:param record: Record to delete.
:type record: :class:`Record`
:rtype: ``bool``
"""
action = "/Record.Remove"
data = {"domain_id": record.zone.id, "record_id": record.id}
try:
self._make_request(action=action, method="POST", data=data)
except DNSPodException as e:
if e.message in RECORD_DOES_NOT_EXIST_ERRORS_MSGS:
raise RecordDoesNotExistError(record_id=record.id,
driver=self,
value="")
elif e.message in ZONE_DOES_NOT_EXIST_ERROR_MSGS:
raise ZoneDoesNotExistError(zone_id=record.zone.id,
driver=self,
value="")
else:
raise e
return True
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`
"""
zone = self.get_zone(zone_id=zone_id)
action = '/v1/zones/%s/records/%s' % (zone_id, record_id)
try:
response = self.connection.request(action=action)
except LuadnsException:
e = sys.exc_info()[1]
if e.message == 'Record not found.':
raise RecordDoesNotExistError(record_id=record_id,
driver=self,
value='')
else:
raise e
record = self._to_record(response.parse_body(), zone=zone)
return record
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 number of the required record.
:type record_id: ``str``
:rtype: :class:`Record`
"""
zone = self.get_zone(zone_id)
try:
if int(record_id) not in range(1, MAX_RECORD_ENTRIES + 1):
raise RecordDoesNotExistError(value="Record doesn't exists",
driver=zone.driver,
record_id=record_id)
except ValueError:
raise WorldWideDNSError(
value="Record id should be a string number", driver=self)
subdomain = zone.extra.get('S%s' % record_id)
type = zone.extra.get('T%s' % record_id)
data = zone.extra.get('D%s' % record_id)
record = self._to_record(record_id, subdomain, type, data, zone)
return record
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`
"""
zone = self.get_zone(zone_id=zone_id)
action = '/v1/Network/DNS/Record/details'
data = json.dumps({'params': {'id': record_id}})
try:
response = self.connection.request(action=action,
method='POST',
data=data)
except APIException:
e = sys.exc_info()[1]
if e.error_class == 'LW::Exception::RecordNotFound':
raise RecordDoesNotExistError(record_id=record_id, driver=self,
value=e.value)
else:
raise e
record = self._to_record(response.objects[0], zone=zone)
return record
def get_record(self, zone_id, record_id):
"""
:param zone_id: The id of the zone where to search for
the record (e.g. example.com)
:type zone_id: ``str``
:param record_id: The type of record to search for
(e.g. A, AAA, MX etc)
:return: :class:`Record`
"""
action = '/v1/zones/%s/%s/%s' % (zone_id, zone_id, record_id)
try:
response = self.connection.request(action=action, method='GET')
except NsOneException:
e = sys.exc_info()[1]
if e.message == 'record not found':
raise RecordDoesNotExistError(value=e.message,
driver=self,
record_id=record_id)
else:
raise e
zone = self.get_zone(zone_id=zone_id)
record = self._to_record(item=response.parse_body(), zone=zone)
return record
def delete_record(self, record):
"""
Delete a record.
:param record: Record to delete.
:type record: :class:`Record`
:rtype: ``bool``
"""
action = '/v1/dns/delete_record'
params = {'api_key': self.key}
data = urlencode({'RECORDID': record.id, 'domain': record.zone.domain})
zone_records = self.list_records(record.zone)
if not self.ex_record_exists(record.id, zone_records):
raise RecordDoesNotExistError(value='',
driver=self,
record_id=record.id)
response = self.connection.request(action=action,
params=params,
data=data,
method='POST')
return response.status == 200
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`
"""
zone = self.get_zone(zone_id)
r_entry = [
i for i in range(MAX_RECORD_ENTRIES)
if zone.extra.get('S%s' % i) == record_id
]
if not r_entry:
raise RecordDoesNotExistError(value="Record doesn't exists",
driver=zone.driver,
record_id=record_id)
entry = r_entry[0]
type = zone.extra.get('T%s' % entry)
data = zone.extra.get('D%s' % entry)
record = self._to_record(record_id, type, data, zone)
return record
def delete_record(self, record):
"""
Use this method to delete a record.
:param record: record to delete
:type record: `Record`
:rtype: Bool
"""
action = '/dns/%s/removeRR' % record.zone.domain
payload = {
'name': record.name,
'data': record.data,
'type': record.type
}
try:
self.connection.request(action=action, data=payload, method='POST')
except BaseHTTPError:
e = sys.exc_info()[1]
if e.code == httplib.NOT_FOUND:
raise RecordDoesNotExistError(value=e.message,
driver=self,
record_id=None)
raise e
return True
def parse_error(self):
status = int(self.status)
if status == httplib.UNAUTHORIZED:
raise InvalidCredsError(value='Authentication failed', driver=self)
elif status == httplib.FORBIDDEN:
raise ProviderError(value='Authorization failed',
http_code=status,
driver=self)
elif status == httplib.NOT_FOUND:
context = self.connection.context
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'])
elif status == httplib.CONFLICT:
context = self.connection.context
if context['resource'] == 'zone':
raise ZoneAlreadyExistsError(value='',
driver=self,
zone_id=context['id'])
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 = "%s - %s (%s)" % (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))
def parse_error(self):
status = int(self.status)
error = {'driver': self, 'value': ''}
if status == httplib.UNAUTHORIZED:
error['value'] = 'Authentication failed'
raise InvalidCredsError(**error)
elif status == httplib.FORBIDDEN:
error['value'] = 'Authorization failed'
error['http_status'] = status
raise ProviderError(**error)
elif status == httplib.NOT_FOUND:
context = self.connection.context
if context['resource'] == 'zone':
error['zone_id'] = context['id']
raise ZoneDoesNotExistError(**error)
elif context['resource'] == 'record':
error['record_id'] = context['id']
raise RecordDoesNotExistError(**error)
elif context['resource'] == 'healthcheck':
error['health_check_id'] = context['id']
raise HealthCheckDoesNotExistError(**error)
elif status == httplib.CONFLICT:
context = self.connection.context
if context['resource'] == 'zone':
error['zone_id'] = context['id']
raise ZoneAlreadyExistsError(**error)
elif status == httplib.BAD_REQUEST:
context = self.connection.context
body = self.parse_body()
raise ProviderError(value=body['errormsg'],
http_code=status,
driver=self)
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`
"""
record = None
zone = self.get_zone(zone_id=zone_id)
records = self.list_records(zone=zone)
for r in records:
if r.id == record_id:
record = r
if record is None:
raise RecordDoesNotExistError(record_id=record_id, driver=self,
value='')
return record
def parse_error(self):
status = int(self.status)
if status == 401:
if not self.body:
raise InvalidCredsError(str(self.status) + ": " + self.error)
else:
raise InvalidCredsError(self.body)
elif status == 404:
context = self.connection.context
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"])
elif status != 503:
try:
body = ET.XML(self.body)
except Exception:
raise MalformedResponseError("Failed to parse XML",
body=self.body)
errors = []
for error in findall(element=body, xpath="error"):
errors.append(error.text)
raise ZerigoError(code=status, errors=errors)
return self.body
def get_record(self, zone_id, record_id):
"""
Returns a Record instance.
:param zone_id: name of the required zone
:type zone_id: ``str``
:param record_id: ID of the required record
:type record_id: ``str``
:rtype: :class: `Record`
"""
ret_record = None
zone = self.get_zone(zone_id=zone_id)
records = self.list_records(zone=zone)
if not self.ex_record_exists(record_id, records):
raise RecordDoesNotExistError(value='',
driver=self,
record_id=record_id)
for record in records:
if record_id == record.id:
ret_record = record
return ret_record
def parse_error(self):
status = int(self.status)
error = {"driver": self, "value": ""}
if status == httplib.UNAUTHORIZED:
error["value"] = "Authentication failed"
raise InvalidCredsError(**error)
elif status == httplib.FORBIDDEN:
error["value"] = "Authorization failed"
error["http_code"] = status
raise ProviderError(**error)
elif status == httplib.NOT_FOUND:
context = self.connection.context
if context["resource"] == "zone":
error["zone_id"] = context["id"]
raise ZoneDoesNotExistError(**error)
elif context["resource"] == "record":
error["record_id"] = context["id"]
raise RecordDoesNotExistError(**error)
elif context["resource"] == "healthcheck":
error["health_check_id"] = context["id"]
raise HealthCheckDoesNotExistError(**error)
elif status == httplib.CONFLICT:
context = self.connection.context
if context["resource"] == "zone":
error["zone_id"] = context["id"]
raise ZoneAlreadyExistsError(**error)
elif status == httplib.BAD_REQUEST:
context = self.connection.context
body = self.parse_body()
raise ProviderError(value=body["errormsg"],
http_code=status,
driver=self)
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:
e = sys.exc_info()[1]
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 parse_body(self):
body = super(CloudFlareDNSResponse, self).parse_body()
body = body or {}
result = body.get('result', None)
error_code = body.get('err_code', None)
msg = body.get('msg', None)
is_error_result = result == 'error'
context = self.connection.context or {}
context_record_id = context.get('record_id', None)
context_zone_domain = context.get('zone_domain', None)
if (is_error_result and 'invalid record id' in msg.lower()
and context_record_id):
raise RecordDoesNotExistError(value=msg,
driver=self.connection.driver,
record_id=context_record_id)
elif (is_error_result and 'invalid zone' in msg.lower()
and context_zone_domain):
raise ZoneDoesNotExistError(value=msg,
driver=self.connection.driver,
zone_id=context_zone_domain)
if error_code == 'E_UNAUTH':
raise InvalidCredsError(msg)
elif result == 'error' or error_code is not None:
msg = 'Request failed: %s' % (self.body)
raise LibcloudError(value=msg, driver=self.connection.driver)
return body
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`
"""
(record_type, record_name) = record_id.split(':', 1)
params = {
'name': record_name,
'type': record_type,
}
request = '/managedZones/%s/rrsets' % (zone_id)
try:
response = self.connection.request(request, method='GET',
params=params).object
except ResourceNotFoundError:
raise ZoneDoesNotExistError(value='',
driver=self.connection.driver,
zone_id=zone_id)
if len(response['rrsets']) > 0:
zone = self.get_zone(zone_id)
return self._to_record(response['rrsets'][0], zone)
raise RecordDoesNotExistError(value='', driver=self.connection.driver,
record_id=record_id)
def delete_record(self, record):
"""
Delete a record.
:param record: Record to delete.
:type record: :class:`Record`
:rtype: ``bool``
"""
action = '/v1/Network/DNS/Record/delete'
data = json.dumps({'params': {'id': record.id}})
try:
response = self.connection.request(action=action,
method='POST',
data=data)
except APIException:
e = sys.exc_info()[1]
if e.error_class == 'LW::Exception::RecordNotFound':
raise RecordDoesNotExistError(record_id=record.id,
driver=self,
value=e.value)
else:
raise e
return record.id in response.objects
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 = '%s - %s (%s)' % (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))
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`
"""
zone = self.get_zone(zone_id=zone_id)
action = '/Record.Info'
data = {'domain_id': zone_id, 'record_id': record_id}
try:
response = self._make_request(action=action,
method='POST',
data=data)
except DNSPodException:
e = sys.exc_info()[1]
if e.message in RECORD_DOES_NOT_EXIST_ERRORS_MSGS:
raise RecordDoesNotExistError(record_id=record_id,
driver=self,
value='')
elif e.message in ZONE_DOES_NOT_EXIST_ERROR_MSGS:
raise ZoneDoesNotExistError(zone_id=zone_id,
driver=self,
value='')
else:
raise e
record = self._to_record(response.object['record'], zone=zone)
return record
def get_record(self, zone_id, record_id):
zone = self.get_zone(zone_id=zone_id)
for record in self.iterate_records(zone):
if record.id == record_id:
return record
raise RecordDoesNotExistError(value='',
driver=self,
record_id=record_id)
def delete_record(self, record):
try:
r = record
batch = [("DELETE", r.name, r.type, r.data, r.extra)]
self._post_changeset(record.zone, batch)
except InvalidChangeBatch:
raise RecordDoesNotExistError(value="", driver=self, record_id=r.id)
return True
def get_record(self, zone_id, record_id):
zone = self.get_zone(zone_id=zone_id)
params = {'id': record_id}
self.connection.set_context({'resource': 'record', 'id': record_id})
result = self.connection.request(
API_ROOT + '/dns/record/', params=params).object
if 'id' not in result:
raise RecordDoesNotExistError(value='',
driver=self, record_id=record_id)
record = self._to_record(item=result, zone=zone)
return record
def get_record(self, zone_id, record_id):
try:
record = self.connection.request(
'SoftLayer_Dns_Domain_ResourceRecord',
'getObject',
id=record_id
).object
return self._to_record(record, zone=self.get_zone(zone_id))
except SoftLayerObjectDoesntExist:
raise RecordDoesNotExistError(value='', driver=self,
record_id=record_id)
def get_record(self, zone_id, record_id):
record_type, name = record_id.split(':', 1)
action = '%s/domains/%s/records/%s/%s' % (API_BASE, zone_id, name,
record_type)
try:
record = self.connection.request(action=action, method='GET')
except ResourceNotFoundError:
raise RecordDoesNotExistError(value='',
driver=self.connection.driver,
record_id=record_id)
return self._to_record(record.object, self.get_zone(zone_id))[0]
