def test_extensions_are_not_loaded_for_plugins_unaware_of_extensions(self):
class ExtensionUnawarePlugin(object):
"""This plugin does not implement supports_extension method.
Extensions will not be loaded when this plugin is used.
"""
pass
plugin_info = {lib_const.CORE: ExtensionUnawarePlugin()}
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(ext_stubs.StubExtension("e1"))
self.assertNotIn("e1", ext_mgr.extensions)
def test_extension_loaded_for_non_core_plugin(self):
class NonCorePluginExtenstion(ext_stubs.StubExtension):
def get_plugin_interface(self):
return None
stub_plugin = ext_stubs.StubPlugin(supported_extensions=["e1"])
plugin_info = {constants.DUMMY: stub_plugin}
with mock.patch("neutron.api.extensions.PluginAwareExtensionManager."
"check_if_plugin_extensions_loaded"):
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(NonCorePluginExtenstion("e1"))
self.assertIn("e1", ext_mgr.extensions)
def test_extensions_expecting_neutron_plugin_interface_are_loaded(self):
class ExtensionForQuamtumPluginInterface(ext_stubs.StubExtension):
"""This Extension does not implement get_plugin_interface method.
This will work with any plugin implementing NeutronPluginBase
"""
pass
stub_plugin = ext_stubs.StubPlugin(supported_extensions=["e1"])
plugin_info = {constants.CORE: stub_plugin}
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(ExtensionForQuamtumPluginInterface("e1"))
self.assertIn("e1", ext_mgr.extensions)
def test_extensions_are_loaded_for_plugin_with_expected_interface(self):
class PluginWithExpectedInterface(object):
"""Implements get_foo method as expected by extension."""
supported_extension_aliases = ["supported_extension"]
def get_foo(self, bar=None):
pass
plugin_info = {constants.CORE: PluginWithExpectedInterface()}
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(
ext_stubs.ExtensionExpectingPluginInterface("supported_extension"))
self.assertIn("supported_extension", ext_mgr.extensions)
def setUp(self,
service_provider=None,
core_plugin=None,
extra_service_plugins=None,
extra_extension_paths=None):
provider = fwaas_constants.FIREWALL_V2
if not service_provider:
provider += (':dummy:neutron_fwaas.tests.unit.services.firewall.'
'test_fwaas_plugin_v2.DummyDriverDB:default')
else:
provider += ':test:' + service_provider + ':default'
bits = provider.split(':')
provider = {
'service_type': bits[0],
'name': bits[1],
'driver': bits[2],
'default': True,
}
# override the default service provider
self.service_providers = (mock.patch.object(
sdb.ServiceTypeManager, 'get_service_providers').start())
self.service_providers.return_value = [provider]
plugin_str = ('neutron_fwaas.services.firewall.fwaas_plugin_v2.'
'FirewallPluginV2')
service_plugins = {'fw_plugin_name': plugin_str}
service_plugins.update(extra_service_plugins or {})
# we need to provide a plugin instance, although the extension manager
# will create a new instance of the plugin
plugins = {
fwaas_constants.FIREWALL_V2: fwaas_plugin_v2.FirewallPluginV2(),
}
for plugin_name, plugin_str in (extra_service_plugins or {}).items():
plugins[plugin_name] = importutils.import_object(plugin_str)
ext_mgr = api_ext.PluginAwareExtensionManager(
':'.join(extensions.__path__ + (extra_extension_paths or [])),
plugins,
)
super(FirewallPluginV2TestCase, self).setUp(
plugin=core_plugin,
service_plugins=service_plugins,
ext_mgr=ext_mgr,
)
# find the Firewall plugin that was instantiated by the extension
# manager
self.plugin = directory.get_plugin(fwaas_constants.FIREWALL_V2)
def test_unsupported_extensions_are_not_loaded(self):
stub_plugin = ext_stubs.StubPlugin(supported_extensions=["e1", "e3"])
plugin_info = {constants.CORE: stub_plugin}
with mock.patch("neutron.api.extensions.PluginAwareExtensionManager."
"check_if_plugin_extensions_loaded"):
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(ext_stubs.StubExtension("e1"))
ext_mgr.add_extension(ext_stubs.StubExtension("e2"))
ext_mgr.add_extension(ext_stubs.StubExtension("e3"))
self.assertIn("e1", ext_mgr.extensions)
self.assertNotIn("e2", ext_mgr.extensions)
self.assertIn("e3", ext_mgr.extensions)
def setUp(self, core_plugin=None, fw_plugin=None):
if not fw_plugin:
fw_plugin = DB_FW_PLUGIN_KLASS
service_plugins = {'fw_plugin_name': fw_plugin}
fdb.Firewall_db_mixin.supported_extension_aliases = ["fwaas"]
super(FirewallPluginDbTestCase,
self).setUp(service_plugins=service_plugins)
self.plugin = importutils.import_object(fw_plugin)
ext_mgr = api_ext.PluginAwareExtensionManager(
extensions_path, {constants.FIREWALL: self.plugin})
app = config.load_paste_app('extensions_test_app')
self.ext_api = api_ext.ExtensionMiddleware(app, ext_mgr=ext_mgr)
def test_extensions_not_loaded_for_plugin_without_expected_interface(self):
class PluginWithoutExpectedIface(object):
"""Does not implement get_foo method as expected by extension."""
supported_extension_aliases = ["supported_extension"]
plugin_info = {constants.CORE: PluginWithoutExpectedIface()}
with mock.patch("neutron.api.extensions.PluginAwareExtensionManager."
"check_if_plugin_extensions_loaded"):
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(
ext_stubs.ExtensionExpectingPluginInterface(
"supported_extension"))
self.assertNotIn("e1", ext_mgr.extensions)
def setUp(self, plugin=None):
service_plugins = {'metering_plugin_name': DB_METERING_PLUGIN_KLASS}
super(MeteringPluginDbTestCase, self).setUp(
plugin=plugin,
service_plugins=service_plugins
)
self.plugin = metering_plugin.MeteringPlugin()
ext_mgr = extensions.PluginAwareExtensionManager(
extensions_path,
{constants.METERING: self.plugin}
)
app = config.load_paste_app('extensions_test_app')
self.ext_api = extensions.ExtensionMiddleware(app, ext_mgr=ext_mgr)
def test_custom_supported_implementation(self):
self.useFixture(CustomExtensionCheckMapMemento())
class FakePlugin(object):
pass
class FakeExtension(ext_stubs.StubExtension):
extensions.register_custom_supported_check('stub_extension',
lambda: True,
plugin_agnostic=True)
ext = FakeExtension()
plugin_info = {lib_const.CORE: FakePlugin()}
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(ext)
self.assertIn("stub_extension", ext_mgr.extensions)
extensions.register_custom_supported_check('stub_extension',
lambda: False,
plugin_agnostic=True)
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(ext)
self.assertNotIn("stub_extension", ext_mgr.extensions)
def test_extensions_without_need_for__plugin_interface_are_loaded(self):
class ExtensionWithNoNeedForPluginInterface(ext_stubs.StubExtension):
"""This Extension does not need any plugin interface.
This will work with any plugin implementing NeutronPluginBase
"""
def get_plugin_interface(self):
return None
stub_plugin = ext_stubs.StubPlugin(supported_extensions=["e1"])
plugin_info = {constants.CORE: stub_plugin}
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(ExtensionWithNoNeedForPluginInterface("e1"))
self.assertTrue("e1" in ext_mgr.extensions)
def test_extensions_without_need_for__plugin_interface_are_loaded(self):
class ExtensionWithNoNeedForPluginInterface(ext_stubs.StubExtension):
"""This Extension does not need any plugin interface.
This will work with any plugin implementing NeutronPluginBase
"""
def get_plugin_interface(self):
return None
stub_plugin = ext_stubs.StubPlugin(supported_extensions=["e1"])
plugin_info = {lib_const.CORE: stub_plugin}
with mock.patch("neutron.api.extensions.PluginAwareExtensionManager."
"check_if_plugin_extensions_loaded"):
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(ExtensionWithNoNeedForPluginInterface("e1"))
self.assertIn("e1", ext_mgr.extensions)
def setUp(self):
service_plugins = {
'TAG':
"neutron.services.tag.tag_plugin.TagPlugin",
'router':
"neutron.tests.unit.extensions.test_l3.TestL3NatServicePlugin"
}
super(TestTagApiBase, self).setUp(service_plugins=service_plugins)
plugin = tag_plugin.TagPlugin()
l3_plugin = test_l3.TestL3NatServicePlugin()
ext_mgr = extensions.PluginAwareExtensionManager(
extensions_path, {
'router': l3_plugin,
'TAG': plugin
})
ext_mgr.extend_resources("2.0", attributes.RESOURCE_ATTRIBUTE_MAP)
app = config.load_paste_app('extensions_test_app')
self.ext_api = extensions.ExtensionMiddleware(app, ext_mgr=ext_mgr)
def setUp(self):
service_plugins = {
'router':
'neutron.tests.unit.extensions.test_l3.TestL3NatServicePlugin'
}
l3_plugin = test_l3.TestL3NatServicePlugin()
sec_plugin = test_securitygroup.SecurityGroupTestPlugin()
ext_mgr = extensions.PluginAwareExtensionManager(
EXTENSIONS_PATH, {
'router': l3_plugin,
'sec': sec_plugin
})
super(TestMaintenance, self).setUp(plugin=PLUGIN_CLASS,
service_plugins=service_plugins)
app = config.load_paste_app('extensions_test_app')
self.ext_api = extensions.ExtensionMiddleware(app, ext_mgr=ext_mgr)
self.session = db_api.get_writer_session()
revision_plugin.RevisionPlugin()
self.net = self._make_network(self.fmt, 'net1', True)['network']
def setUp(self):
sfc_plugin = test_sfc_db.DB_SFC_PLUGIN_CLASS
flowclassifier_plugin = (
test_flowclassifier_db.DB_FLOWCLASSIFIER_PLUGIN_CLASS)
service_plugins = {
sfc_ext.SFC_EXT: sfc_plugin,
flowclassifier.FLOW_CLASSIFIER_EXT: flowclassifier_plugin
}
sfc_db.SfcDbPlugin.supported_extension_aliases = [sfc_ext.SFC_EXT]
sfc_db.SfcDbPlugin.path_prefix = sfc_ext.SFC_PREFIX
fdb.FlowClassifierDbPlugin.supported_extension_aliases = [
flowclassifier.FLOW_CLASSIFIER_EXT
]
fdb.FlowClassifierDbPlugin.path_prefix = (
flowclassifier.FLOW_CLASSIFIER_PREFIX)
super(TestDfSfcDriver, self).setUp(ext_mgr=None,
plugin=None,
service_plugins=service_plugins)
self.sfc_plugin = importutils.import_object(sfc_plugin)
self.flowclassifier_plugin = importutils.import_object(
flowclassifier_plugin)
ext_mgr = api_ext.PluginAwareExtensionManager(
test_sfc_db.extensions_path, {
sfc_ext.SFC_EXT: self.sfc_plugin,
flowclassifier.FLOW_CLASSIFIER_EXT: self.flowclassifier_plugin
})
app = config.load_paste_app('extensions_test_app')
self.ext_api = api_ext.ExtensionMiddleware(app, ext_mgr=ext_mgr)
self.ctx = context.get_admin_context()
self.fake_lockedobjects = mock.patch(
'dragonflow.db.neutron.lockedobjects_db.wrap_db_lock',
side_effect=utils.empty_wrapper)
self.fake_lockedobjects.start()
self.addCleanup(self.fake_lockedobjects.stop)
# Import must be done after mock.patch for wrap_db_lock
self.driver = importutils.import_object(
'dragonflow.neutron.services.sfc.driver.DfSfcDriver')
self.driver.initialize()
self.driver._nb_api = mock.Mock()
def setUp(self):
super(ExtensionExtendedAttributeTestCase, self).setUp()
plugin = ("neutron.tests.unit.test_extension_extended_attribute."
"ExtensionExtendedAttributeTestPlugin")
# point config file to: neutron/tests/etc/neutron.conf.test
args = ['--config-file', test_api_v2.etcdir('neutron.conf.test')]
config.parse(args=args)
cfg.CONF.set_override('core_plugin', plugin)
manager.NeutronManager._instance = None
ext_mgr = extensions.PluginAwareExtensionManager(
extensions_path,
{constants.CORE: ExtensionExtendedAttributeTestPlugin})
ext_mgr.extend_resources("2.0", {})
extensions.PluginAwareExtensionManager._instance = ext_mgr
app = config.load_paste_app('extensions_test_app')
self._api = extensions.ExtensionMiddleware(app, ext_mgr=ext_mgr)
self._tenant_id = "8c70909f-b081-452d-872b-df48e6c355d1"
# Save the global RESOURCE_ATTRIBUTE_MAP
self.saved_attr_map = {}
for resource, attrs in attributes.RESOURCE_ATTRIBUTE_MAP.iteritems():
self.saved_attr_map[resource] = attrs.copy()
# Add the resources to the global attribute map
# This is done here as the setup process won't
# initialize the main API router which extends
# the global attribute map
attributes.RESOURCE_ATTRIBUTE_MAP.update(
extattr.EXTENDED_ATTRIBUTES_2_0)
self.agentscheduler_dbMinxin = manager.NeutronManager.get_plugin()
self.addCleanup(cfg.CONF.reset)
self.addCleanup(self.restore_attribute_map)
quota.QUOTAS._driver = None
cfg.CONF.set_override('quota_driver',
'neutron.quota.ConfDriver',
group='QUOTAS')
def test_extensions_are_loaded_for_plugin_with_expected_interface(self):
class PluginWithExpectedInterface(service_base.ServicePluginBase):
"""Implements get_foo method as expected by extension."""
supported_extension_aliases = ["supported_extension"]
def get_foo(self, bar=None):
pass
def get_plugin_type(self):
pass
def get_plugin_description(self):
pass
plugin_info = {lib_const.CORE: PluginWithExpectedInterface()}
with mock.patch("neutron.api.extensions.PluginAwareExtensionManager."
"check_if_plugin_extensions_loaded"):
ext_mgr = extensions.PluginAwareExtensionManager('', plugin_info)
ext_mgr.add_extension(
ext_stubs.ExtensionExpectingPluginInterface(
"supported_extension"))
self.assertIn("supported_extension", ext_mgr.extensions)
def setUp(self):
super(RouterServiceInsertionTestCase, self).setUp()
plugin = (
"neutron.tests.unit.test_routerserviceinsertion."
"RouterServiceInsertionTestPlugin"
)
# point config file to: neutron/tests/etc/neutron.conf.test
args = ['--config-file', test_api_v2.etcdir('neutron.conf.test')]
config.parse(args=args)
#just stubbing core plugin with LoadBalancer plugin
cfg.CONF.set_override('core_plugin', plugin)
cfg.CONF.set_override('service_plugins', [])
cfg.CONF.set_override('quota_router', -1, group='QUOTAS')
self.addCleanup(cfg.CONF.reset)
# Ensure 'stale' patched copies of the plugin are never returned
neutron.manager.NeutronManager._instance = None
# Ensure existing ExtensionManager is not used
ext_mgr = extensions.PluginAwareExtensionManager(
extensions_path,
{constants.LOADBALANCER: RouterServiceInsertionTestPlugin()}
)
extensions.PluginAwareExtensionManager._instance = ext_mgr
router.APIRouter()
app = config.load_paste_app('extensions_test_app')
self._api = extensions.ExtensionMiddleware(app, ext_mgr=ext_mgr)
self._tenant_id = "8c70909f-b081-452d-872b-df48e6c355d1"
self._service_type_id = _uuid()
self._setup_core_resources()
def setUp(self):
service_plugins = {
'router':
'neutron.tests.unit.extensions.test_l3.TestL3NatServicePlugin'}
l3_plugin = test_l3.TestL3NatServicePlugin()
sec_plugin = test_securitygroup.SecurityGroupTestPlugin()
ext_mgr = extensions.PluginAwareExtensionManager(
EXTENSIONS_PATH, {'router': l3_plugin, 'sec': sec_plugin}
)
super(TestMaintenance, self).setUp(plugin=PLUGIN_CLASS,
service_plugins=service_plugins)
app = config.load_paste_app('extensions_test_app')
self.ext_api = extensions.ExtensionMiddleware(app, ext_mgr=ext_mgr)
self.session = db_api.get_writer_session()
revision_plugin.RevisionPlugin()
self.net = self._make_network(self.fmt, 'net1', True)['network']
# Mock the default value for INCONSISTENCIES_OLDER_THAN so
# tests won't need to wait for the timeout in order to validate
# the database inconsistencies
self.older_than_mock = mock.patch(
'networking_ovn.db.maintenance.INCONSISTENCIES_OLDER_THAN', -1)
self.older_than_mock.start()
self.addCleanup(self.older_than_mock.stop)
def get_ext_managers(self):
extensions_path = ':'.join(l2gw_extensions.__path__)
return api_extensions.PluginAwareExtensionManager(
extensions_path, {'l2gw_plugin': L2GatewayPlugin()})
def setUp(self, service_provider=None, core_plugin=None):
if not service_provider:
provider = (constants.BGPVPN +
':dummy:networking_bgpvpn.neutron.services.'
'service_drivers.driver_api.BGPVPNDriver:default')
else:
provider = (constants.BGPVPN + ':test:' + service_provider +
':default')
bits = provider.split(':')
provider = {
'service_type': bits[0],
'name': bits[1],
'driver': bits[2]
}
if len(bits) == 4:
provider['default'] = True
# override the default service provider
self.service_providers = (mock.patch.object(
sdb.ServiceTypeManager, 'get_service_providers').start())
self.service_providers.return_value = [provider]
bgpvpn_plugin_str = ('networking_bgpvpn.neutron.services.plugin.'
'BGPVPNPlugin')
l3_plugin_str = ('neutron.tests.unit.extensions.test_l3.'
'TestL3NatServicePlugin')
service_plugins = {
'bgpvpn_plugin': bgpvpn_plugin_str,
'l3_plugin_name': l3_plugin_str
}
extensions_path = ':'.join(extensions.__path__ + n_extensions.__path__)
# we need to provide a plugin instance, although
# the extension manager will create a new instance
# of the plugin
ext_mgr = api_extensions.PluginAwareExtensionManager(
extensions_path, {
constants.BGPVPN: plugin.BGPVPNPlugin(),
'l3_plugin_name': TestL3NatServicePlugin()
})
super(BgpvpnTestCaseMixin, self).setUp(plugin=core_plugin,
service_plugins=service_plugins,
ext_mgr=ext_mgr)
# find the BGPVPN plugin that was instantiated by the
# extension manager:
self.bgpvpn_plugin = (
manager.NeutronManager.get_service_plugins()[constants.BGPVPN])
self.bgpvpn_data = {
'bgpvpn': {
'name': 'bgpvpn1',
'type': 'l3',
'route_targets': ['1234:56'],
'tenant_id': self._tenant_id
}
}
self.converted_data = copy.copy(self.bgpvpn_data)
self.converted_data['bgpvpn'].update({
'export_targets': [],
'import_targets': [],
'route_distinguishers': []
})
def setUp(self):
# init the flow classifier plugin
flowclassifier_plugin = (
test_flowclassifier_db.DB_FLOWCLASSIFIER_PLUGIN_CLASS)
service_plugins = {
flowclassifier.FLOW_CLASSIFIER_EXT: flowclassifier_plugin
}
fdb.FlowClassifierDbPlugin.supported_extension_aliases = [
flowclassifier.FLOW_CLASSIFIER_EXT
]
fdb.FlowClassifierDbPlugin.path_prefix = (
flowclassifier.FLOW_CLASSIFIER_PREFIX)
super(TestNsxvFlowClassifierDriver,
self).setUp(ext_mgr=None,
plugin=None,
service_plugins=service_plugins)
self.flowclassifier_plugin = importutils.import_object(
flowclassifier_plugin)
ext_mgr = api_ext.PluginAwareExtensionManager(
test_flowclassifier_db.extensions_path,
{flowclassifier.FLOW_CLASSIFIER_EXT: self.flowclassifier_plugin})
app = config.load_paste_app('extensions_test_app')
self.ext_api = api_ext.ExtensionMiddleware(app, ext_mgr=ext_mgr)
self.ctx = context.get_admin_context()
# use the fake vcns
mock_vcns = mock.patch(vmware.VCNS_NAME, autospec=True)
mock_vcns_instance = mock_vcns.start()
self.fc2 = fake_vcns.FakeVcns()
mock_vcns_instance.return_value = self.fc2
# use the nsxv flow classifier driver
self._profile_id = 'serviceprofile-1'
cfg.CONF.set_override('service_insertion_profile_id', self._profile_id,
'nsxv')
cfg.CONF.set_override('service_insertion_redirect_all', True, 'nsxv')
self.driver = nsx_v_driver.NsxvFlowClassifierDriver()
self.driver.initialize()
self._fc_name = 'test1'
self._fc_description = 'test 1'
self._fc_source = '10.10.0.0/24'
self._fc_dest = '20.10.0.0/24'
self._fc_prot = 'TCP'
self._fc_source_ports = range(100, 115)
self._fc_dest_ports = range(80, 81)
self._fc = {
'name': self._fc_name,
'description': self._fc_description,
'logical_source_port': None,
'logical_destination_port': None,
'source_ip_prefix': self._fc_source,
'destination_ip_prefix': self._fc_dest,
'protocol': self._fc_prot,
'source_port_range_min': self._fc_source_ports[0],
'source_port_range_max': self._fc_source_ports[-1],
'destination_port_range_min': self._fc_dest_ports[0],
'destination_port_range_max': self._fc_dest_ports[-1]
}
