openstack
/
designate
Code Issues Proposed changes

Merge "Rename _retrieve_from_cache to _retrieve_statuses"

This commit is contained in:
Jenkins 2015-03-10 10:50:21 +00:00 committed by Gerrit Code Review
parent eefeb1414e 89495a3471
commit dfe98d7367
4 changed files with 182 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
designate/pool_manager/service.py
View File

@ -369,8 +369,8 @@ class Service(service.RPCService, service.Service):
domains = self._get_failed_domains(context, CREATE_ACTION)
for domain in domains:
create_statuses = self._retrieve_from_cache(
context, domain, CREATE_ACTION, check_server=True)
create_statuses = self._retrieve_statuses(
context, domain, CREATE_ACTION)
for create_status in create_statuses:
server_backend = self._get_server_backend(
create_status.server_id)
@ -417,8 +417,8 @@ class Service(service.RPCService, service.Service):
domains = self._get_failed_domains(context, DELETE_ACTION)
for domain in domains:
delete_statuses = self._retrieve_from_cache(
context, domain, DELETE_ACTION, check_server=True)
delete_statuses = self._retrieve_statuses(
context, domain, DELETE_ACTION)
for delete_status in delete_statuses:
server_backend = self._get_server_backend(
delete_status.server_id)
@ -448,8 +448,8 @@ class Service(service.RPCService, service.Service):
domains = self._get_failed_domains(context, UPDATE_ACTION)
for domain in domains:
update_statuses = self._retrieve_from_cache(
context, domain, UPDATE_ACTION, check_server=True)
update_statuses = self._retrieve_statuses(
context, domain, UPDATE_ACTION)
for update_status in update_statuses:
server_backend = self._get_server_backend(
update_status.server_id)
@ -497,7 +497,7 @@ class Service(service.RPCService, service.Service):
def _is_success_consensus(self, context, domain, action, threshold=None):
success_count = 0
pool_manager_statuses = self._retrieve_from_cache(
pool_manager_statuses = self._retrieve_statuses(
context, domain, action)
for pool_manager_status in pool_manager_statuses:
if pool_manager_status.status == SUCCESS_STATUS:
@ -520,7 +520,7 @@ class Service(service.RPCService, service.Service):
def _get_consensus_serial(self, context, domain):
consensus_serial = 0
update_statuses = self._retrieve_from_cache(
update_statuses = self._retrieve_statuses(
context, domain, UPDATE_ACTION)
for serial in self._get_serials_descending(update_statuses):
serial_count = 0
@ -535,7 +535,7 @@ class Service(service.RPCService, service.Service):
def _get_error_serial(self, context, domain, consensus_serial):
error_serial = 0
if not self._is_success_consensus(context, domain, UPDATE_ACTION):
update_statuses = self._retrieve_from_cache(
update_statuses = self._retrieve_statuses(
context, domain, UPDATE_ACTION)
for serial in self._get_serials_ascending(update_statuses):
if serial > consensus_serial:
@ -578,15 +578,19 @@ class Service(service.RPCService, service.Service):
LOG.debug('Cleared cache for domain %s with action %s.' %
(domain.name, action))
def _is_in_cache(self, context, domain, action):
return len(self._retrieve_from_cache(
context, domain=domain, action=action)) > 0
def _retrieve_from_mdns(self, context, server, domain, action):
(status, actual_serial, retries) = \
self.mdns_api.get_serial_number(
context, domain, server, self.timeout, self.retry_interval,
self.max_retries, self.delay)
try:
(status, actual_serial, retries) = \
self.mdns_api.get_serial_number(
context, domain, server, self.timeout, self.retry_interval,
self.max_retries, self.delay)
except messaging.MessagingException as msg_ex:
LOG.debug('Could not retrieve status and serial for domain %s on '
'server %s with action %s from the server. %s:%s' %
(domain.name, self._get_destination(server), action,
type(msg_ex), str(msg_ex)))
return None
pool_manager_status = self._build_status_object(server, domain, action)
if status == NO_DOMAIN_STATUS:
if action == CREATE_ACTION:
@ -609,8 +613,7 @@ class Service(service.RPCService, service.Service):
return pool_manager_status
def _retrieve_from_cache(self, context, domain, action,
check_server=False):
def _retrieve_statuses(self, context, domain, action):
pool_manager_statuses = []
for server_backend in self.server_backends:
server = server_backend['server']
@ -626,13 +629,10 @@ class Service(service.RPCService, service.Service):
except exceptions.PoolManagerStatusNotFound:
LOG.debug('Cache miss! Did not retrieve status and serial '
'for domain %s on server %s with action %s from '
'the cache.' %
'the cache. Getting it from the server.' %
(domain.name, self._get_destination(server), action))
if check_server:
pool_manager_status = self._retrieve_from_mdns(
context, server, domain, action)
else:
pool_manager_status = None
pool_manager_status = self._retrieve_from_mdns(
context, server, domain, action)
if pool_manager_status is not None:
pool_manager_statuses.append(pool_manager_status)

77
designate/tests/test_pool_manager/test_service_memcache.py
View File

@ -13,6 +13,7 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo import messaging
from oslo.config import cfg
from mock import call
from mock import patch
@ -76,18 +77,20 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
}
return objects.Domain.from_dict(values)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(mdns_rpcapi.MdnsAPI, 'poll_for_serial_number')
@patch.object(mdns_rpcapi.MdnsAPI, 'notify_zone_changed')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_create_domain(
self, mock_update_status, mock_notify_zone_changed,
mock_poll_for_serial_number):
mock_poll_for_serial_number, mock_get_serial_number):
domain = self._build_domain('example.org.', 'CREATE', 'PENDING')
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(0, len(create_statuses))
@ -108,6 +111,14 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.server_backends[1]['server'], 30, 2, 3, 1)],
mock_poll_for_serial_number.call_args_list)
self.assertEqual(2, mock_get_serial_number.call_count)
self.assertEqual(
[call(self.admin_context, domain,
self.service.server_backends[0]['server'], 30, 2, 3, 1),
call(self.admin_context, domain,
self.service.server_backends[1]['server'], 30, 2, 3, 1)],
mock_get_serial_number.call_args_list)
self.assertEqual(False, mock_update_status.called)
@patch.object(impl_fake.FakeBackend, 'create_domain')
@ -124,7 +135,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(2, len(create_statuses))
self.assertEqual('ERROR', create_statuses[0].status)
@ -152,7 +163,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(2, len(create_statuses))
self.assertEqual('SUCCESS', create_statuses[0].status)
@ -188,7 +199,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(2, len(create_statuses))
self.assertEqual('SUCCESS', create_statuses[0].status)
@ -203,24 +214,28 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.assertEqual(False, mock_update_status.called)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain(self, mock_update_status):
def test_delete_domain(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'DELETE', 'PENDING')
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(0, len(delete_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'SUCCESS', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'delete_domain')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain_backend_both_failure(
self, mock_update_status, mock_delete_domain):
self, mock_update_status, mock_delete_domain, _):
domain = self._build_domain('example.org.', 'DELETE', 'PENDING')
@ -228,7 +243,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(2, len(delete_statuses))
self.assertEqual('ERROR', delete_statuses[0].status)
@ -237,10 +252,12 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'delete_domain')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain_backend_one_failure(
self, mock_update_status, mock_delete_domain):
self, mock_update_status, mock_delete_domain, _):
domain = self._build_domain('example.org.', 'DELETE', 'PENDING')
@ -248,7 +265,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(2, len(delete_statuses))
self.assertEqual('SUCCESS', delete_statuses[0].status)
@ -257,10 +274,12 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'delete_domain')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain_backend_one_failure_consensus(
self, mock_update_status, mock_delete_domain):
self, mock_update_status, mock_delete_domain, _):
self.service.stop()
self.config(
@ -274,7 +293,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(2, len(delete_statuses))
self.assertEqual('SUCCESS', delete_statuses[0].status)
@ -283,8 +302,10 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'SUCCESS', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status(self, mock_update_status):
def test_update_status(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'UPDATE', 'PENDING')
@ -292,7 +313,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(1, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)
@ -305,15 +326,17 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'SUCCESS', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status_both_failure(self, mock_update_status):
def test_update_status_both_failure(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'UPDATE', 'PENDING')
@ -321,7 +344,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(1, len(update_statuses))
self.assertEqual('ERROR', update_statuses[0].status)
@ -337,7 +360,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(2, len(update_statuses))
self.assertEqual('ERROR', update_statuses[0].status)
@ -351,8 +374,10 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
call(self.admin_context, domain.id, 'ERROR', 0)],
mock_update_status.call_args_list)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status_one_failure(self, mock_update_status):
def test_update_status_one_failure(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'UPDATE', 'PENDING')
@ -360,7 +385,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(1, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)
@ -373,7 +398,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(2, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)
@ -387,8 +412,10 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
call(self.admin_context, domain.id, 'ERROR', 0)],
mock_update_status.call_args_list)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status_one_failure_consensus(self, mock_update_status):
def test_update_status_one_failure_consensus(self, mock_update_status, _):
self.service.stop()
self.config(
@ -402,7 +429,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(1, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)
@ -418,7 +445,7 @@ class PoolManagerServiceMemcacheTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(2, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)

81
designate/tests/test_pool_manager/test_service_noop.py
View File

@ -13,6 +13,7 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo import messaging
from oslo.config import cfg
from mock import call
from mock import patch
@ -76,18 +77,20 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
}
return objects.Domain(**values)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(mdns_rpcapi.MdnsAPI, 'poll_for_serial_number')
@patch.object(mdns_rpcapi.MdnsAPI, 'notify_zone_changed')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_create_domain(
self, mock_update_status, mock_notify_zone_changed,
mock_poll_for_serial_number):
mock_poll_for_serial_number, _):
domain = self._build_domain('example.org.', 'CREATE', 'PENDING')
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(0, len(create_statuses))
@ -111,13 +114,15 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'create_domain')
@patch.object(mdns_rpcapi.MdnsAPI, 'poll_for_serial_number')
@patch.object(mdns_rpcapi.MdnsAPI, 'notify_zone_changed')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_create_domain_backend_both_failure(
self, mock_update_status, mock_notify_zone_changed,
mock_poll_for_serial_number, mock_create_domain):
mock_poll_for_serial_number, mock_create_domain, _):
domain = self._build_domain('example.org.', 'CREATE', 'PENDING')
@ -125,7 +130,7 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(0, len(create_statuses))
@ -137,13 +142,15 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'create_domain')
@patch.object(mdns_rpcapi.MdnsAPI, 'poll_for_serial_number')
@patch.object(mdns_rpcapi.MdnsAPI, 'notify_zone_changed')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_create_domain_backend_one_failure(
self, mock_update_status, mock_notify_zone_changed,
mock_poll_for_serial_number, mock_create_domain):
mock_poll_for_serial_number, mock_create_domain, _):
domain = self._build_domain('example.org.', 'CREATE', 'PENDING')
@ -151,7 +158,7 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(0, len(create_statuses))
@ -165,13 +172,15 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'create_domain')
@patch.object(mdns_rpcapi.MdnsAPI, 'poll_for_serial_number')
@patch.object(mdns_rpcapi.MdnsAPI, 'notify_zone_changed')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_create_domain_backend_one_failure_consensus(
self, mock_update_status, mock_notify_zone_changed,
mock_poll_for_serial_number, mock_create_domain):
mock_poll_for_serial_number, mock_create_domain, _):
self.service.stop()
self.config(
@ -185,7 +194,7 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(0, len(create_statuses))
@ -199,24 +208,28 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain(self, mock_update_status):
def test_delete_domain(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'DELETE', 'PENDING')
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(0, len(delete_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'delete_domain')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain_backend_both_failure(
self, mock_update_status, mock_delete_domain):
self, mock_update_status, mock_delete_domain, _):
domain = self._build_domain('example.org.', 'DELETE', 'PENDING')
@ -224,17 +237,19 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(0, len(delete_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'delete_domain')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain_backend_one_failure(
self, mock_update_status, mock_delete_domain):
self, mock_update_status, mock_delete_domain, _):
domain = self._build_domain('example.org.', 'DELETE', 'PENDING')
@ -242,17 +257,19 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(0, len(delete_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'delete_domain')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain_backend_one_failure_consensus(
self, mock_update_status, mock_delete_domain):
self, mock_update_status, mock_delete_domain, _):
self.service.stop()
self.config(
@ -266,15 +283,17 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(0, len(delete_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status(self, mock_update_status):
def test_update_status(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'UPDATE', 'PENDING')
@ -282,7 +301,7 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))
@ -293,15 +312,17 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))
# Ensure update_status was not called.
self.assertEqual(False, mock_update_status.called)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status_both_failure(self, mock_update_status):
def test_update_status_both_failure(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'UPDATE', 'PENDING')
@ -309,7 +330,7 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))
@ -323,15 +344,17 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', 0)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status_one_failure(self, mock_update_status):
def test_update_status_one_failure(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'UPDATE', 'PENDING')
@ -339,7 +362,7 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))
@ -350,15 +373,17 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', 0)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status_one_failure_consensus(self, mock_update_status):
def test_update_status_one_failure_consensus(self, mock_update_status, _):
self.service.stop()
self.config(
@ -372,7 +397,7 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))
@ -386,7 +411,7 @@ class PoolManagerServiceNoopTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))

77
designate/tests/test_pool_manager/test_service_sqlalchemy.py
View File

@ -14,6 +14,7 @@
# License for the specific language governing permissions and limitations
# under the License.
import testtools
from oslo import messaging
from oslo.config import cfg
from mock import call
from mock import patch
@ -96,18 +97,20 @@ class PoolManagerServiceTest(PoolManagerTestCase):
with testtools.ExpectedException(exceptions.NoPoolServersConfigured):
self.start_service('pool_manager')
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(mdns_rpcapi.MdnsAPI, 'poll_for_serial_number')
@patch.object(mdns_rpcapi.MdnsAPI, 'notify_zone_changed')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_create_domain(
self, mock_update_status, mock_notify_zone_changed,
mock_poll_for_serial_number):
mock_poll_for_serial_number, mock_get_serial_number):
domain = self._build_domain('example.org.', 'CREATE', 'PENDING')
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(0, len(create_statuses))
@ -128,6 +131,14 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[1]['server'], 30, 2, 3, 1)],
mock_poll_for_serial_number.call_args_list)
self.assertEqual(2, mock_get_serial_number.call_count)
self.assertEqual(
[call(self.admin_context, domain,
self.service.server_backends[0]['server'], 30, 2, 3, 1),
call(self.admin_context, domain,
self.service.server_backends[1]['server'], 30, 2, 3, 1)],
mock_get_serial_number.call_args_list)
self.assertEqual(False, mock_update_status.called)
@patch.object(impl_fake.FakeBackend, 'create_domain')
@ -144,7 +155,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(2, len(create_statuses))
self.assertEqual('ERROR', create_statuses[0].status)
@ -172,7 +183,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(2, len(create_statuses))
self.assertEqual('SUCCESS', create_statuses[0].status)
@ -208,7 +219,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.create_domain(self.admin_context, domain)
create_statuses = self.service._retrieve_from_cache(
create_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'CREATE')
self.assertEqual(2, len(create_statuses))
self.assertEqual('SUCCESS', create_statuses[0].status)
@ -223,24 +234,28 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.assertEqual(False, mock_update_status.called)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain(self, mock_update_status):
def test_delete_domain(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'DELETE', 'PENDING')
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(0, len(delete_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'SUCCESS', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'delete_domain')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain_backend_both_failure(
self, mock_update_status, mock_delete_domain):
self, mock_update_status, mock_delete_domain, _):
domain = self._build_domain('example.org.', 'DELETE', 'PENDING')
@ -248,7 +263,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(2, len(delete_statuses))
self.assertEqual('ERROR', delete_statuses[0].status)
@ -257,10 +272,12 @@ class PoolManagerServiceTest(PoolManagerTestCase):
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'delete_domain')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain_backend_one_failure(
self, mock_update_status, mock_delete_domain):
self, mock_update_status, mock_delete_domain, _):
domain = self._build_domain('example.org.', 'DELETE', 'PENDING')
@ -268,7 +285,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(2, len(delete_statuses))
self.assertEqual('SUCCESS', delete_statuses[0].status)
@ -277,10 +294,12 @@ class PoolManagerServiceTest(PoolManagerTestCase):
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'ERROR', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(impl_fake.FakeBackend, 'delete_domain')
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_delete_domain_backend_one_failure_consensus(
self, mock_update_status, mock_delete_domain):
self, mock_update_status, mock_delete_domain, _):
self.service.stop()
self.config(
@ -294,7 +313,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.delete_domain(self.admin_context, domain)
delete_statuses = self.service._retrieve_from_cache(
delete_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'DELETE')
self.assertEqual(2, len(delete_statuses))
self.assertEqual('SUCCESS', delete_statuses[0].status)
@ -329,8 +348,10 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[1]['server'], 30, 2, 3, 1)],
mock_poll_for_serial_number.call_args_list)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status(self, mock_update_status):
def test_update_status(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'UPDATE', 'PENDING')
@ -338,7 +359,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(1, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)
@ -351,15 +372,17 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(0, len(update_statuses))
mock_update_status.assert_called_once_with(
self.admin_context, domain.id, 'SUCCESS', domain.serial)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status_both_failure(self, mock_update_status):
def test_update_status_both_failure(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'UPDATE', 'PENDING')
@ -367,7 +390,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(1, len(update_statuses))
self.assertEqual('ERROR', update_statuses[0].status)
@ -383,7 +406,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(2, len(update_statuses))
self.assertEqual('ERROR', update_statuses[0].status)
@ -397,8 +420,10 @@ class PoolManagerServiceTest(PoolManagerTestCase):
call(self.admin_context, domain.id, 'ERROR', 0)],
mock_update_status.call_args_list)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status_one_failure(self, mock_update_status):
def test_update_status_one_failure(self, mock_update_status, _):
domain = self._build_domain('example.org.', 'UPDATE', 'PENDING')
@ -406,7 +431,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(1, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)
@ -419,7 +444,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(2, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)
@ -433,8 +458,10 @@ class PoolManagerServiceTest(PoolManagerTestCase):
call(self.admin_context, domain.id, 'ERROR', 0)],
mock_update_status.call_args_list)
@patch.object(mdns_rpcapi.MdnsAPI, 'get_serial_number',
side_effect=messaging.MessagingException)
@patch.object(central_rpcapi.CentralAPI, 'update_status')
def test_update_status_one_failure_consensus(self, mock_update_status):
def test_update_status_one_failure_consensus(self, mock_update_status, _):
self.service.stop()
self.config(
@ -448,7 +475,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[0]['server'],
'SUCCESS', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(1, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)
@ -464,7 +491,7 @@ class PoolManagerServiceTest(PoolManagerTestCase):
self.service.server_backends[1]['server'],
'ERROR', domain.serial)
update_statuses = self.service._retrieve_from_cache(
update_statuses = self.service._retrieve_statuses(
self.admin_context, domain, 'UPDATE')
self.assertEqual(2, len(update_statuses))
self.assertEqual('SUCCESS', update_statuses[0].status)