openstack/deb-designate
Code Issues Proposed changes

Combine Backend and PoolBackend

Browse Source 
As all backends must be PoolBackends, we combine the two classes and
removed the now dead code.

Change-Id: Iadbb91e10a93ff358be7f687a16e5f4b725c0de7
This commit is contained in:
Kiall Mac Innes 2015-03-22 14:03:42 +00:00
parent ea323cffa3
commit 6aa438d88d
5 changed files with 27 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
designate/backend/__init__.py
View File

@ -15,20 +15,20 @@
# under the License.
from oslo_log import log as logging
from designate.backend.base import PoolBackend
from designate.backend.base import Backend
LOG = logging.getLogger(__name__)
def get_backend(backend_driver, backend_options):
LOG.debug("Loading backend driver: %s" % backend_driver)
cls = PoolBackend.get_driver(backend_driver)
cls = Backend.get_driver(backend_driver)
return cls(backend_options)
def get_server_object(backend_driver, server_id):
LOG.debug("Loading backend driver: %s" % backend_driver)
cls = PoolBackend.get_driver(backend_driver)
cls = Backend.get_driver(backend_driver)
return cls.get_server_object(backend_driver, server_id)

179
designate/backend/base.py
View File

@ -19,8 +19,7 @@ import copy
from oslo.config import cfg
from oslo_log import log as logging
from designate.i18n import _LW
from designate import exceptions
from designate.i18n import _LI
from designate.context import DesignateContext
from designate.plugin import DriverPlugin
from designate import objects
@ -34,125 +33,20 @@ class Backend(DriverPlugin):
__plugin_type__ = 'backend'
__plugin_ns__ = 'designate.backend'
def __init__(self, central_service):
def __init__(self, backend_options):
super(Backend, self).__init__()
self.central_service = central_service
self.backend_options = backend_options
self.admin_context = DesignateContext.get_admin_context()
self.admin_context.all_tenants = True
def start(self):
pass
LOG.info(_LI('Starting %s backend'), self.get_canonical_name())
def stop(self):
pass
LOG.info(_LI('Stopped %s backend'), self.get_canonical_name())
def create_tsigkey(self, context, tsigkey):
"""Create a TSIG Key"""
raise exceptions.NotImplemented(
'TSIG is not supported by this backend')
def update_tsigkey(self, context, tsigkey):
"""Update a TSIG Key"""
raise exceptions.NotImplemented(
'TSIG is not supported by this backend')
def delete_tsigkey(self, context, tsigkey):
"""Delete a TSIG Key"""
raise exceptions.NotImplemented(
'TSIG is not supported by this backend')
@abc.abstractmethod
def create_domain(self, context, domain):
"""Create a DNS domain"""
@abc.abstractmethod
def update_domain(self, context, domain):
"""Update a DNS domain"""
@abc.abstractmethod
def delete_domain(self, context, domain):
"""Delete a DNS domain"""
@abc.abstractmethod
def create_recordset(self, context, domain, recordset):
"""Create a DNS recordset"""
@abc.abstractmethod
def update_recordset(self, context, domain, recordset):
"""Update a DNS recordset"""
@abc.abstractmethod
def delete_recordset(self, context, domain, recordset):
"""Delete a DNS recordset"""
@abc.abstractmethod
def create_record(self, context, domain, recordset, record):
"""Create a DNS record"""
@abc.abstractmethod
def update_record(self, context, domain, recordset, record):
"""Update a DNS record"""
@abc.abstractmethod
def delete_record(self, context, domain, recordset, record):
"""Delete a DNS record"""
def sync_domain(self, context, domain, rdata):
"""
Re-Sync a DNS domain
This is the default, naive, domain synchronization implementation.
"""
# First up, delete the domain from the backend.
try:
self.delete_domain(context, domain)
except exceptions.DomainNotFound as e:
# NOTE(Kiall): This means a domain was missing from the backend.
# Good thing we're doing a sync!
LOG.warn(_LW("Failed to delete domain '%(domain)s' during sync. "
"Message: %(message)s") %
{'domain': domain['id'], 'message': str(e)})
# Next, re-create the domain in the backend.
self.create_domain(context, domain)
# Finally, re-create the records for the domain.
for recordset, records in rdata:
# Re-create the record in the backend.
self.create_recordset(context, domain, recordset)
for record in records:
self.create_record(context, domain, recordset, record)
def sync_record(self, context, domain, recordset, record):
"""
Re-Sync a DNS record.
This is the default, naive, record synchronization implementation.
"""
# First up, delete the record from the backend.
try:
self.delete_record(context, domain, recordset, record)
except exceptions.RecordNotFound as e:
# NOTE(Kiall): This means a record was missing from the backend.
# Good thing we're doing a sync!
LOG.warn(_LW("Failed to delete record '%(record)s' "
"in domain '%(domain)s' during sync. "
"Message: %(message)s") %
{'record': record['id'], 'domain': domain['id'],
'message': str(e)})
# Finally, re-create the record in the backend.
self.create_record(context, domain, recordset, record)
def ping(self, context):
"""Ping the Backend service"""
return {
'status': None
}
class PoolBackend(Backend):
# Config Methods
@classmethod
def get_cfg_opts(cls):
group = cfg.OptGroup(
@ -217,10 +111,15 @@ class PoolBackend(Backend):
def _get_server_cfg_opts(cls):
return []
def __init__(self, backend_options):
super(PoolBackend, self).__init__(None)
self.backend_options = backend_options
def get_backend_option(self, key):
"""
Get the backend option value using the backend option key.
"""
for backend_option in self.backend_options:
if backend_option['key'] == key:
return backend_option['value']
# Pool Mgr Object Creation
@classmethod
def _create_server_object(cls, backend, server_id, backend_options,
server_section_name):
@ -286,23 +185,7 @@ class PoolBackend(Backend):
return cls._create_server_object(
backend, server_id, backend_options, server_section_name)
def get_backend_option(self, key):
"""
Get the backend option value using the backend option key.
"""
for backend_option in self.backend_options:
if backend_option['key'] == key:
return backend_option['value']
def create_tsigkey(self, context, tsigkey):
pass
def update_tsigkey(self, context, tsigkey):
pass
def delete_tsigkey(self, context, tsigkey):
pass
# Core Backend Interface
@abc.abstractmethod
def create_domain(self, context, domain):
"""
@ -324,29 +207,9 @@ class PoolBackend(Backend):
:param domain: the DNS domain.
"""
def create_recordset(self, context, domain, recordset):
pass
def update_recordset(self, context, domain, recordset):
pass
def delete_recordset(self, context, domain, recordset):
pass
def create_record(self, context, domain, recordset, record):
pass
def update_record(self, context, domain, recordset, record):
pass
def delete_record(self, context, domain, recordset, record):
pass
def sync_domain(self, context, domain, records):
pass
def sync_record(self, context, domain, record):
pass
def ping(self, context):
pass
"""Ping the Backend service"""
return {
'status': None
}

2
designate/backend/impl_bind9.py
View File

@ -27,7 +27,7 @@ LOG = logging.getLogger(__name__)
DEFAULT_MASTER_PORT = 5354
class Bind9Backend(base.PoolBackend):
class Bind9Backend(base.Backend):
__plugin_name__ = 'bind9'
@classmethod

2
designate/backend/impl_fake.py
View File

@ -22,7 +22,7 @@ from designate.backend import base
LOG = logging.getLogger(__name__)
class FakeBackend(base.PoolBackend):
class FakeBackend(base.Backend):
__plugin_name__ = 'fake'
def create_domain(self, context, domain):

2
designate/backend/impl_powerdns/__init__.py
View File

@ -34,7 +34,7 @@ def _map_col(keys, col):
return dict([(keys[i], col[i]) for i in range(len(keys))])
class PowerDNSBackend(base.PoolBackend):
class PowerDNSBackend(base.Backend):
__plugin_name__ = 'powerdns'
@classmethod