openstack/deb-designate
Code Issues Proposed changes

Merge "API now passes objects to central"

Browse Source
This commit is contained in:
Jenkins 2014-06-09 13:18:13 +00:00 committed by Gerrit Code Review
commit d18ce92a52
21 changed files with 403 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
contrib/designate-ext-samplehandler/designate_ext_samplehandler/notification_handler/sample.py
View File

@ -15,6 +15,7 @@
# under the License.
from oslo.config import cfg
from designate.openstack.common import log as logging
from designate.objects import Record
from designate.notification_handler.base import NotificationHandler
LOG = logging.getLogger(__name__)
@ -64,13 +65,17 @@ class SampleHandler(NotificationHandler):
for fixed_ip in payload['fixed_ips']:
if fixed_ip['version'] == 4:
self.central_api.create_record(domain_id,
type='A',
name=hostname,
data=fixed_ip['address'])
values = dict(
type='A',
name=hostname,
data=fixed_ip['address']
)
self.central_api.create_record(domain_id, Record(**values))
elif fixed_ip['version'] == 6:
self.central_api.create_record(domain_id,
type='AAAA',
name=hostname,
data=fixed_ip['address'])
values = dict(
type='AAAA',
name=hostname,
data=fixed_ip['address']
)
self.central_api.create_record(domain_id, Record(**values))

3
designate/api/v1/domains.py
View File

@ -17,6 +17,7 @@ import flask
from designate.openstack.common import log as logging
from designate import schema
from designate.api import get_central_api
from designate.objects import Domain
LOG = logging.getLogger(__name__)
blueprint = flask.Blueprint('domains', __name__)
@ -41,7 +42,7 @@ def create_domain():
values = flask.request.json
domain_schema.validate(values)
domain = get_central_api().create_domain(context, values)
domain = get_central_api().create_domain(context, Domain(**values))
response = flask.jsonify(domain_schema.filter(domain))
response.status_int = 201

10
designate/api/v1/records.py
View File

@ -18,6 +18,8 @@ from designate.openstack.common import log as logging
from designate import exceptions
from designate import schema
from designate.api import get_central_api
from designate.objects import Record
from designate.objects import RecordSet
LOG = logging.getLogger(__name__)
blueprint = flask.Blueprint('records', __name__)
@ -37,18 +39,20 @@ def _find_or_create_recordset(context, domain_id, name, type, ttl):
try:
recordset = _find_recordset(context, domain_id, name, type)
except exceptions.RecordSetNotFound:
recordset = get_central_api().create_recordset(context, domain_id, {
values = {
'name': name,
'type': type,
'ttl': ttl,
})
}
recordset = get_central_api().create_recordset(
context, domain_id, RecordSet(**values))
return recordset
def _extract_record_values(values):
record_values = ('data', 'priority', 'comment',)
return dict((k, values[k]) for k in record_values if k in values)
return Record(**dict((k, values[k]) for k in record_values if k in values))
def _extract_recordset_values(values):

3
designate/api/v1/servers.py
View File

@ -17,6 +17,7 @@ import flask
from designate.openstack.common import log as logging
from designate import schema
from designate.api import get_central_api
from designate.objects import Server
LOG = logging.getLogger(__name__)
blueprint = flask.Blueprint('servers', __name__)
@ -41,7 +42,7 @@ def create_server():
server_schema.validate(values)
server = get_central_api().create_server(context,
values=flask.request.json)
server=Server(**values))
response = flask.jsonify(server_schema.filter(server))
response.status_int = 201

3
designate/api/v1/tsigkeys.py
View File

@ -17,6 +17,7 @@ import flask
from designate.openstack.common import log as logging
from designate import schema
from designate.api import get_central_api
from designate.objects import TsigKey
LOG = logging.getLogger(__name__)
blueprint = flask.Blueprint('tsigkeys', __name__)
@ -41,7 +42,7 @@ def create_tsigkey():
tsigkey_schema.validate(values)
tsigkey = get_central_api().create_tsigkey(
context, values=flask.request.json)
context, tsigkey=TsigKey(**values))
response = flask.jsonify(tsigkey_schema.filter(tsigkey))
response.status_int = 201

4
designate/api/v2/controllers/blacklists.py
View File

@ -20,6 +20,7 @@ from designate import schema
from designate import utils
from designate.api.v2.controllers import rest
from designate.api.v2.views import blacklists as blacklists_view
from designate.objects import Blacklist
LOG = logging.getLogger(__name__)
@ -77,7 +78,8 @@ class BlacklistsController(rest.RestController):
values = self._view.load(context, request, body)
# Create the blacklist
blacklist = self.central_api.create_blacklist(context, values)
blacklist = self.central_api.create_blacklist(
context, Blacklist(**values))
response.status_int = 201

5
designate/api/v2/controllers/records.py
View File

@ -19,6 +19,7 @@ from designate import schema
from designate import utils
from designate.api.v2.controllers import rest
from designate.api.v2.views import records as records_view
from designate.objects import Record
LOG = logging.getLogger(__name__)
@ -83,8 +84,8 @@ class RecordsController(rest.RestController):
values = self._view.load(context, request, body)
# Create the records
record = self.central_api.create_record(context, zone_id, recordset_id,
values)
record = self.central_api.create_record(
context, zone_id, recordset_id, Record(**values))
# Prepare the response headers
if record['status'] == 'PENDING':

4
designate/api/v2/controllers/recordsets.py
View File

@ -20,6 +20,7 @@ from designate import utils
from designate.api.v2.controllers import rest
from designate.api.v2.views import recordsets as recordsets_view
from designate.api.v2.controllers import records
from designate.objects import RecordSet
LOG = logging.getLogger(__name__)
@ -84,7 +85,8 @@ class RecordSetsController(rest.RestController):
values = self._view.load(context, request, body)
# Create the recordset
recordset = self.central_api.create_recordset(context, zone_id, values)
recordset = self.central_api.create_recordset(
context, zone_id, RecordSet(**values))
# Prepare the response headers
response.status_int = 201

3
designate/api/v2/controllers/tlds.py
View File

@ -18,6 +18,7 @@ from designate import schema
from designate import utils
from designate.api.v2.controllers import rest
from designate.api.v2.views import tlds as tlds_view
from designate.objects import Tld
LOG = logging.getLogger(__name__)
@ -73,7 +74,7 @@ class TldsController(rest.RestController):
values = self._view.load(context, request, body)
# Create the tld
tld = self.central_api.create_tld(context, values)
tld = self.central_api.create_tld(context, Tld(**values))
response.status_int = 201
response.headers['Location'] = self._view._get_resource_href(request,

14
designate/api/v2/controllers/zones.py
View File

@ -24,6 +24,9 @@ from designate.api.v2.controllers import rest
from designate.api.v2.controllers import nameservers
from designate.api.v2.controllers import recordsets
from designate.api.v2.views import zones as zones_view
from designate.objects import Domain
from designate.objects import Record
from designate.objects import RecordSet
from designate.openstack.common import log as logging
LOG = logging.getLogger(__name__)
@ -141,7 +144,7 @@ class ZonesController(rest.RestController):
values = self._view.load(context, request, body)
# Create the zone
zone = self.central_api.create_domain(context, values)
zone = self.central_api.create_domain(context, Domain(**values))
# Prepare the response headers
# If the zone has been created asynchronously
@ -264,7 +267,7 @@ class ZonesController(rest.RestController):
'email': email,
'ttl': str(soa.ttl)
}
return self.central_api.create_domain(context, values)
return self.central_api.create_domain(context, Domain(**values))
def _record2json(self, record_type, rdata):
if record_type == 'MX':
@ -300,7 +303,7 @@ class ZonesController(rest.RestController):
}
recordset = self.central_api.create_recordset(
context, zone_id, values)
context, zone_id, RecordSet(**values))
for rdata in rdataset:
if (record_type == 'NS'
@ -314,7 +317,10 @@ class ZonesController(rest.RestController):
values = self._record2json(record_type, rdata)
self.central_api.create_record(
context, zone_id, recordset['id'], values)
context,
zone_id,
recordset['id'],
Record(**values))
def _parse_zonefile(self, request):
""" Parses a POSTed zonefile into a dnspython zone object """

105
designate/central/rpcapi.py
View File

@ -39,14 +39,15 @@ class CentralAPI(object):
3.1 - Add floating ip ptr methods
3.2 - TLD Api changes
3.3 - Add methods for blacklisted domains
4.0 - Create methods now accept designate objects
"""
RPC_API_VERSION = '3.0'
RPC_API_VERSION = '4.0'
def __init__(self, topic=None):
topic = topic if topic else cfg.CONF.central_topic
target = messaging.Target(topic=topic, version=self.RPC_API_VERSION)
self.client = rpc.get_client(target, version_cap='3.3')
self.client = rpc.get_client(target, version_cap='4.0')
# Misc Methods
def get_absolute_limits(self, context):
@ -78,10 +79,10 @@ class CentralAPI(object):
return self.client.call(context, 'reset_quotas', tenant_id=tenant_id)
# Server Methods
def create_server(self, context, values):
def create_server(self, context, server):
LOG.info("create_server: Calling central's create_server.")
return self.client.call(context, 'create_server', values=values)
return self.client.call(context, 'create_server', server=server)
def find_servers(self, context, criterion=None, marker=None, limit=None,
sort_key=None, sort_dir=None):
@ -108,15 +109,13 @@ class CentralAPI(object):
return self.client.call(context, 'delete_server', server_id=server_id)
# TSIG Key Methods
def create_tsigkey(self, context, values):
def create_tsigkey(self, context, tsigkey):
LOG.info("create_tsigkey: Calling central's create_tsigkey.")
return self.client.call(context, 'create_tsigkey', values=values)
return self.client.call(context, 'create_tsigkey', tsigkey=tsigkey)
def find_tsigkeys(self, context, criterion=None, marker=None, limit=None,
sort_key=None, sort_dir=None):
LOG.info("find_tsigkeys: Calling central's find_tsigkeys.")
return self.client.call(context, 'find_tsigkeys', criterion=criterion,
marker=marker, limit=limit, sort_key=sort_key,
sort_dir=sort_dir)
@ -150,9 +149,9 @@ class CentralAPI(object):
return self.client.call(context, 'count_tenants')
# Domain Methods
def create_domain(self, context, values):
def create_domain(self, context, domain):
LOG.info("create_domain: Calling central's create_domain.")
return self.client.call(context, 'create_domain', values=values)
return self.client.call(context, 'create_domain', domain=domain)
def get_domain(self, context, domain_id):
LOG.info("get_domain: Calling central's get_domain.")
@ -193,43 +192,35 @@ class CentralAPI(object):
return self.client.call(context, 'touch_domain', domain_id=domain_id)
# TLD Methods
def create_tld(self, context, values):
def create_tld(self, context, tld):
LOG.info("create_tld: Calling central's create_tld.")
cctxt = self.client.prepare(version='3.2')
return cctxt.call(context, 'create_tld', values=values)
return self.client.call(context, 'create_tld', tld=tld)
def find_tlds(self, context, criterion=None, marker=None, limit=None,
sort_key=None, sort_dir=None):
LOG.info("find_tlds: Calling central's find_tlds.")
cctxt = self.client.prepare(version='3.2')
return cctxt.call(context, 'find_tlds', criterion=criterion,
marker=marker, limit=limit, sort_key=sort_key,
sort_dir=sort_dir)
return self.client.call(context, 'find_tlds', criterion=criterion,
marker=marker, limit=limit, sort_key=sort_key,
sort_dir=sort_dir)
def get_tld(self, context, tld_id):
LOG.info("get_tld: Calling central's get_tld.")
cctxt = self.client.prepare(version='3.2')
return cctxt.call(context, 'get_tld', tld_id=tld_id)
return self.client.call(context, 'get_tld', tld_id=tld_id)
def update_tld(self, context, tld_id, values):
LOG.info("update_tld: Calling central's update_tld.")
cctxt = self.client.prepare(version='3.2')
return cctxt.call(context, 'update_tld', tld_id=tld_id, values=values)
return self.client.call(context, 'update_tld', tld_id=tld_id,
values=values)
def delete_tld(self, context, tld_id):
LOG.info("delete_tld: Calling central's delete_tld.")
cctxt = self.client.prepare(version='3.2')
return cctxt.call(context, 'delete_tld', tld_id=tld_id)
return self.client.call(context, 'delete_tld', tld_id=tld_id)
# RecordSet Methods
def create_recordset(self, context, domain_id, values):
def create_recordset(self, context, domain_id, recordset):
LOG.info("create_recordset: Calling central's create_recordset.")
return self.client.call(context, 'create_recordset',
domain_id=domain_id, values=values)
domain_id=domain_id, recordset=recordset)
def get_recordset(self, context, domain_id, recordset_id):
LOG.info("get_recordset: Calling central's get_recordset.")
@ -271,13 +262,13 @@ class CentralAPI(object):
criterion=criterion)
# Record Methods
def create_record(self, context, domain_id, recordset_id, values,
def create_record(self, context, domain_id, recordset_id, record,
increment_serial=True):
LOG.info("create_record: Calling central's create_record.")
return self.client.call(context, 'create_record',
domain_id=domain_id,
recordset_id=recordset_id,
values=values,
record=record,
increment_serial=increment_serial)
def get_record(self, context, domain_id, recordset_id, record_id):
@ -339,62 +330,46 @@ class CentralAPI(object):
def list_floatingips(self, context):
LOG.info("list_floatingips: Calling central's list_floatingips.")
cctxt = self.client.prepare(version='3.1')
return cctxt.call(context, 'list_floatingips')
return self.client.call(context, 'list_floatingips')
def get_floatingip(self, context, region, floatingip_id):
LOG.info("get_floatingip: Calling central's get_floatingip.")
cctxt = self.client.prepare(version='3.1')
return cctxt.call(context, 'get_floatingip', region=region,
floatingip_id=floatingip_id)
return self.client.call(context, 'get_floatingip', region=region,
floatingip_id=floatingip_id)
def update_floatingip(self, context, region, floatingip_id, values):
LOG.info("update_floatingip: Calling central's update_floatingip.")
cctxt = self.client.prepare(version='3.1')
return cctxt.call(context, 'update_floatingip', region=region,
floatingip_id=floatingip_id, values=values)
return self.client.call(context, 'update_floatingip', region=region,
floatingip_id=floatingip_id, values=values)
# Blacklisted Domain Methods
def create_blacklist(self, context, values):
def create_blacklist(self, context, blacklist):
LOG.info("create_blacklist: Calling central's create_blacklist")
cctxt = self.client.prepare(version='3.3')
return cctxt.call(context, 'create_blacklist', values=values)
return self.client.call(context, 'create_blacklist',
blacklist=blacklist)
def get_blacklist(self, context, blacklist_id):
LOG.info("get_blacklist: Calling central's get_blacklist.")
cctxt = self.client.prepare(version='3.3')
return cctxt.call(context, 'get_blacklist', blacklist_id=blacklist_id)
return self.client.call(context, 'get_blacklist',
blacklist_id=blacklist_id)
def find_blacklists(self, context, criterion=None, marker=None, limit=None,
sort_key=None, sort_dir=None):
LOG.info("find_blacklists: Calling central's find_blacklists.")
cctxt = self.client.prepare(version='3.3')
return cctxt.call(context, 'find_blacklists', criterion=criterion,
marker=marker, limit=limit, sort_key=sort_key,
sort_dir=sort_dir)
return self.client.call(
context, 'find_blacklists', criterion=criterion, marker=marker,
limit=limit, sort_key=sort_key, sort_dir=sort_dir)
def find_blacklist(self, context, criterion):
LOG.info("find_blacklist: Calling central's find_blacklist.")
cctxt = self.client.prepare(version='3.3')
return cctxt.call(context, 'find_blacklist', criterion=criterion)
return self.client.call(context, 'find_blacklist', criterion=criterion)
def update_blacklist(self, context, blacklist_id, values):
LOG.info("update_blacklist: Calling central's update_blacklist.")
cctxt = self.client.prepare(version='3.3')
return cctxt.call(context, 'update_blacklist',
blacklist_id=blacklist_id, values=values)
return self.client.call(context, 'update_blacklist',
blacklist_id=blacklist_id, values=values)
def delete_blacklist(self, context, blacklist_id):
LOG.info("delete_blacklist: Calling central's delete blacklist.")
cctxt = self.client.prepare(version='3.3')
return cctxt.call(context, 'delete_blacklist',
blacklist_id=blacklist_id)
return self.client.call(context, 'delete_blacklist',
blacklist_id=blacklist_id)

251
designate/central/service.py
View File

@ -24,6 +24,7 @@ from designate.openstack.common import log as logging
from designate import backend
from designate import exceptions
from designate import network_api
from designate import objects
from designate import policy
from designate import quota
from designate import service
@ -47,7 +48,7 @@ def wrap_backend_call():
class Service(service.Service):
RPC_API_VERSION = '3.3'
RPC_API_VERSION = '4.0'
target = messaging.Target(version=RPC_API_VERSION)
@ -145,13 +146,13 @@ class Service(service.Service):
def _is_valid_recordset_placement(self, context, domain, recordset_name,
recordset_type, recordset_id=None):
# CNAME's must not be created at the zone apex.
if recordset_type == 'CNAME' and recordset_name == domain['name']:
if recordset_type == 'CNAME' and recordset_name == domain.name:
raise exceptions.InvalidRecordSetLocation(
'CNAME recordsets may not be created at the zone apex')
# CNAME's must not share a name with other recordsets
criterion = {
'domain_id': domain['id'],
'domain_id': domain.id,
'name': recordset_name,
}
@ -160,7 +161,7 @@ class Service(service.Service):
recordsets = self.storage_api.find_recordsets(context, criterion)
if ((len(recordsets) == 1 and recordsets[0]['id'] != recordset_id)
if ((len(recordsets) == 1 and recordsets[0].id != recordset_id)
or len(recordsets) > 1):
raise exceptions.InvalidRecordSetLocation(
'CNAME recordsets may not share a name with any other records')
@ -175,18 +176,18 @@ class Service(service.Service):
domains subdomains..
"""
LOG.debug("Checking if %s belongs in any of %s subdomains",
recordset_name, domain['name'])
recordset_name, domain.name)
criterion = criterion or {}
context = context.elevated()
context.all_tenants = True
if domain['name'] == recordset_name:
if domain.name == recordset_name:
return
child_domains = self.storage_api.find_domains(
context, {"parent_domain_id": domain['id']})
context, {"parent_domain_id": domain.id})
for child_domain in child_domains:
try:
self._is_valid_recordset_name(
@ -206,7 +207,7 @@ class Service(service.Service):
blacklists = self.storage_api.find_blacklists(context)
for blacklist in blacklists:
if bool(re.search(blacklist["pattern"], domain_name)):
if bool(re.search(blacklist.pattern, domain_name)):
return True
return False
@ -312,17 +313,17 @@ class Service(service.Service):
self.quota.reset_quotas(context, tenant_id)
# Server Methods
def create_server(self, context, values):
def create_server(self, context, server):
policy.check('create_server', context)
with self.storage_api.create_server(context, values) as server:
with self.storage_api.create_server(context, server) as created_server:
# Update backend with the new server..
with wrap_backend_call():
self.backend.create_server(context, server)
self.backend.create_server(context, created_server)
self.notifier.info(context, 'dns.server.create', server)
self.notifier.info(context, 'dns.server.create', created_server)
return server
return created_server
def find_servers(self, context, criterion=None, marker=None, limit=None,
sort_key=None, sort_dir=None):
@ -354,7 +355,7 @@ class Service(service.Service):
# don't delete last of servers
servers = self.storage_api.find_servers(context)
if len(servers) == 1 and server_id == servers[0]['id']:
if len(servers) == 1 and server_id == servers[0].id:
raise exceptions.LastServerDeleteNotAllowed(
"Not allowed to delete last of servers")
@ -366,17 +367,17 @@ class Service(service.Service):
self.notifier.info(context, 'dns.server.delete', server)
# TLD Methods
def create_tld(self, context, values):
def create_tld(self, context, tld):
policy.check('create_tld', context)
# The TLD is only created on central's storage and not on the backend.
with self.storage_api.create_tld(context, values) as tld:
with self.storage_api.create_tld(context, tld) as created_tld:
pass
self.notifier.info(context, 'dns.tld.create', tld)
self.notifier.info(context, 'dns.tld.create', created_tld)
# Set check for tlds to be true
self.check_for_tlds = True
return tld
return created_tld
def find_tlds(self, context, criterion=None, marker=None, limit=None,
sort_key=None, sort_dir=None):
@ -414,16 +415,17 @@ class Service(service.Service):
self.notifier.info(context, 'dns.tld.delete', tld)
# TSIG Key Methods
def create_tsigkey(self, context, values):
def create_tsigkey(self, context, tsigkey):
policy.check('create_tsigkey', context)
with self.storage_api.create_tsigkey(context, values) as tsigkey:
with self.storage_api.create_tsigkey(context, tsigkey) \
as created_tsigkey:
with wrap_backend_call():
self.backend.create_tsigkey(context, tsigkey)
self.backend.create_tsigkey(context, created_tsigkey)
self.notifier.info(context, 'dns.tsigkey.create', tsigkey)
self.notifier.info(context, 'dns.tsigkey.create', created_tsigkey)
return tsigkey
return created_tsigkey
def find_tsigkeys(self, context, criterion=None, marker=None, limit=None,
sort_key=None, sort_dir=None):
@ -477,38 +479,37 @@ class Service(service.Service):
return self.storage_api.count_tenants(context)
# Domain Methods
def create_domain(self, context, values):
def create_domain(self, context, domain):
# TODO(kiall): Refactor this method into *MUCH* smaller chunks.
# Default to creating in the current users tenant
if 'tenant_id' not in values:
values['tenant_id'] = context.tenant
if not hasattr(domain, 'tenant_id'):
domain.tenant_id = context.tenant
target = {
'tenant_id': values['tenant_id'],
'domain_name': values['name']
'tenant_id': domain.tenant_id,
'domain_name': domain.name
}
policy.check('create_domain', context, target)
# Ensure the tenant has enough quota to continue
self._enforce_domain_quota(context, values['tenant_id'])
self._enforce_domain_quota(context, domain.tenant_id)
# Ensure the domain name is valid
self._is_valid_domain_name(context, values['name'])
self._is_valid_domain_name(context, domain.name)
# Ensure TTL is above the minimum
ttl = values.get('ttl', None)
if ttl is not None:
self._is_valid_ttl(context, ttl)
if hasattr(domain, 'ttl') and domain.ttl is not None:
self._is_valid_ttl(context, domain.ttl)
# Handle sub-domains appropriately
parent_domain = self._is_subdomain(context, values['name'])
parent_domain = self._is_subdomain(context, domain.name)
if parent_domain:
if parent_domain['tenant_id'] == values['tenant_id']:
if parent_domain.tenant_id == domain.tenant_id:
# Record the Parent Domain ID
values['parent_domain_id'] = parent_domain['id']
domain.parent_domain_id = parent_domain.id
else:
raise exceptions.Forbidden('Unable to create subdomain in '
'another tenants domain')
@ -526,23 +527,23 @@ class Service(service.Service):
raise exceptions.NoServersConfigured()
# Set the serial number
values['serial'] = utils.increment_serial()
domain.serial = utils.increment_serial()
with self.storage_api.create_domain(context, values) as domain:
with self.storage_api.create_domain(context, domain) as created_domain:
with wrap_backend_call():
self.backend.create_domain(context, domain)
self.backend.create_domain(context, created_domain)
self.notifier.info(context, 'dns.domain.create', domain)
self.notifier.info(context, 'dns.domain.create', created_domain)
return domain
return created_domain
def get_domain(self, context, domain_id):
domain = self.storage_api.get_domain(context, domain_id)
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'tenant_id': domain['tenant_id']
'domain_name': domain.name,
'tenant_id': domain.tenant_id
}
policy.check('get_domain', context, target)
@ -553,8 +554,8 @@ class Service(service.Service):
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'tenant_id': domain['tenant_id']
'domain_name': domain.name,
'tenant_id': domain.tenant_id
}
policy.check('get_domain_servers', context, target)
@ -583,8 +584,8 @@ class Service(service.Service):
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'tenant_id': domain['tenant_id']
'domain_name': domain.name,
'tenant_id': domain.tenant_id
}
policy.check('update_domain', context, target)
@ -599,7 +600,7 @@ class Service(service.Service):
target = {'domain_id': domain_id, 'tenant_id': values['tenant_id']}
policy.check('create_domain', context, target)
if 'name' in values and values['name'] != domain['name']:
if 'name' in values and values['name'] != domain.name:
raise exceptions.BadRequest('Renaming a domain is not allowed')
# Ensure TTL is above the minimum
@ -609,7 +610,7 @@ class Service(service.Service):
if increment_serial:
# Increment the serial number
values['serial'] = utils.increment_serial(domain['serial'])
values['serial'] = utils.increment_serial(domain.serial)
with self.storage_api.update_domain(
context, domain_id, values) as domain:
@ -625,8 +626,8 @@ class Service(service.Service):
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'tenant_id': domain['tenant_id']
'domain_name': domain.name,
'tenant_id': domain.tenant_id
}
policy.check('delete_domain', context, target)
@ -663,8 +664,8 @@ class Service(service.Service):
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'tenant_id': domain['tenant_id']
'domain_name': domain.name,
'tenant_id': domain.tenant_id
}
policy.check('touch_domain', context, target)
@ -676,14 +677,14 @@ class Service(service.Service):
return domain
# RecordSet Methods
def create_recordset(self, context, domain_id, values):
def create_recordset(self, context, domain_id, recordset):
domain = self.storage_api.get_domain(context, domain_id)
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'recordset_name': values['name'],
'tenant_id': domain['tenant_id'],
'domain_name': domain.name,
'recordset_name': recordset.name,
'tenant_id': domain.tenant_id,
}
policy.check('create_recordset', context, target)
@ -692,40 +693,41 @@ class Service(service.Service):
self._enforce_recordset_quota(context, domain)
# Ensure TTL is above the minimum
ttl = values.get('ttl', None)
ttl = getattr(recordset, 'ttl', None)
if ttl is not None:
self._is_valid_ttl(context, ttl)
# Ensure the recordset name and placement is valid
self._is_valid_recordset_name(context, domain, values['name'])
self._is_valid_recordset_placement(context, domain, values['name'],
values['type'])
self._is_valid_recordset_name(context, domain, recordset.name)
self._is_valid_recordset_placement(context, domain, recordset.name,
recordset.type)
self._is_valid_recordset_placement_subdomain(
context, domain, values['name'])
context, domain, recordset.name)
with self.storage_api.create_recordset(
context, domain_id, values) as recordset:
context, domain_id, recordset) as created_recordset:
with wrap_backend_call():
self.backend.create_recordset(context, domain, recordset)
self.backend.create_recordset(
context, domain, created_recordset)
# Send RecordSet creation notification
self.notifier.info(context, 'dns.recordset.create', recordset)
self.notifier.info(context, 'dns.recordset.create', created_recordset)
return recordset
return created_recordset
def get_recordset(self, context, domain_id, recordset_id):
domain = self.storage_api.get_domain(context, domain_id)
recordset = self.storage_api.get_recordset(context, recordset_id)
# Ensure the domain_id matches the record's domain_id
if domain['id'] != recordset['domain_id']:
if domain.id != recordset.domain_id:
raise exceptions.RecordSetNotFound()
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'recordset_id': recordset['id'],
'tenant_id': domain['tenant_id'],
'domain_name': domain.name,
'recordset_id': recordset.id,
'tenant_id': domain.tenant_id,
}
policy.check('get_recordset', context, target)
@ -752,23 +754,23 @@ class Service(service.Service):
recordset = self.storage_api.get_recordset(context, recordset_id)
# Ensure the domain_id matches the recordset's domain_id
if domain['id'] != recordset['domain_id']:
if domain.id != recordset.domain_id:
raise exceptions.RecordSetNotFound()
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'recordset_id': recordset['id'],
'tenant_id': domain['tenant_id']
'domain_name': domain.name,
'recordset_id': recordset.id,
'tenant_id': domain.tenant_id
}
policy.check('update_recordset', context, target)
# Ensure the record name is valid
recordset_name = values['name'] if 'name' in values \
else recordset['name']
else recordset.name
recordset_type = values['type'] if 'type' in values \
else recordset['type']
else recordset.type
self._is_valid_recordset_name(context, domain, recordset_name)
self._is_valid_recordset_placement(context, domain, recordset_name,
@ -801,14 +803,14 @@ class Service(service.Service):
recordset = self.storage_api.get_recordset(context, recordset_id)
# Ensure the domain_id matches the recordset's domain_id
if domain['id'] != recordset['domain_id']:
if domain.id != recordset.domain_id:
raise exceptions.RecordSetNotFound()
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'recordset_id': recordset['id'],
'tenant_id': domain['tenant_id']
'domain_name': domain.name,
'recordset_id': recordset.id,
'tenant_id': domain.tenant_id
}
policy.check('delete_recordset', context, target)
@ -839,17 +841,17 @@ class Service(service.Service):
return self.storage_api.count_recordsets(context, criterion)
# Record Methods
def create_record(self, context, domain_id, recordset_id, values,
def create_record(self, context, domain_id, recordset_id, record,
increment_serial=True):
domain = self.storage_api.get_domain(context, domain_id)
recordset = self.storage_api.get_recordset(context, recordset_id)
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'domain_name': domain.name,
'recordset_id': recordset_id,
'recordset_name': recordset['name'],
'tenant_id': domain['tenant_id']
'recordset_name': recordset.name,
'tenant_id': domain.tenant_id
}
policy.check('create_record', context, target)
@ -858,17 +860,18 @@ class Service(service.Service):
self._enforce_record_quota(context, domain, recordset)
with self.storage_api.create_record(
context, domain_id, recordset_id, values) as record:
context, domain_id, recordset_id, record) as created_record:
with wrap_backend_call():
self.backend.create_record(context, domain, recordset, record)
self.backend.create_record(
context, domain, recordset, created_record)
if increment_serial:
self._increment_domain_serial(context, domain_id)
# Send Record creation notification
self.notifier.info(context, 'dns.record.create', record)
self.notifier.info(context, 'dns.record.create', created_record)
return record
return created_record
def get_record(self, context, domain_id, recordset_id, record_id):
domain = self.storage_api.get_domain(context, domain_id)
@ -876,20 +879,20 @@ class Service(service.Service):
record = self.storage_api.get_record(context, record_id)
# Ensure the domain_id matches the record's domain_id
if domain['id'] != record['domain_id']:
if domain.id != record.domain_id:
raise exceptions.RecordNotFound()
# Ensure the recordset_id matches the record's recordset_id
if recordset['id'] != record['recordset_id']:
if recordset.id != record.recordset_id:
raise exceptions.RecordNotFound()
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'domain_name': domain.name,
'recordset_id': recordset_id,
'recordset_name': recordset['name'],
'record_id': record['id'],
'tenant_id': domain['tenant_id']
'recordset_name': recordset.name,
'record_id': record.id,
'tenant_id': domain.tenant_id
}
policy.check('get_record', context, target)
@ -917,20 +920,20 @@ class Service(service.Service):
record = self.storage_api.get_record(context, record_id)
# Ensure the domain_id matches the record's domain_id
if domain['id'] != record['domain_id']:
if domain.id != record.domain_id:
raise exceptions.RecordNotFound()
# Ensure the recordset_id matches the record's recordset_id
if recordset['id'] != record['recordset_id']:
if recordset.id != record.recordset_id:
raise exceptions.RecordNotFound()
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'domain_name': domain.name,
'recordset_id': recordset_id,
'recordset_name': recordset['name'],
'record_id': record['id'],
'tenant_id': domain['tenant_id']
'recordset_name': recordset.name,
'record_id': record.id,
'tenant_id': domain.tenant_id
}
policy.check('update_record', context, target)
@ -956,20 +959,20 @@ class Service(service.Service):
record = self.storage_api.get_record(context, record_id)
# Ensure the domain_id matches the record's domain_id
if domain['id'] != record['domain_id']:
if domain.id != record.domain_id:
raise exceptions.RecordNotFound()
# Ensure the recordset_id matches the record's recordset_id
if recordset['id'] != record['recordset_id']:
if recordset.id != record.recordset_id:
raise exceptions.RecordNotFound()
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'domain_name': domain.name,
'recordset_id': recordset_id,
'recordset_name': recordset['name'],
'record_id': record['id'],
'tenant_id': domain['tenant_id']
'recordset_name': recordset.name,
'record_id': record.id,
'tenant_id': domain.tenant_id
}
policy.check('delete_record', context, target)
@ -1007,7 +1010,7 @@ class Service(service.Service):
rdata = []
for recordset in recordsets:
records = self.find_records(
context, {'recordset_id': recordset['id']})
context, {'recordset_id': recordset.id})
rdata.append((recordset, records))
with wrap_backend_call():
return self.backend.sync_domain(context, domain, rdata)
@ -1019,7 +1022,7 @@ class Service(service.Service):
results = {}
for domain in domains:
results[domain['id']] = self._sync_domain(context, domain)
results[domain.id] = self._sync_domain(context, domain)
return results
@ -1028,8 +1031,8 @@ class Service(service.Service):
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'tenant_id': domain['tenant_id']
'domain_name': domain.name,
'tenant_id': domain.tenant_id
}
policy.check('diagnostics_sync_domain', context, target)
@ -1042,11 +1045,11 @@ class Service(service.Service):
target = {
'domain_id': domain_id,
'domain_name': domain['name'],
'domain_name': domain.name,
'recordset_id': recordset_id,
'recordset_name': recordset['name'],
'recordset_name': recordset.name,
'record_id': record_id,
'tenant_id': domain['tenant_id']
'tenant_id': domain.tenant_id
}
policy.check('diagnostics_sync_record', context, target)
@ -1279,7 +1282,8 @@ class Service(service.Service):
'tenant_id': tenant_id
}
zone = self.create_domain(elevated_context, zone_values)
zone = self.create_domain(
elevated_context, objects.Domain(**zone_values))
record_name = self.network_api.address_name(fip['address'])
@ -1309,12 +1313,13 @@ class Service(service.Service):
}
recordset = self.create_recordset(
elevated_context, zone['id'], recordset_values)
elevated_context,
zone['id'],
objects.RecordSet(**recordset_values))
record_values = {
'data': values['ptrdname'],
'description': values['description'],
'type': 'PTR',
'managed': True,
'managed_extra': fip['address'],
'managed_resource_id': floatingip_id,
@ -1324,7 +1329,10 @@ class Service(service.Service):
}
record = self.create_record(
elevated_context, zone['id'], recordset['id'], record_values)
elevated_context,
zone['id'],
recordset['id'],
objects.Record(**record_values))
mangled = self._format_floatingips(
context, {(region, floatingip_id): (fip, record)},
@ -1374,15 +1382,16 @@ class Service(service.Service):
context, region, floatingip_id, values)
# Blacklisted Domains
def create_blacklist(self, context, values):
def create_blacklist(self, context, blacklist):
policy.check('create_blacklist', context)
with self.storage_api.create_blacklist(context, values) as blacklist:
with self.storage_api.create_blacklist(context, blacklist) as \
created_blacklist:
pass # NOTE: No other systems need updating
self.notifier.info(context, 'dns.blacklist.create', blacklist)
self.notifier.info(context, 'dns.blacklist.create', created_blacklist)
return blacklist
return created_blacklist
def get_blacklist(self, context, blacklist_id):
policy.check('get_blacklist', context)

13
designate/notification_handler/base.py
View File

@ -20,6 +20,8 @@ from designate import exceptions
from designate.openstack.common import log as logging
from designate.central import rpcapi as central_rpcapi
from designate.context import DesignateContext
from designate.objects import Record
from designate.objects import RecordSet
from designate.plugin import ExtensionPlugin
@ -85,11 +87,13 @@ class NotificationHandler(ExtensionPlugin):
'type': type,
})
except exceptions.RecordSetNotFound:
recordset = self.central_api.create_recordset(context, domain_id, {
values = {
'name': name,
'type': type,
'ttl': ttl,
})
}
recordset = self.central_api.create_recordset(
context, domain_id, RecordSet(**values))
return recordset
@ -147,9 +151,10 @@ class BaseAddressHandler(NotificationHandler):
LOG.debug('Creating record in %s / %s with values %r',
domain['id'], recordset['id'], record_values)
self.central_api.create_record(context, domain['id'],
self.central_api.create_record(context,
domain['id'],
recordset['id'],
record_values)
Record(**record_values))
def _delete(self, managed=True, resource_id=None, resource_type='instance',
criterion={}):

5
designate/objects/record.py
View File

@ -38,8 +38,9 @@ class Record(BaseObject):
def __init__(self, **kwargs):
self.FIELDS = self.RECORD_FIELDS + self.RRDATA_FIELDS
super(Record, self).__init__(**kwargs)
self.from_text()
self.to_text()
if len(self.RRDATA_FIELDS) > 0:
self.from_text()
self.to_text()
def from_text(self):
"""

59
designate/storage/api.py
View File

@ -115,18 +115,18 @@ class StorageAPI(object):
self.storage.commit()
@contextlib.contextmanager
def create_server(self, context, values):
def create_server(self, context, server):
"""
Create a Server.
:param context: RPC Context.
:param values: Values to create the new Domain from.
:param server: Server object with the values to be created.
"""
self.storage.begin()
try:
server = self.storage.create_server(context, values)
yield server
created_server = self.storage.create_server(context, server)
yield created_server
except Exception:
with excutils.save_and_reraise_exception():
self.storage.rollback()
@ -202,18 +202,18 @@ class StorageAPI(object):
self.storage.commit()
@contextlib.contextmanager
def create_tld(self, context, values):
def create_tld(self, context, tld):
"""
Create a TLD.
:param context: RPC Context.
:param values: Values to create the new TLD from.
:param tld: Tld object with the values to be created.
"""
self.storage.begin()
try:
tld = self.storage.create_tld(context, values)
yield tld
created_tld = self.storage.create_tld(context, tld)
yield created_tld
except Exception:
with excutils.save_and_reraise_exception():
self.storage.rollback()
@ -289,17 +289,18 @@ class StorageAPI(object):
self.storage.commit()
@contextlib.contextmanager
def create_tsigkey(self, context, values):
def create_tsigkey(self, context, tsigkey):
"""
Create a TSIG Key.
:param context: RPC Context.
:param tsigkey: TsigKey object with the values to be created.
"""
self.storage.begin()
try:
tsigkey = self.storage.create_tsigkey(context, values)
yield tsigkey
created_tsigkey = self.storage.create_tsigkey(context, tsigkey)
yield created_tsigkey
except Exception:
with excutils.save_and_reraise_exception():
self.storage.rollback()
@ -400,18 +401,18 @@ class StorageAPI(object):
return self.storage.count_tenants(context)
@contextlib.contextmanager
def create_domain(self, context, values):
def create_domain(self, context, domain):
"""
Create a new Domain.
:param context: RPC Context.
:param values: Values to create the new Domain from.
:param domain: Domain object with the values to be created.
"""
self.storage.begin()
try:
domain = self.storage.create_domain(context, values)
yield domain
created_domain = self.storage.create_domain(context, domain)
yield created_domain
except Exception:
with excutils.save_and_reraise_exception():
self.storage.rollback()
@ -496,20 +497,20 @@ class StorageAPI(object):
return self.storage.count_domains(context, criterion)
@contextlib.contextmanager
def create_recordset(self, context, domain_id, values):
def create_recordset(self, context, domain_id, recordset):
"""
Create a recordset on a given Domain ID
:param context: RPC Context.
:param domain_id: Domain ID to create the recordset in.
:param values: Values to create the new RecordSet from.
:param recordset: RecordSet object with the values to be created.
"""
self.storage.begin()
try:
recordset = self.storage.create_recordset(
context, domain_id, values)
yield recordset
created_recordset = self.storage.create_recordset(
context, domain_id, recordset)
yield created_recordset
except Exception:
with excutils.save_and_reraise_exception():
self.storage.rollback()
@ -594,7 +595,7 @@ class StorageAPI(object):
return self.storage.count_recordsets(context, criterion)
@contextlib.contextmanager
def create_record(self, context, domain_id, recordset_id, values):
def create_record(self, context, domain_id, recordset_id, record):
"""
Create a record on a given Domain ID
@ -602,13 +603,14 @@ class StorageAPI(object):
:param domain_id: Domain ID to create the record in.
:param recordset_id: RecordSet ID to create the record in.
:param values: Values to create the new Record from.
:param record: Record object with the values to be created.
"""
self.storage.begin()
try:
record = self.storage.create_record(
context, domain_id, recordset_id, values)
yield record
created_record = self.storage.create_record(
context, domain_id, recordset_id, record)
yield created_record
except Exception:
with excutils.save_and_reraise_exception():
self.storage.rollback()
@ -692,18 +694,19 @@ class StorageAPI(object):
return self.storage.count_records(context, criterion)
@contextlib.contextmanager
def create_blacklist(self, context, values):
def create_blacklist(self, context, blacklist):
"""
Create a new Blacklisted Domain.
:param context: RPC Context.
:param values: Values to create the new Blacklist from.
:param blacklist: Blacklist object with the values to be created.
"""
self.storage.begin()
try:
blacklist = self.storage.create_blacklist(context, values)
yield blacklist
created_blacklist = self.storage.create_blacklist(
context, blacklist)
yield created_blacklist
except Exception:
with excutils.save_and_reraise_exception():
self.storage.rollback()

29
designate/storage/base.py
View File

@ -87,12 +87,12 @@ class Storage(DriverPlugin):
"""
@abc.abstractmethod
def create_server(self, context, values):
def create_server(self, context, server):
"""
Create a Server.
:param context: RPC Context.
:param values: Values to create the new Domain from.
:param server: Server object with the values to be created.
"""
@abc.abstractmethod
@ -140,12 +140,12 @@ class Storage(DriverPlugin):
"""
@abc.abstractmethod
def create_tld(self, context, values):
def create_tld(self, context, tld):
"""
Create a TLD.
:param context: RPC Context.
:param values: Values to create the new TLD from.
:param tld: Tld object with the values to be created.
"""
@abc.abstractmethod
@ -208,11 +208,12 @@ class Storage(DriverPlugin):
"""
@abc.abstractmethod
def create_tsigkey(self, context, values):
def create_tsigkey(self, context, tsigkey):
"""
Create a TSIG Key.
:param context: RPC Context.
:param tsigkey: TsigKey object with the values to be created.
"""
@abc.abstractmethod
@ -285,12 +286,12 @@ class Storage(DriverPlugin):
"""
@abc.abstractmethod
def create_domain(self, context, values):
def create_domain(self, context, domain):
"""
Create a new Domain.
:param context: RPC Context.
:param values: Values to create the new Domain from.
:param domain: Domain object with the values to be created.
"""
@abc.abstractmethod
@ -356,13 +357,13 @@ class Storage(DriverPlugin):
"""
@abc.abstractmethod
def create_recordset(self, context, domain_id, values):
def create_recordset(self, context, domain_id, recordset):
"""
Create a recordset on a given Domain ID
:param context: RPC Context.
:param domain_id: Domain ID to create the recordset in.
:param values: Values to create the new RecordSet from.
:param recordset: RecordSet object with the values to be created.
"""
@abc.abstractmethod
@ -428,15 +429,15 @@ class Storage(DriverPlugin):
"""
@abc.abstractmethod
def create_record(self, context, domain_id, recordset_id, values):
def create_record(self, context, domain_id, recordset_id, record):
"""
Create a record on a given Domain ID
:param context: RPC Context.
:param domain_id: Domain ID to create the record in.
:param recordset_id: RecordSet ID to create the record in.
:param values: Values to create the new Record from.
"""
:param record: Record object with the values to be created.
"""
@abc.abstractmethod
def get_record(self, context, record_id):
@ -500,12 +501,12 @@ class Storage(DriverPlugin):
"""
@abc.abstractmethod
def create_blacklist(self, context, values):
def create_blacklist(self, context, blacklist):
"""
Create a Blacklist.
:param context: RPC Context.
:param values: Values to create the new Blacklist from.
:param blacklist: Blacklist object with the values to be created.
"""
@abc.abstractmethod

80
designate/storage/impl_sqlalchemy/__init__.py
View File

@ -228,17 +228,17 @@ class SQLAlchemyStorage(base.Storage):
except exceptions.NotFound:
raise exceptions.ServerNotFound()
def create_server(self, context, values):
server = models.Server()
def create_server(self, context, server):
storage_server = models.Server()
server.update(values)
storage_server.update(server)
try:
server.save(self.session)
storage_server.save(self.session)
except exceptions.Duplicate:
raise exceptions.DuplicateServer()
return objects.Server.from_sqla(server)
return objects.Server.from_sqla(storage_server)
def find_servers(self, context, criterion=None,
marker=None, limit=None, sort_key=None, sort_dir=None):
@ -280,16 +280,16 @@ class SQLAlchemyStorage(base.Storage):
except exceptions.NotFound:
raise exceptions.TLDNotFound()
def create_tld(self, context, values):
tld = models.Tld()
tld.update(values)
def create_tld(self, context, tld):
storage_tld = models.Tld()
storage_tld.update(tld)
try:
tld.save(self.session)
storage_tld.save(self.session)
except exceptions.Duplicate:
raise exceptions.DuplicateTLD()
return objects.Tld.from_sqla(tld)
return objects.Tld.from_sqla(storage_tld)
def find_tlds(self, context, criterion=None,
marker=None, limit=None, sort_key=None, sort_dir=None):
@ -332,17 +332,17 @@ class SQLAlchemyStorage(base.Storage):
except exceptions.NotFound:
raise exceptions.TsigKeyNotFound()
def create_tsigkey(self, context, values):
tsigkey = models.TsigKey()
def create_tsigkey(self, context, tsigkey):
storage_tsigkey = models.TsigKey()
tsigkey.update(values)
storage_tsigkey.update(tsigkey)
try:
tsigkey.save(self.session)
storage_tsigkey.save(self.session)
except exceptions.Duplicate:
raise exceptions.DuplicateTsigKey()
return objects.TsigKey.from_sqla(tsigkey)
return objects.TsigKey.from_sqla(storage_tsigkey)
def find_tsigkeys(self, context, criterion=None,
marker=None, limit=None, sort_key=None, sort_dir=None):
@ -425,17 +425,17 @@ class SQLAlchemyStorage(base.Storage):
except exceptions.NotFound:
raise exceptions.DomainNotFound()
def create_domain(self, context, values):
domain = models.Domain()
def create_domain(self, context, domain):
storage_domain = models.Domain()
domain.update(values)
storage_domain.update(domain)
try:
domain.save(self.session)
storage_domain.save(self.session)
except exceptions.Duplicate:
raise exceptions.DuplicateDomain()
return objects.Domain.from_sqla(domain)
return objects.Domain.from_sqla(storage_domain)
def get_domain(self, context, domain_id):
domain = self._find_domains(context, {'id': domain_id}, one=True)
@ -492,22 +492,22 @@ class SQLAlchemyStorage(base.Storage):
except exceptions.NotFound:
raise exceptions.RecordSetNotFound()
def create_recordset(self, context, domain_id, values):
def create_recordset(self, context, domain_id, recordset):
# Fetch the domain as we need the tenant_id
domain = self._find_domains(context, {'id': domain_id}, one=True)
recordset = models.RecordSet()
storage_recordset = models.RecordSet()
recordset.update(values)
recordset.tenant_id = domain['tenant_id']
recordset.domain_id = domain_id
storage_recordset.update(recordset)
storage_recordset.tenant_id = domain['tenant_id']
storage_recordset.domain_id = domain_id
try:
recordset.save(self.session)
storage_recordset.save(self.session)
except exceptions.Duplicate:
raise exceptions.DuplicateRecordSet()
return objects.RecordSet.from_sqla(recordset)
return objects.RecordSet.from_sqla(storage_recordset)
def get_recordset(self, context, recordset_id):
recordset = self._find_recordsets(context, {'id': recordset_id},
@ -593,24 +593,24 @@ class SQLAlchemyStorage(base.Storage):
else:
raise TypeError("Unknown recordset type - %s" % recordset.type)
def create_record(self, context, domain_id, recordset_id, values):
def create_record(self, context, domain_id, recordset_id, record):
# Fetch the domain as we need the tenant_id
domain = self._find_domains(context, {'id': domain_id}, one=True)
# Create and populate the new Record model
record = models.Record()
record.update(values)
record.tenant_id = domain['tenant_id']
record.domain_id = domain_id
record.recordset_id = recordset_id
storage_record = models.Record()
storage_record.update(record)
storage_record.tenant_id = domain['tenant_id']
storage_record.domain_id = domain_id
storage_record.recordset_id = recordset_id
try:
# Save the new Record model
record.save(self.session)
storage_record.save(self.session)
except exceptions.Duplicate:
raise exceptions.DuplicateRecord()
return self._get_record_object(context, record)
return self._get_record_object(context, storage_record)
def find_records(self, context, criterion=None,
marker=None, limit=None, sort_key=None, sort_dir=None):
@ -666,17 +666,17 @@ class SQLAlchemyStorage(base.Storage):
except exceptions.NotFound:
raise exceptions.BlacklistNotFound()
def create_blacklist(self, context, values):
blacklist = models.Blacklists()
def create_blacklist(self, context, blacklist):
storage_blacklist = models.Blacklists()
blacklist.update(values)
storage_blacklist.update(blacklist)
try:
blacklist.save(self.session)
storage_blacklist.save(self.session)
except exceptions.Duplicate:
raise exceptions.DuplicateBlacklist()
return objects.Blacklist.from_sqla(blacklist)
return objects.Blacklist.from_sqla(storage_blacklist)
def find_blacklists(self, context, criterion=None,
marker=None, limit=None, sort_key=None, sort_dir=None):

34
designate/tests/__init__.py
View File

@ -40,6 +40,7 @@ from designate.tests import resources
from designate import exceptions
from designate.network_api import fake as fake_network_api
from designate import network_api
from designate import objects
# NOTE: If eventlet isn't patched and there's a exc tests block
import eventlet
@ -428,21 +429,24 @@ class TestCase(test.BaseTestCase):
fixture = kwargs.pop('fixture', 0)
values = self.get_server_fixture(fixture=fixture, values=kwargs)
return self.central_service.create_server(context, values=values)
return self.central_service.create_server(
context, server=objects.Server(**values))
def create_tld(self, **kwargs):
context = kwargs.pop('context', self.admin_context)
fixture = kwargs.pop('fixture', 0)
values = self.get_tld_fixture(fixture=fixture, values=kwargs)
return self.central_service.create_tld(context, values=values)
tld = objects.Tld(**values)
return self.central_service.create_tld(context, tld=tld)
def create_default_tld(self, **kwargs):
context = kwargs.pop('context', self.admin_context)
fixture = kwargs.pop('fixture', 0)
values = self.get_default_tld_fixture(fixture=fixture, values=kwargs)
return self.central_service.create_tld(context, values=values)
tld = objects.Tld(**values)
return self.central_service.create_tld(context, tld=tld)
def create_default_tlds(self):
for index in range(len(self.default_tld_fixtures)):
@ -456,7 +460,8 @@ class TestCase(test.BaseTestCase):
fixture = kwargs.pop('fixture', 0)
values = self.get_tsigkey_fixture(fixture=fixture, values=kwargs)
return self.central_service.create_tsigkey(context, values=values)
return self.central_service.create_tsigkey(
context, tsigkey=objects.TsigKey(**values))
def create_domain(self, **kwargs):
context = kwargs.pop('context', self.admin_context)
@ -473,7 +478,8 @@ class TestCase(test.BaseTestCase):
if 'tenant_id' not in values:
values['tenant_id'] = context.tenant
return self.central_service.create_domain(context, values=values)
domain = objects.Domain(**values)
return self.central_service.create_domain(context, domain=domain)
def create_recordset(self, domain, type='A', **kwargs):
context = kwargs.pop('context', self.admin_context)
@ -482,9 +488,8 @@ class TestCase(test.BaseTestCase):
values = self.get_recordset_fixture(domain['name'], type=type,
fixture=fixture,
values=kwargs)
return self.central_service.create_recordset(context,
domain['id'],
values=values)
return self.central_service.create_recordset(
context, domain['id'], recordset=objects.RecordSet(**values))
def create_record(self, domain, recordset, **kwargs):
context = kwargs.pop('context', self.admin_context)
@ -492,17 +497,20 @@ class TestCase(test.BaseTestCase):
values = self.get_record_fixture(recordset['type'], fixture=fixture,
values=kwargs)
return self.central_service.create_record(context,
domain['id'],
recordset['id'],
values=values)
return self.central_service.create_record(
context,
domain['id'],
recordset['id'],
record=objects.Record(**values))
def create_blacklist(self, **kwargs):
context = kwargs.pop('context', self.admin_context)
fixture = kwargs.pop('fixture', 0)
values = self.get_blacklist_fixture(fixture=fixture, values=kwargs)
return self.central_service.create_blacklist(context, values=values)
blacklist = objects.Blacklist(**values)
return self.central_service.create_blacklist(
context, blacklist=blacklist)
def _ensure_interface(self, interface, implementation):
for name in interface.__abstractmethods__:

4
designate/tests/test_backend/test_multi.py
View File

@ -17,6 +17,7 @@ import mock
from mock import call
from mock import MagicMock
from designate import exceptions
from designate import objects
from designate import tests
from designate.tests.test_backend import BackendTestMixin
@ -106,7 +107,8 @@ class MultiBackendTestCase(tests.TestCase, BackendTestMixin):
# recreate it if something goes wrong, create the domain first
self.backend.central_service.create_server(
self.get_admin_context(), self.get_server_fixture())
self.backend.central_service.create_domain(context, domain)
self.backend.central_service.create_domain(
context, objects.Domain(**domain))
self.backend.master.delete_domain = MagicMock(
side_effect=exceptions.Backend)
self.assertRaises(exceptions.Backend, self.backend.delete_domain,

65
designate/tests/test_central/test_service.py
View File

@ -18,6 +18,7 @@ import random
import testtools
from designate.openstack.common import log as logging
from designate import exceptions
from designate import objects
from designate.tests.test_central import CentralTestCase
LOG = logging.getLogger(__name__)
@ -168,7 +169,7 @@ class CentralServiceTest(CentralTestCase):
# Create a server
server = self.central_service.create_server(
self.admin_context, values=values)
self.admin_context, server=objects.Server(**values))
# Ensure all values have been set correctly
self.assertIsNotNone(server['id'])
@ -332,7 +333,7 @@ class CentralServiceTest(CentralTestCase):
# Create a tsigkey
tsigkey = self.central_service.create_tsigkey(
self.admin_context, values=values)
self.admin_context, tsigkey=objects.TsigKey(**values))
# Ensure all values have been set correctly
self.assertIsNotNone(tsigkey['id'])
@ -440,7 +441,7 @@ class CentralServiceTest(CentralTestCase):
# Create a domain
domain = self.central_service.create_domain(
self.admin_context, values=values)
self.admin_context, domain=objects.Domain(**values))
# Ensure all values have been set correctly
self.assertIsNotNone(domain['id'])
@ -477,8 +478,9 @@ class CentralServiceTest(CentralTestCase):
name='xn--3e0b707e'
)
tld = objects.Tld(**values)
# Create the appropriate TLD
self.central_service.create_tld(self.admin_context, values=values)
self.central_service.create_tld(self.admin_context, tld=tld)
# Test creation of a domain in 한국 (kr)
values = dict(
@ -505,7 +507,7 @@ class CentralServiceTest(CentralTestCase):
# Create the subdomain
domain = self.central_service.create_domain(
self.admin_context, values=values)
self.admin_context, domain=objects.Domain(**values))
# Ensure all values have been set correctly
self.assertIsNotNone(domain['id'])
@ -531,7 +533,8 @@ class CentralServiceTest(CentralTestCase):
# Attempt to create the subdomain
with testtools.ExpectedException(exceptions.Forbidden):
self.central_service.create_domain(context, values=values)
self.central_service.create_domain(
context, domain=objects.Domain(**values))
def test_create_blacklisted_domain_success(self):
# Create blacklisted zone using default values
@ -550,7 +553,7 @@ class CentralServiceTest(CentralTestCase):
# Create a zone that is blacklisted
domain = self.central_service.create_domain(
self.admin_context, values=values)
self.admin_context, domain=objects.Domain(**values))
# Ensure all values have been set correctly
self.assertIsNotNone(domain['id'])
@ -571,14 +574,14 @@ class CentralServiceTest(CentralTestCase):
with testtools.ExpectedException(exceptions.InvalidDomainName):
# Create a domain
self.central_service.create_domain(
self.admin_context, values=values)
self.admin_context, domain=objects.Domain(**values))
def _test_create_domain_fail(self, values, exception):
with testtools.ExpectedException(exception):
# Create an invalid domain
self.central_service.create_domain(
self.admin_context, values=values)
self.admin_context, domain=objects.Domain(**values))
def test_create_domain_invalid_tld_fail(self):
# Create a server
@ -593,7 +596,8 @@ class CentralServiceTest(CentralTestCase):
)
# Create a valid domain
self.central_service.create_domain(self.admin_context, values=values)
self.central_service.create_domain(
self.admin_context, domain=objects.Domain(**values))
values = dict(
name='example.net.',
@ -604,7 +608,7 @@ class CentralServiceTest(CentralTestCase):
with testtools.ExpectedException(exceptions.InvalidDomainName):
# Create an invalid domain
self.central_service.create_domain(
self.admin_context, values=values)
self.admin_context, domain=objects.Domain(**values))
def test_create_domain_invalid_ttl_fail(self):
self.policy({'use_low_ttl': '!'})
@ -619,7 +623,8 @@ class CentralServiceTest(CentralTestCase):
self.create_server()
with testtools.ExpectedException(exceptions.InvalidTTL):
self.central_service.create_domain(context, values=values)
self.central_service.create_domain(
context, domain=objects.Domain(**values))
def test_create_domain_no_min_ttl(self):
self.policy({'use_low_ttl': '!'})
@ -633,7 +638,7 @@ class CentralServiceTest(CentralTestCase):
#Create domain with random TTL
domain = self.central_service.create_domain(
self.admin_context, values=values)
self.admin_context, domain=objects.Domain(**values))
# Ensure all values have been set correctly
self.assertEqual(domain['ttl'], values['ttl'])
@ -900,7 +905,9 @@ class CentralServiceTest(CentralTestCase):
# Create a recordset
recordset = self.central_service.create_recordset(
self.admin_context, domain['id'], values=values)
self.admin_context,
domain['id'],
recordset=objects.RecordSet(**values))
# Ensure all values have been set correctly
self.assertIsNotNone(recordset['id'])
@ -928,7 +935,9 @@ class CentralServiceTest(CentralTestCase):
# Attempt to create a CNAME record at the apex
with testtools.ExpectedException(exceptions.InvalidRecordSetLocation):
self.central_service.create_recordset(
self.admin_context, domain['id'], values=values)
self.admin_context,
domain['id'],
recordset=objects.RecordSet(**values))
def test_create_invalid_recordset_location_cname_sharing(self):
domain = self.create_domain()
@ -942,7 +951,9 @@ class CentralServiceTest(CentralTestCase):
# Attempt to create a CNAME record alongside another record
with testtools.ExpectedException(exceptions.InvalidRecordSetLocation):
self.central_service.create_recordset(
self.admin_context, domain['id'], values=values)
self.admin_context,
domain['id'],
recordset=objects.RecordSet(**values))
def test_create_invalid_recordset_location_wrong_domain(self):
domain = self.create_domain()
@ -956,7 +967,9 @@ class CentralServiceTest(CentralTestCase):
# Attempt to create a record in the incorrect domain
with testtools.ExpectedException(exceptions.InvalidRecordSetLocation):
self.central_service.create_recordset(
self.admin_context, domain['id'], values=values)
self.admin_context,
domain['id'],
recordset=objects.RecordSet(**values))
def test_create_invalid_recordset_ttl(self):
self.policy({'use_low_ttl': '!'})
@ -973,7 +986,9 @@ class CentralServiceTest(CentralTestCase):
# Attempt to create a A record under the TTL
with testtools.ExpectedException(exceptions.InvalidTTL):
self.central_service.create_recordset(
self.admin_context, domain['id'], values=values)
self.admin_context,
domain['id'],
recordset=objects.RecordSet(**values))
def test_create_recordset_no_min_ttl(self):
self.policy({'use_low_ttl': '!'})
@ -988,7 +1003,9 @@ class CentralServiceTest(CentralTestCase):
)
recordset = self.central_service.create_recordset(
self.admin_context, domain['id'], values=values)
self.admin_context,
domain['id'],
recordset=objects.RecordSet(**values))
self.assertEqual(recordset['ttl'], values['ttl'])
def test_get_recordset(self):
@ -1213,7 +1230,10 @@ class CentralServiceTest(CentralTestCase):
# Create a record
record = self.central_service.create_record(
self.admin_context, domain['id'], recordset['id'], values=values)
self.admin_context,
domain['id'],
recordset['id'],
record=objects.Record(**values))
# Ensure all values have been set correctly
self.assertIsNotNone(record['id'])
@ -1241,7 +1261,10 @@ class CentralServiceTest(CentralTestCase):
# Create a record
self.central_service.create_record(
self.admin_context, domain['id'], recordset['id'], values=values,
self.admin_context,
domain['id'],
recordset['id'],
record=objects.Record(**values),
increment_serial=False)
# Ensure the domains serial number was not updated

32
designate/tests/test_storage/__init__.py
View File

@ -17,6 +17,7 @@ import testtools
import uuid
from designate.openstack.common import log as logging
from designate import exceptions
from designate import objects
from designate.storage.base import Storage as StorageBase
LOG = logging.getLogger(__name__)
@ -39,14 +40,16 @@ class StorageTestCase(object):
context = context or self.admin_context
fixture = self.get_server_fixture(fixture, values)
return fixture, self.storage.create_server(context, fixture)
return fixture, self.storage.create_server(
context, objects.Server(**fixture))
def create_tsigkey(self, fixture=0, values=None, context=None):
values = values or {}
context = context or self.admin_context
fixture = self.get_tsigkey_fixture(fixture, values)
return fixture, self.storage.create_tsigkey(context, fixture)
return fixture, self.storage.create_tsigkey(
context, objects.TsigKey(**fixture))
def create_domain(self, fixture=0, values=None, context=None):
values = values or {}
@ -57,7 +60,8 @@ class StorageTestCase(object):
if 'tenant_id' not in fixture:
fixture['tenant_id'] = context.tenant
return fixture, self.storage.create_domain(context, fixture)
return fixture, self.storage.create_domain(
context, objects.Domain(**fixture))
def create_recordset(self, domain, type='A', fixture=0, values=None,
context=None):
@ -67,7 +71,7 @@ class StorageTestCase(object):
fixture = self.get_recordset_fixture(domain['name'], type, fixture,
values)
return fixture, self.storage.create_recordset(
context, domain['id'], fixture)
context, domain['id'], objects.RecordSet(**fixture))
def create_record(self, domain, recordset, fixture=0, values=None,
context=None):
@ -76,7 +80,7 @@ class StorageTestCase(object):
fixture = self.get_record_fixture(recordset['type'], fixture, values)
return fixture, self.storage.create_record(
context, domain['id'], recordset['id'], fixture)
context, domain['id'], recordset['id'], objects.Record(**fixture))
# Paging Tests
def _ensure_paging(self, data, method):
@ -296,7 +300,8 @@ class StorageTestCase(object):
'name': 'ns1.example.org.'
}
result = self.storage.create_server(self.admin_context, values=values)
result = self.storage.create_server(
self.admin_context, server=objects.Server(**values))
self.assertIsNotNone(result['id'])
self.assertIsNotNone(result['created_at'])
@ -409,7 +414,8 @@ class StorageTestCase(object):
def test_create_tsigkey(self):
values = self.get_tsigkey_fixture()
result = self.storage.create_tsigkey(self.admin_context, values=values)
result = self.storage.create_tsigkey(
self.admin_context, tsigkey=objects.TsigKey(**values))
self.assertIsNotNone(result['id'])
self.assertIsNotNone(result['created_at'])
@ -604,7 +610,8 @@ class StorageTestCase(object):
'email': 'example@example.net'
}
result = self.storage.create_domain(self.admin_context, values=values)
result = self.storage.create_domain(
self.admin_context, domain=objects.Domain(**values))
self.assertIsNotNone(result['id'])
self.assertIsNotNone(result['created_at'])
@ -821,9 +828,10 @@ class StorageTestCase(object):
'type': 'A'
}
result = self.storage.create_recordset(self.admin_context,
domain['id'],
values=values)
result = self.storage.create_recordset(
self.admin_context,
domain['id'],
recordset=objects.RecordSet(**values))
self.assertIsNotNone(result['id'])
self.assertIsNotNone(result['created_at'])
@ -1028,7 +1036,7 @@ class StorageTestCase(object):
result = self.storage.create_record(self.admin_context,
domain['id'],
recordset['id'],
values=values)
record=objects.Record(**values))
self.assertIsNotNone(result['id'])
self.assertIsNotNone(result['created_at'])