def test_bump_revision(self):
db_rev.create_initial_revision(self.net['id'], constants.TYPE_NETWORKS,
self.session)
self.net['revision_number'] = 123
db_rev.bump_revision(self.net, constants.TYPE_NETWORKS)
row = self.get_revision_row(self.net['id'])
self.assertEqual(123, row.revision_number)
def _test_fix_create_update_port(self, ovn_rev, neutron_rev):
self.port['revision_number'] = neutron_rev
# Create an entry to the revision_numbers table and assert the
# initial revision_number for our test object is the expected
db_rev.create_initial_revision(
self.port['id'], constants.TYPE_PORTS, self.session,
revision_number=ovn_rev)
row = db_rev.get_revision_row(self.port['id'])
self.assertEqual(ovn_rev, row.revision_number)
if ovn_rev < 0:
self.fake_ovn_client._nb_idl.get_lswitch_port.return_value = None
else:
fake_lsp = mock.Mock(external_ids={
constants.OVN_REV_NUM_EXT_ID_KEY: ovn_rev})
self.fake_ovn_client._nb_idl.get_lswitch_port.return_value = (
fake_lsp)
self.fake_ovn_client._plugin.get_port.return_value = self.port
self.periodic._fix_create_update(row)
# Since the revision number was < 0, make sure create_port()
# is invoked with the latest version of the object in the neutron
# database
if ovn_rev < 0:
self.fake_ovn_client.create_port.assert_called_once_with(
self.port)
# If the revision number is > 0 it means that the object already
# exist and we just need to update to match the latest in the
# neutron database so, update_port() should be called.
else:
self.fake_ovn_client.update_port.assert_called_once_with(
self.port)
def update_port_precommit(self, context):
"""Update resources of a port.
:param context: PortContext instance describing the new
state of the port, as well as the original state prior
to the update_port call.
Called inside transaction context on session to complete a
port update as defined by this mechanism driver. Raising an
exception will result in rollback of the transaction.
update_port_precommit is called for all changes to the port
state. It is up to the mechanism driver to ignore state or
state changes that it does not know or care about.
"""
port = context.current
original_port = context.original
self._validate_ignored_port(port, original_port)
utils.validate_and_get_data_from_binding_profile(port)
if self._is_port_provisioning_required(port, context.host,
context.original_host):
self._insert_port_provisioning_block(context._plugin_context,
port['id'])
if utils.is_lsp_router_port(port):
# handle the case when an existing port is added to a
# logical router so we need to track the creation of the lrp
if not utils.is_lsp_router_port(original_port):
db_rev.create_initial_revision(port['id'],
ovn_const.TYPE_ROUTER_PORTS,
context._plugin_context.session,
may_exist=True)
def _test_fix_security_group_create(self, mock_bump, revision_number):
sg_name = utils.ovn_addrset_name('fake_id', 'ip4')
sg = self._make_security_group(self.fmt, sg_name, '')['security_group']
db_rev.create_initial_revision(
sg['id'], constants.TYPE_SECURITY_GROUPS, self.session,
revision_number=revision_number)
row = db_rev.get_revision_row(sg['id'])
self.assertEqual(revision_number, row.revision_number)
if revision_number < 0:
self.fake_ovn_client._nb_idl.get_address_set.return_value = None
self.fake_ovn_client._nb_idl.get_port_group.return_value = None
else:
self.fake_ovn_client._nb_idl.get_address_set.return_value = (
mock.sentinel.AddressSet)
self.fake_ovn_client._plugin.get_security_group.return_value = sg
self.periodic._fix_create_update(row)
if revision_number < 0:
self.fake_ovn_client.create_security_group.assert_called_once_with(
sg)
else:
# If the object already exist let's make sure we just bump
# the revision number in the ovn_revision_numbers table
self.assertFalse(self.fake_ovn_client.create_security_group.called)
mock_bump.assert_called_once_with(
sg, constants.TYPE_SECURITY_GROUPS)
def create_port_precommit(self, context):
"""Allocate resources for a new port.
:param context: PortContext instance describing the port.
Create a new port, allocating resources as necessary in the
database. Called inside transaction context on session. Call
cannot block. Raising an exception will result in a rollback
of the current transaction.
"""
port = context.current
if utils.is_lsp_ignored(port):
return
utils.validate_and_get_data_from_binding_profile(port)
if self._is_port_provisioning_required(port, context.host):
self._insert_port_provisioning_block(context._plugin_context,
port['id'])
db_rev.create_initial_revision(port['id'], ovn_const.TYPE_PORTS,
context._plugin_context.session)
# in the case of router ports we also need to
# track the creation and update of the LRP OVN objects
if utils.is_lsp_router_port(port):
db_rev.create_initial_revision(port['id'],
ovn_const.TYPE_ROUTER_PORTS,
context._plugin_context.session)
def test_bump_older_revision(self):
db_rev.create_initial_revision(self.net['id'], constants.TYPE_NETWORKS,
self.session, revision_number=123)
self.net['revision_number'] = 1
db_rev.bump_revision(self.net, constants.TYPE_NETWORKS)
# Assert the revision number wasn't bumped
row = db_rev.get_revision_row(self.net['id'])
self.assertEqual(123, row.revision_number)
def test_get_inconsistent_resources(self):
# Set the intial revision to -1 to force it to be incosistent
db_rev.create_initial_revision(
self.net['id'], constants.TYPE_NETWORKS, self.session,
revision_number=-1)
res = db_maint.get_inconsistent_resources()
self.assertEqual(1, len(res))
self.assertEqual(self.net['id'], res[0].resource_uuid)
def test_get_inconsistent_resources_consistent(self):
# Set the initial revision to 0 which is the initial revision_number
# for recently created resources
db_rev.create_initial_revision(
self.net['id'], constants.TYPE_NETWORKS, self.session,
revision_number=0)
res = db_maint.get_inconsistent_resources()
# Assert nothing is inconsistent
self.assertEqual([], res)
def test_get_deleted_resources(self):
db_rev.create_initial_revision(
self.net['id'], constants.TYPE_NETWORKS, self.session,
revision_number=0)
self._delete('networks', self.net['id'])
res = db_maint.get_deleted_resources()
self.assertEqual(1, len(res))
self.assertEqual(self.net['id'], res[0].resource_uuid)
self.assertIsNone(res[0].standard_attr_id)
def test_create_initial_revision_may_exist_duplicated_entry(self):
args = (self.net['id'], constants.TYPE_NETWORKS, self.session)
db_rev.create_initial_revision(*args)
# assert DBDuplicateEntry is raised when may_exist is False (default)
self.assertRaises(db_exc.DBDuplicateEntry,
db_rev.create_initial_revision, *args)
try:
db_rev.create_initial_revision(*args, may_exist=True)
except db_exc.DBDuplicateEntry:
self.fail("create_initial_revision shouldn't raise "
"DBDuplicateEntry when may_exist is True")
def create_network_precommit(self, context):
"""Allocate resources for a new network.
:param context: NetworkContext instance describing the new
network.
Create a new network, allocating resources as necessary in the
database. Called inside transaction context on session. Call
cannot block. Raising an exception will result in a rollback
of the current transaction.
"""
self._validate_network_segments(context.network_segments)
db_rev.create_initial_revision(context.current['id'],
ovn_const.TYPE_NETWORKS,
context._plugin_context.session)
def test_get_inconsistent_resources_older_than(self):
# Stop the mock so the INCONSISTENCIES_OLDER_THAN will have
# it's default value
self.older_than_mock.stop()
db_rev.create_initial_revision(
self.net['id'], constants.TYPE_NETWORKS, self.session,
revision_number=-1)
res = db_maint.get_inconsistent_resources()
# Assert that nothing is returned because the entry is not old
# enough to be picked as an inconsistency
self.assertEqual(0, len(res))
# Start the mock again and make sure it nows shows up as an
# inconsistency
self.older_than_mock.start()
res = db_maint.get_inconsistent_resources()
self.assertEqual(1, len(res))
self.assertEqual(self.net['id'], res[0].resource_uuid)
def create_subnet_precommit(self, context):
db_rev.create_initial_revision(context.current['id'],
ovn_const.TYPE_SUBNETS,
context._plugin_context.session)
def _create_sg_rule_precommit(self, resource, event, trigger, **kwargs):
sg_rule = kwargs.get('security_group_rule')
context = kwargs.get('context')
db_rev.create_initial_revision(sg_rule['id'],
ovn_const.TYPE_SECURITY_GROUP_RULES,
context.session)
def _create_security_group_precommit(self, resource, event, trigger,
security_group, context, **kwargs):
db_rev.create_initial_revision(security_group['id'],
ovn_const.TYPE_SECURITY_GROUPS,
context.session)
def _prepare_resources_for_ordering_test(self, delete=False):
subnet = self._make_subnet(self.fmt, {'network': self.net}, '10.0.0.1',
'10.0.0.0/24')['subnet']
self._set_net_external(self.net['id'])
info = {'network_id': self.net['id']}
router = self._make_router(self.fmt, None,
external_gateway_info=info)['router']
fip = self._make_floatingip(self.fmt, self.net['id'])['floatingip']
port = self._make_port(self.fmt, self.net['id'])['port']
sg = self._make_security_group(self.fmt, 'sg1', '')['security_group']
rule = self._build_security_group_rule(sg['id'], 'ingress',
n_const.PROTO_NUM_TCP)
sg_rule = self._make_security_group_rule(self.fmt,
rule)['security_group_rule']
db_rev.create_initial_revision(router['id'], constants.TYPE_ROUTERS,
self.session)
db_rev.create_initial_revision(subnet['id'], constants.TYPE_SUBNETS,
self.session)
db_rev.create_initial_revision(fip['id'], constants.TYPE_FLOATINGIPS,
self.session)
db_rev.create_initial_revision(port['id'], constants.TYPE_PORTS,
self.session)
db_rev.create_initial_revision(port['id'], constants.TYPE_ROUTER_PORTS,
self.session)
db_rev.create_initial_revision(sg['id'],
constants.TYPE_SECURITY_GROUPS,
self.session)
db_rev.create_initial_revision(sg_rule['id'],
constants.TYPE_SECURITY_GROUP_RULES,
self.session)
db_rev.create_initial_revision(self.net['id'], constants.TYPE_NETWORKS,
self.session)
if delete:
self._delete('security-group-rules', sg_rule['id'])
self._delete('floatingips', fip['id'])
self._delete('ports', port['id'])
self._delete('security-groups', sg['id'])
self._delete('routers', router['id'])
self._delete('subnets', subnet['id'])
self._delete('networks', self.net['id'])
def create_floatingip_precommit(self, resource, event, trigger, context,
floatingip, floatingip_id, floatingip_db):
db_rev.create_initial_revision(
floatingip_id, ovn_const.TYPE_FLOATINGIPS, context.session)
def create_router_precommit(self, resource, event, trigger, context,
router, router_id, router_db):
db_rev.create_initial_revision(
router_id, ovn_const.TYPE_ROUTERS, context.session)
def test_delete_revision(self):
db_rev.create_initial_revision(self.net['id'], constants.TYPE_NETWORKS,
self.session)
db_rev.delete_revision(self.net['id'])
row = self.get_revision_row(self.net['id'])
self.assertIsNone(row)
