def test_retry_on_unavailable(self):
pl = NeutronManager.get_plugin()
with nested(
mock.patch(SERVERMANAGER + '.ServerProxy.rest_call',
return_value=(httplib.SERVICE_UNAVAILABLE, 0, 0,
0)),
mock.patch(SERVERMANAGER + '.time.sleep')) as (srestmock,
tmock):
# making a call should trigger retries with sleeps in between
pl.servers.rest_call('GET', '/', '', None, [])
rest_call = [
mock.call('GET',
'/',
'',
None,
False,
reconnect=True,
hash_handler=mock.ANY)
]
rest_call_count = (
servermanager.HTTP_SERVICE_UNAVAILABLE_RETRY_COUNT + 1)
srestmock.assert_has_calls(rest_call * rest_call_count)
sleep_call = [
mock.call(
servermanager.HTTP_SERVICE_UNAVAILABLE_RETRY_INTERVAL)
]
# should sleep 1 less time than the number of calls
sleep_call_count = rest_call_count - 1
tmock.assert_has_calls(sleep_call * sleep_call_count)
def setUp(self, plugin=None):
ext_mgr = test_extension_security_group.SecurityGroupTestExtensionManager()
super(PortSecurityTestCase, self).setUp(plugin=plugin, ext_mgr=ext_mgr)
# Check if a plugin supports security groups
plugin_obj = NeutronManager.get_plugin()
self._skip_security_group = "security-group" not in plugin_obj.supported_extension_aliases
def setUp(self):
super(ProvidernetExtensionTestCase, self).setUp()
plugin = 'neutron.neutron_plugin_base_v2.NeutronPluginBaseV2'
# Ensure 'stale' patched copies of the plugin are never returned
NeutronManager._instance = None
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
# 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()
# Update the plugin and extensions path
cfg.CONF.set_override('core_plugin', plugin)
cfg.CONF.set_override('allow_pagination', True)
cfg.CONF.set_override('allow_sorting', True)
self._plugin_patcher = mock.patch(plugin, autospec=True)
self.plugin = self._plugin_patcher.start()
# Ensure Quota checks never fail because of mock
instance = self.plugin.return_value
instance.get_networks_count.return_value = 1
# Instantiate mock plugin and enable the 'provider' extension
NeutronManager.get_plugin().supported_extension_aliases = ([
"provider"
])
ext_mgr = ProviderExtensionManager()
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.addCleanup(self._plugin_patcher.stop)
self.addCleanup(cfg.CONF.reset)
self.addCleanup(self._restore_attribute_map)
self.api = webtest.TestApp(router.APIRouter())
def test_network_admin_state(self):
name = "network_test"
admin_status_up = False
tenant_id = "tenant_test"
network = {"network": {"name": name, "admin_state_up": admin_status_up, "tenant_id": tenant_id}}
plugin = NeutronManager.get_plugin()
self.assertEqual(plugin._network_admin_state(network), network)
def test_update_port_security_off_address_pairs(self):
if self._skip_port_security:
self.skipTest("Plugin does not implement port-security extension")
with self.network() as net:
with self.subnet(network=net):
address_pairs = [{'mac_address': '00:00:00:00:00:01',
'ip_address': '10.0.0.1'}]
res = self._create_port(self.fmt, net['network']['id'],
arg_list=('port_security_enabled',
addr_pair.ADDRESS_PAIRS,),
port_security_enabled=True,
allowed_address_pairs=address_pairs)
port = self.deserialize(self.fmt, res)
print port
update_port = {'port': {psec.PORTSECURITY: False}}
# If plugin implements security groups we also need to remove
# the security group on port.
plugin_obj = NeutronManager.get_plugin()
if 'security-groups' in plugin_obj.supported_extension_aliases:
update_port['port']['security_groups'] = []
req = self.new_update_request('ports', update_port,
port['port']['id'])
res = req.get_response(self.api)
self.assertEqual(res.status_int, 409)
self._delete('ports', port['port']['id'])
def test_create_networks_bulk_emulated_plugin_failure(self):
real_has_attr = hasattr
def fakehasattr(item, attr):
if attr.endswith('__native_bulk_support'):
return False
return real_has_attr(item, attr)
plugin_obj = NeutronManager.get_plugin()
orig = plugin_obj.create_network
#ensures the API choose the emulation code path
with mock.patch('__builtin__.hasattr',
new=fakehasattr):
with mock.patch.object(plugin_obj,
'create_network') as patched_plugin:
def side_effect(*args, **kwargs):
return self._do_side_effect(patched_plugin, orig,
*args, **kwargs)
patched_plugin.side_effect = side_effect
res = self._create_network_bulk(self.fmt, 2, 'test', True)
LOG.debug("response is %s" % res)
# We expect an internal server error as we injected a fault
self._validate_behavior_on_bulk_failure(
res,
'networks',
wexc.HTTPInternalServerError.code)
def test_load_api_extensions(self):
q_config.parse(['--config-file', BASE_CONF_PATH,
'--config-file', NSX_INI_FULL_PATH])
cfg.CONF.set_override('core_plugin', PLUGIN_NAME)
# Load the configuration, and initialize the plugin
NeutronManager().get_plugin()
self.assertIn('extensions', cfg.CONF.api_extensions_path)
def test_file_put_contents(self):
pl = NeutronManager.get_plugin()
with mock.patch(SERVERMANAGER + '.open', create=True) as omock:
pl.servers._file_put_contents('somepath', 'contents')
omock.assert_has_calls([mock.call('somepath', 'w')])
omock.return_value.__enter__.return_value.assert_has_calls(
[mock.call.write('contents')])
def test_cert_get_fail(self):
pl = NeutronManager.get_plugin()
pl.servers.ssl = True
with mock.patch('os.path.exists', return_value=False):
self.assertRaises(cfg.Error,
pl.servers._get_combined_cert_for_server,
*('example.org', 443))
def setUp(self):
self.httpPatch = patch('httplib.HTTPConnection', create=True,
new=HTTPConnectionMock)
self.httpPatch.start()
test_l3_plugin.L3NatDBTestCase.setUp = new_L3_setUp
super(RouterDBTestCase, self).setUp()
self.plugin_obj = NeutronManager.get_plugin()
def setUp(self, plugin=None):
super(PortSecurityTestCase, self).setUp()
# Check if a plugin supports security groups
plugin_obj = NeutronManager.get_plugin()
self._skip_security_group = (
'security-group' not in plugin_obj.supported_extension_aliases)
def test_update_port_security_off_address_pairs(self):
if self._skip_port_security:
self.skipTest("Plugin does not implement port-security extension")
with self.network() as net:
with self.subnet(network=net):
address_pairs = [{
'mac_address': '00:00:00:00:00:01',
'ip_address': '10.0.0.1'
}]
res = self._create_port(self.fmt,
net['network']['id'],
arg_list=(
'port_security_enabled',
addr_pair.ADDRESS_PAIRS,
),
port_security_enabled=True,
allowed_address_pairs=address_pairs)
port = self.deserialize(self.fmt, res)
update_port = {'port': {psec.PORTSECURITY: False}}
# If plugin implements security groups we also need to remove
# the security group on port.
plugin_obj = NeutronManager.get_plugin()
if 'security-groups' in plugin_obj.supported_extension_aliases:
update_port['port']['security_groups'] = []
req = self.new_update_request('ports', update_port,
port['port']['id'])
res = req.get_response(self.api)
self.assertEqual(res.status_int, 409)
self._delete('ports', port['port']['id'])
def _update_secgrp_rule(self, context, rule_id):
compute, project = self.gce_svc, self.gce_project
name = self._gce_secgrp_id(rule_id)
try:
gce_firewall_info = gceutils.get_firewall_rule(
compute, project, name)
except gce_errors.HttpError:
return
try:
core_plugin = NeutronManager.get_plugin()
except AttributeError:
core_plugin = directory.get_plugin()
rule = core_plugin.get_security_group_rule(context, rule_id)
network_link = gce_firewall_info['network']
try:
gce_rule = self._convert_secgrp_rule_to_gce(rule, network_link)
LOG.info("Update GCE firewall rule %s" % name)
operation = gceutils.update_firewall_rule(compute, project, name,
gce_rule)
gceutils.wait_for_operation(compute, project, operation)
except Exception as e:
LOG.exception("An error occurred while updating security "
"group: %s" % e)
LOG.error("Deleting existing GCE firewall rule %s" % name)
operation = gceutils.delete_firewall_rule(compute, project, name)
gceutils.wait_for_operation(compute, project, operation)
def test_update_network(self):
plugin_obj = NeutronManager.get_plugin()
networks_req = {}
router_inst = RouterInstance()
network = {
'router:external': router_inst,
u'name': u'network1',
'admin_state_up': 'True',
'tenant_id': uuid.uuid4().hex.decode(),
'vpc:route_table': '',
'shared': False,
'port_security_enabled': True,
u'contrail:policys': [],
}
context_obj = Context(network['tenant_id'])
#create project
if not GlobalProjects:
project_name = 'admin'
GlobalProjects.append(MockProject(name=project_name))
networks_req[u'network'] = network
net_dict = plugin_obj.create_network(context_obj, networks_req)
net_id = net_dict.get('id')
# change one of the attribute and update the network
network['admin_state_up'] = 'False'
new_dict = plugin_obj.update_network(context_obj, net_id,
networks_req)
self.assertNotEqual(net_dict.get('admin_state_up'),
new_dict.get('admin_state_up'))
def test_delete_subnet(self):
#First create virtual network without subnet and then
#create subnet to update given network.
plugin_obj = NeutronManager.get_plugin()
networks_req = {}
router_inst = RouterInstance()
network = {
'router:external': router_inst,
u'name': u'network1',
'admin_state_up': 'True',
'tenant_id': uuid.uuid4().hex.decode(),
'vpc:route_table': '',
'shared': False,
'port_security_enabled': True,
u'contrail:policys': [],
}
networks_req[u'network'] = network
context_obj = Context(network['tenant_id'])
#create project
if not GlobalProjects:
project_name = 'admin'
GlobalProjects.append(MockProject(name=project_name))
net = plugin_obj.create_network(context_obj, networks_req)
subnet_obj[u'subnet']['network_id'] = net['id']
subnet_dict = plugin_obj.create_subnet(context_obj, subnet_obj)
subnet_id = subnet_dict['id']
plugin_obj.delete_subnet(context_obj, subnet_id)
def test_delete_network(self):
# First create the network and request to delete the same
plugin_obj = NeutronManager.get_plugin()
networks_req = {}
router_inst = RouterInstance()
network = {
'router:external': router_inst,
u'name': u'network1',
'admin_state_up': 'True',
'tenant_id': uuid.uuid4().hex.decode(),
'vpc:route_table': '',
'shared': False,
'port_security_enabled': True,
u'contrail:policys': [],
}
context_obj = Context(network['tenant_id'])
#create project
if not GlobalProjects:
project_name = 'admin'
GlobalProjects.append(MockProject(name=project_name))
networks_req[u'network'] = network
net_dict = plugin_obj.create_network(context_obj, networks_req)
net_id = net_dict.get('id')
plugin_obj.delete_network(context_obj, net_id)
mock_vnc_api_cls.virtual_network_delete.assert_called_once()
def test_create_network(self):
plugin_obj = NeutronManager.get_plugin()
networks_req = {}
router_inst = RouterInstance()
network = {
'router:external': router_inst,
u'name': u'network1',
'admin_state_up': 'True',
'tenant_id': uuid.uuid4().hex.decode(),
'vpc:route_table': '',
'shared': False,
'port_security_enabled': True,
u'contrail:policys': [],
}
networks_req[u'network'] = network
context_obj = Context(network['tenant_id'])
#create project
if not GlobalProjects:
project_name = 'admin'
GlobalProjects.append(MockProject(name=project_name))
net = plugin_obj.create_network(context_obj, networks_req)
if 'contrail:fq_name' not in net.keys():
assert False
else:
assert True
def setUp(self, plugin=None):
super(AllowedAddressPairTestCase, self).setUp()
# Check if a plugin supports security groups
plugin_obj = NeutronManager.get_plugin()
self._skip_port_security = (
'port-security' not in plugin_obj.supported_extension_aliases)
def setUp(self, plugin=None):
super(AllowedAddressPairTestCase, self).setUp()
# Check if a plugin supports security groups
plugin_obj = NeutronManager.get_plugin()
self._skip_port_security = ('port-security' not in
plugin_obj.supported_extension_aliases)
def test_update_port_security_off_address_pairs(self):
if self._skip_port_security:
self.skipTest("Plugin does not implement port-security extension")
with self.network() as net:
with self.subnet(network=net):
address_pairs = [{"mac_address": "00:00:00:00:00:01", "ip_address": "10.0.0.1"}]
res = self._create_port(
self.fmt,
net["network"]["id"],
arg_list=("port_security_enabled", addr_pair.ADDRESS_PAIRS),
port_security_enabled=True,
allowed_address_pairs=address_pairs,
)
port = self.deserialize(self.fmt, res)
print port
update_port = {"port": {psec.PORTSECURITY: False}}
# If plugin implements security groups we also need to remove
# the security group on port.
plugin_obj = NeutronManager.get_plugin()
if "security-groups" in plugin_obj.supported_extension_aliases:
update_port["port"]["security_groups"] = []
req = self.new_update_request("ports", update_port, port["port"]["id"])
res = req.get_response(self.api)
self.assertEqual(res.status_int, 409)
self._delete("ports", port["port"]["id"])
def test_create_subnets_bulk_emulated_plugin_failure(self):
real_has_attr = hasattr
#ensures the API choose the emulation code path
def fakehasattr(item, attr):
if attr.endswith('__native_bulk_support'):
return False
return real_has_attr(item, attr)
with mock.patch('__builtin__.hasattr',
new=fakehasattr):
plugin_obj = NeutronManager.get_plugin()
orig = plugin_obj.create_subnet
with mock.patch.object(plugin_obj,
'create_subnet') as patched_plugin:
def side_effect(*args, **kwargs):
self._do_side_effect(patched_plugin, orig,
*args, **kwargs)
patched_plugin.side_effect = side_effect
with self.network() as net:
res = self._create_subnet_bulk(self.fmt, 2,
net['network']['id'],
'test')
# We expect an internal server error as we injected a fault
self._validate_behavior_on_bulk_failure(
res,
'subnets',
wexc.HTTPInternalServerError.code)
def setUp(self, plugin=None):
super(PortSecurityTestCase, self).setUp()
# Check if a plugin supports security groups
plugin_obj = NeutronManager.get_plugin()
self._skip_security_group = ('security-group' not in
plugin_obj.supported_extension_aliases)
def test_create404_triggers_background_sync(self):
# allow the async background thread to run for this test
self.spawn_p.stop()
with nested(
mock.patch(
SERVER_POOL + ".rest_create_port",
side_effect=servermanager.RemoteRestError(reason=servermanager.NXNETWORK, status=404),
),
mock.patch(DRIVER + "._send_all_data"),
self.port(**{"device_id": "devid", "binding:host_id": "host"}),
) as (mock_http, mock_send_all, p):
# wait for thread to finish
mm = NeutronManager.get_plugin().mechanism_manager
bigdriver = mm.mech_drivers["bigswitch"].obj
bigdriver.evpool.waitall()
mock_send_all.assert_has_calls(
[
mock.call(
send_routers=False,
send_ports=True,
send_floating_ips=False,
triggered_by_tenant=p["port"]["tenant_id"],
)
]
)
self.spawn_p.start()
def test_create_networks_bulk_emulated_plugin_failure(self):
real_has_attr = hasattr
def fakehasattr(item, attr):
if attr.endswith('__native_bulk_support'):
return False
return real_has_attr(item, attr)
plugin_obj = NeutronManager.get_plugin()
orig = plugin_obj.create_network
#ensures the API choose the emulation code path
with mock.patch('__builtin__.hasattr', new=fakehasattr):
with mock.patch.object(plugin_obj,
'create_network') as patched_plugin:
def side_effect(*args, **kwargs):
return self._do_side_effect(patched_plugin, orig, *args,
**kwargs)
patched_plugin.side_effect = side_effect
res = self._create_network_bulk(self.fmt, 2, 'test', True)
LOG.debug("response is %s" % res)
# We expect an internal server error as we injected a fault
self._validate_behavior_on_bulk_failure(
res, 'networks', wexc.HTTPInternalServerError.code)
def test_create_subnets_bulk_emulated_plugin_failure(self):
real_has_attr = hasattr
#ensures the API choose the emulation code path
def fakehasattr(item, attr):
if attr.endswith('__native_bulk_support'):
return False
return real_has_attr(item, attr)
with mock.patch('__builtin__.hasattr', new=fakehasattr):
plugin_obj = NeutronManager.get_plugin()
orig = plugin_obj.create_subnet
with mock.patch.object(plugin_obj,
'create_subnet') as patched_plugin:
def side_effect(*args, **kwargs):
self._do_side_effect(patched_plugin, orig, *args, **kwargs)
patched_plugin.side_effect = side_effect
with self.network() as net:
res = self._create_subnet_bulk(self.fmt, 2,
net['network']['id'],
'test')
# We expect an internal server error as we injected a fault
self._validate_behavior_on_bulk_failure(
res, 'subnets', wexc.HTTPInternalServerError.code)
def test_conflict_sync_raises_error_without_topology(self):
pl = NeutronManager.get_plugin()
pl.servers.get_topo_function = None
with mock.patch(SERVERMANAGER + ".ServerProxy.rest_call", return_value=(httplib.CONFLICT, 0, 0, 0)):
# making a call should trigger a conflict sync that will
# error without the topology function set
self.assertRaises(cfg.Error, pl.servers.rest_call, *("GET", "/", "", None, []))
def test_consistency_watchdog(self):
pl = NeutronManager.get_plugin()
pl.servers.capabilities = []
self.watch_p.stop()
with nested(
mock.patch('eventlet.sleep'),
mock.patch(
SERVERMANAGER + '.ServerPool.rest_call',
side_effect=servermanager.RemoteRestError(
reason='Failure to trigger except clause.'
)
),
mock.patch(
SERVERMANAGER + '.LOG.exception',
side_effect=KeyError('Failure to break loop')
)
) as (smock, rmock, lmock):
# should return immediately without consistency capability
pl.servers._consistency_watchdog()
self.assertFalse(smock.called)
pl.servers.capabilities = ['consistency']
self.assertRaises(KeyError,
pl.servers._consistency_watchdog)
rmock.assert_called_with('GET', '/health', '', {}, [], False)
self.assertEqual(1, len(lmock.mock_calls))
def setUp(self):
super(ProvidernetExtensionTestCase, self).setUp()
plugin = 'neutron.neutron_plugin_base_v2.NeutronPluginBaseV2'
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
# 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()
# Update the plugin and extensions path
self.setup_coreplugin(plugin)
cfg.CONF.set_override('allow_pagination', True)
cfg.CONF.set_override('allow_sorting', True)
self._plugin_patcher = mock.patch(plugin, autospec=True)
self.plugin = self._plugin_patcher.start()
# Ensure Quota checks never fail because of mock
instance = self.plugin.return_value
instance.get_networks_count.return_value = 1
# Instantiate mock plugin and enable the 'provider' extension
NeutronManager.get_plugin().supported_extension_aliases = (
["provider"])
ext_mgr = ProviderExtensionManager()
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.addCleanup(self._plugin_patcher.stop)
self.addCleanup(self._restore_attribute_map)
self.api = webtest.TestApp(router.APIRouter())
quota.QUOTAS._driver = None
cfg.CONF.set_override('quota_driver', 'neutron.quota.ConfDriver',
group='QUOTAS')
def test_port_vif_details(self):
plugin = NeutronManager.get_plugin()
with self.port(name='name') as port1:
ctx = context.get_admin_context()
port = plugin.get_port(ctx, port1['port']['id'])
self.assertEqual(port['binding:vif_type'],
portbindings.VIF_TYPE_OVS)
def test_cert_get_fail(self):
pl = NeutronManager.get_plugin()
pl.servers.ssl = True
with mock.patch('os.path.exists', return_value=False):
self.assertRaises(cfg.Error,
pl.servers._get_combined_cert_for_server,
*('example.org', 443))
def get_resources(cls):
"""Returns Ext Resources."""
parent_resource = dict(member_name="tenant",
collection_name="extensions/csco/tenants")
controller = CredentialController(NeutronManager.get_plugin())
return [extensions.ResourceExtension('credentials', controller,
parent=parent_resource)]
def test_file_put_contents(self):
pl = NeutronManager.get_plugin()
with mock.patch(SERVERMANAGER + '.open', create=True) as omock:
pl.servers._file_put_contents('somepath', 'contents')
omock.assert_has_calls([mock.call('somepath', 'w')])
omock.return_value.__enter__.return_value.assert_has_calls([
mock.call.write('contents')
])
def test_core_plugin_supports_services(self):
cfg.CONF.set_override("core_plugin", "neutron.tests.unit.test_neutron_manager." "MultiServiceCorePlugin")
mgr = NeutronManager.get_instance()
svc_plugins = mgr.get_service_plugins()
self.assertEqual(3, len(svc_plugins))
self.assertIn(constants.CORE, svc_plugins.keys())
self.assertIn(constants.LOADBALANCER, svc_plugins.keys())
self.assertIn(constants.DUMMY, svc_plugins.keys())
def setUp(self):
self.setup_patches()
self.setup_config_files()
ext_mgr = RouterRulesTestExtensionManager()
super(RouterDBTestCase, self).setUp(plugin=self._plugin_name,
ext_mgr=ext_mgr)
cfg.CONF.set_default('allow_overlapping_ips', False)
self.plugin_obj = NeutronManager.get_plugin()
def setUp(self):
self.setup_patches()
self.setup_config_files()
ext_mgr = RouterRulesTestExtensionManager()
super(RouterDBTestBase, self).setUp(plugin=self._plugin_name, ext_mgr=ext_mgr)
cfg.CONF.set_default("allow_overlapping_ips", False)
self.plugin_obj = NeutronManager.get_plugin()
self.startHttpPatch()
def test_load_plugin_with_full_options(self):
q_config.parse(['--config-file', BASE_CONF_PATH,
'--config-file', NSX_INI_FULL_PATH])
cfg.CONF.set_override('core_plugin', PLUGIN_NAME)
plugin = NeutronManager().get_plugin()
cluster = plugin.cluster
self._assert_required_options(cluster)
self._assert_extra_options(cluster)
def test_sticky_cert_fetch_fail(self):
pl = NeutronManager.get_plugin()
pl.servers.ssl = True
with mock.patch(
"ssl.get_server_certificate", side_effect=Exception("There is no more entropy in the universe")
) as sslgetmock:
self.assertRaises(cfg.Error, pl.servers._get_combined_cert_for_server, *("example.org", 443))
sslgetmock.assert_has_calls([mock.call(("example.org", 443))])
def _get_plugin_ref(self):
plugin_obj = NeutronManager.get_plugin()
if getattr(plugin_obj, "_master"):
plugin_ref = plugin_obj
else:
plugin_ref = getattr(plugin_obj, "_model")._plugins[const.VSWITCH_PLUGIN]
return plugin_ref
def test_ports_vif_details(self):
cfg.CONF.set_default("allow_overlapping_ips", True)
plugin = NeutronManager.get_plugin()
with contextlib.nested(self.port(), self.port()) as (port1, port2):
ctx = context.get_admin_context()
ports = plugin.get_ports(ctx)
self.assertEqual(len(ports), 2)
for port in ports:
self.assertEqual(port["binding:vif_type"], portbindings.VIF_TYPE_OVS)
def test_conflict_sync_raises_error_without_topology(self):
pl = NeutronManager.get_plugin()
pl.servers.get_topo_function = None
with mock.patch(SERVERMANAGER + '.ServerProxy.rest_call',
return_value=(httplib.CONFLICT, 0, 0, 0)):
# making a call should trigger a conflict sync that will
# error without the topology function set
self.assertRaises(cfg.Error, pl.servers.rest_call,
*('GET', '/', '', None, []))
def _delete_secgrp(self, context, secgrp_id):
try:
core_plugin = NeutronManager.get_plugin()
except AttributeError:
core_plugin = directory.get_plugin()
secgrp = core_plugin.get_security_group(context, secgrp_id)
secgrp_rules = secgrp['security_group_rules']
for secgrp_rule in secgrp_rules:
self._delete_secgrp_rule(context, secgrp_rule['id'])
def get_resources(cls):
"""Returns Ext Resources."""
controller = resource.Resource(
QuotaSetsController(NeutronManager.get_plugin()),
faults=base.FAULT_MAP)
return [extensions.ResourceExtension(
Quotasv2.get_alias(),
controller,
collection_actions={'tenant': 'GET'})]
def get_resources(cls):
"""Returns Ext Resources."""
controller = resource.Resource(
QuotaSetsController(NeutronManager.get_plugin()),
faults=base.FAULT_MAP)
return [extensions.ResourceExtension(
Quotasv2.get_alias(),
controller,
collection_actions={'tenant': 'GET'})]
def test_network_admin_state(self):
name = 'network_test'
admin_status_up = False
tenant_id = 'tenant_test'
network = {'network': {'name': name,
'admin_state_up': admin_status_up,
'tenant_id': tenant_id}}
plugin = NeutronManager.get_plugin()
self.assertEqual(plugin._network_admin_state(network), network)
def test_allocate_pools_for_subnet(self):
cidr = '10.0.0.0/24'
gateway_ip = '10.0.0.254'
subnet = {'gateway_ip': gateway_ip, 'cidr': cidr, 'ip_version': 4}
allocation_pool = [{"start": '10.0.0.2', "end": '10.0.0.253'}]
context = None
plugin = NeutronManager.get_plugin()
pool = plugin._allocate_pools_for_subnet(context, subnet)
self.assertEqual(allocation_pool, pool)
def _get_plugin_ref(self):
plugin_obj = NeutronManager.get_plugin()
if getattr(plugin_obj, "_master"):
plugin_ref = plugin_obj
else:
plugin_ref = getattr(plugin_obj, "_model").\
_plugins[const.VSWITCH_PLUGIN]
return plugin_ref
def setUp(self, plugin=None):
ext_mgr = (
test_extension_security_group.SecurityGroupTestExtensionManager())
super(PortSecurityTestCase, self).setUp(plugin=plugin, ext_mgr=ext_mgr)
# Check if a plugin supports security groups
plugin_obj = NeutronManager.get_plugin()
self._skip_security_group = ('security-group' not in
plugin_obj.supported_extension_aliases)
def test_delete_failure_sets_bad_hash(self):
pl = NeutronManager.get_plugin()
hash_handler = cdb.HashHandler()
with mock.patch(SERVERMANAGER + '.ServerProxy.rest_call',
return_value=(httplib.INTERNAL_SERVER_ERROR, 0, 0, 0)):
# a failed delete call should put a bad hash in the DB
pl.servers.rest_call('DELETE', '/', '', None, [])
self.assertEqual('INCONSISTENT,INCONSISTENT',
hash_handler.read_for_update())
def test_allocate_pools_for_subnet(self):
cidr = "10.0.0.0/24"
gateway_ip = "10.0.0.254"
subnet = {"gateway_ip": gateway_ip, "cidr": cidr, "ip_version": 4}
allocation_pool = [{"start": "10.0.0.2", "end": "10.0.0.253"}]
context = None
plugin = NeutronManager.get_plugin()
pool = plugin._allocate_pools_for_subnet(context, subnet)
self.assertEqual(allocation_pool, pool)
def test_no_cert_error(self):
pl = NeutronManager.get_plugin()
pl.servers.ssl = True
cfg.CONF.set_override("ssl_sticky", False, "RESTPROXY")
# pretend base dir exists and 3 children do, but host cert doesn't
with mock.patch("os.path.exists", side_effect=[True, True, True, True, False]) as exmock:
# will raise error because no certs found
self.assertRaises(cfg.Error, pl.servers._get_combined_cert_for_server, *("example.org", 443))
self.assertEqual(exmock.call_count, 5)
def test_core_plugin_supports_services(self):
cfg.CONF.set_override("core_plugin",
"neutron.tests.unit.test_neutron_manager."
"MultiServiceCorePlugin")
mgr = NeutronManager.get_instance()
svc_plugins = mgr.get_service_plugins()
self.assertEqual(3, len(svc_plugins))
self.assertIn(constants.CORE, svc_plugins.keys())
self.assertIn(constants.LOADBALANCER, svc_plugins.keys())
self.assertIn(constants.DUMMY, svc_plugins.keys())
def test_ports_vif_details(self):
cfg.CONF.set_default('allow_overlapping_ips', True)
plugin = NeutronManager.get_plugin()
with contextlib.nested(self.port(), self.port()) as (port1, port2):
ctx = context.get_admin_context()
ports = plugin.get_ports(ctx)
self.assertEqual(len(ports), 2)
for port in ports:
self.assertEqual(port['binding:vif_type'],
portbindings.VIF_TYPE_OVS)
def test_service_plugin_by_name_is_loaded(self):
cfg.CONF.set_override("core_plugin", DB_PLUGIN_KLASS)
cfg.CONF.set_override("service_plugins", ["dummy"])
mgr = NeutronManager.get_instance()
plugin = mgr.get_service_plugins()[constants.DUMMY]
self.assertTrue(
isinstance(plugin,
(dummy_plugin.DummyServicePlugin, types.ClassType)),
"loaded plugin should be of type neutronDummyPlugin")
