def test_create_delete_l3_policy_with_routers(self):
with self.router() as router1:
with self.router() as router2:
routers = [router1['router']['id'], router2['router']['id']]
l3p = self.create_l3_policy(routers=routers)
l3p_id = l3p['l3_policy']['id']
test_l3p_id = self._gbp_plugin.get_l3p_id_from_router_id(
nctx.get_admin_context(),
router1['router']['id'])
self.assertEqual(l3p_id, test_l3p_id)
test_l3p_id = self._gbp_plugin.get_l3p_id_from_router_id(
nctx.get_admin_context(),
router2['router']['id'])
self.assertEqual(l3p_id, test_l3p_id)
self.assertEqual(sorted(routers),
sorted(l3p['l3_policy']['routers']))
req = self.new_show_request('l3_policies', l3p_id,
fmt=self.fmt)
res = self.deserialize(self.fmt,
req.get_response(self.ext_api))
self.assertEqual(sorted(routers),
sorted(res['l3_policy']['routers']))
req = self.new_delete_request('l3_policies', l3p_id)
res = req.get_response(self.ext_api)
self.assertEqual(webob.exc.HTTPNoContent.code, res.status_int)
def _pull_missed_statuses(self):
LOG.debug("starting to pull pending statuses...")
plugin = directory.get_plugin()
filter = {"status": [n_const.PORT_STATUS_DOWN],
"vif_type": ["unbound"]}
ports = plugin.get_ports(context.get_admin_context(), filter)
if not ports:
LOG.debug("no down ports found, done")
return
port_fetch_url = utils.get_odl_url(self.PORT_PATH)
client = odl_client.OpenDaylightRestClient.create_client(
url=port_fetch_url)
for port in ports:
port_id = port["id"]
response = client.get(port_id)
if response.status_code != 200:
LOG.warning("Non-200 response code %s", str(response))
continue
odl_status = response.json()['port'][0]['status']
if odl_status == n_const.PORT_STATUS_ACTIVE:
# for now we only support transition from DOWN->ACTIVE
# See https://bugs.launchpad.net/networking-odl/+bug/1686023
provisioning_blocks.provisioning_complete(
context.get_admin_context(),
port_id, resources.PORT,
provisioning_blocks.L2_AGENT_ENTITY)
LOG.debug("done pulling pending statuses")
def test_delete_listener(self):
with self.loadbalancer(no_delete=True) as loadbalancer:
lb_id = loadbalancer['loadbalancer']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE, lb_id)
with self.listener(loadbalancer_id=lb_id,
no_delete=True) as listener:
listener_id = listener['listener']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE,
lb_id)
ctx = context.get_admin_context()
self.plugin_instance.delete_listener(
ctx, listener['listener']['id'])
calls = self.mock_api.delete_listener.call_args_list
_, called_listener, called_host = calls[0][0]
self.assertEqual(listener_id, called_listener.id)
self.assertEqual('host', called_host)
self.assertEqual(constants.PENDING_DELETE,
called_listener.provisioning_status)
ctx = context.get_admin_context()
lb = self.plugin_instance.db.get_loadbalancer(ctx, lb_id)
self.assertEqual(constants.ACTIVE,
lb.provisioning_status)
self.assertRaises(
loadbalancerv2.EntityNotFound,
self.plugin_instance.db.get_listener, ctx, listener_id)
def _extend_port_resource_request(port_res, port_db):
"""Add resource request to a port."""
port_res['resource_request'] = None
qos_policy = policy_object.QosPolicy.get_port_policy(
context.get_admin_context(), port_res['id'])
# Note(lajoskatona): QosPolicyPortBinding is not ready for some
# reasons, so let's try and fetch the QoS policy directly if there is a
# qos_policy_id in port_res.
if (not qos_policy and 'qos_policy_id' in port_res and
port_res['qos_policy_id']):
qos_policy = policy_object.QosPolicy.get_policy_obj(
context.get_admin_context(), port_res['qos_policy_id']
)
# Note(lajoskatona): handle the case when the port inherits qos-policy
# from the network.
if not qos_policy:
net = network_object.Network.get_object(
context.get_admin_context(), id=port_res['network_id'])
if net and net.qos_policy_id:
qos_policy = policy_object.QosPolicy.get_network_policy(
context.get_admin_context(), net.id)
if not qos_policy:
return port_res
resources = {}
rule_direction_class = {
nl_constants.INGRESS_DIRECTION:
pl_constants.CLASS_NET_BW_INGRESS_KBPS,
nl_constants.EGRESS_DIRECTION:
pl_constants.CLASS_NET_BW_EGRESS_KBPS
}
for rule in qos_policy.rules:
if rule.rule_type == qos_consts.RULE_TYPE_MINIMUM_BANDWIDTH:
resources[rule_direction_class[rule.direction]] = rule.min_kbps
if not resources:
return port_res
vnic_trait = pl_utils.vnic_type_trait(
port_res[portbindings.VNIC_TYPE])
# TODO(lajoskatona): Change to handle all segments when any traits
# support will be available. See Placement spec:
# https://review.openstack.org/565730
first_segment = network_object.NetworkSegment.get_objects(
context.get_admin_context(),
network_id=port_res['network_id'])[0]
if not first_segment or not first_segment.physical_network:
return port_res
physnet_trait = pl_utils.physnet_trait(
first_segment.physical_network)
resource_request = {
'required': [physnet_trait, vnic_trait],
'resources': resources
}
port_res['resource_request'] = resource_request
return port_res
def reschedule_resources_from_down_agents(self, agent_type,
get_down_bindings,
agent_id_attr,
resource_id_attr,
resource_name,
reschedule_resource,
rescheduling_failed):
"""Reschedule resources from down neutron agents
if admin state is up.
"""
agent_dead_limit = self.agent_dead_limit_seconds()
self.wait_down_agents(agent_type, agent_dead_limit)
context = ncontext.get_admin_context()
try:
down_bindings = get_down_bindings(context, agent_dead_limit)
agents_back_online = set()
for binding in down_bindings:
binding_agent_id = getattr(binding, agent_id_attr)
binding_resource_id = getattr(binding, resource_id_attr)
if binding_agent_id in agents_back_online:
continue
else:
# we need new context to make sure we use different DB
# transaction - otherwise we may fetch same agent record
# each time due to REPEATABLE_READ isolation level
context = ncontext.get_admin_context()
agent = self._get_agent(context, binding_agent_id)
if agent.is_active:
agents_back_online.add(binding_agent_id)
continue
LOG.warning(
"Rescheduling %(resource_name)s %(resource)s from agent "
"%(agent)s because the agent did not report to the server "
"in the last %(dead_time)s seconds.",
{'resource_name': resource_name,
'resource': binding_resource_id,
'agent': binding_agent_id,
'dead_time': agent_dead_limit})
try:
reschedule_resource(context, binding_resource_id)
except (rescheduling_failed, oslo_messaging.RemoteError):
# Catch individual rescheduling errors here
# so one broken one doesn't stop the iteration.
LOG.exception("Failed to reschedule %(resource_name)s "
"%(resource)s",
{'resource_name': resource_name,
'resource': binding_resource_id})
except Exception:
# we want to be thorough and catch whatever is raised
# to avoid loop abortion
LOG.exception("Exception encountered during %(resource_name)s "
"rescheduling.",
{'resource_name': resource_name})
def _gen_port(self):
network_id = self.plugin.create_network(context.get_admin_context(), {
'network':
{'name': 'pecannet', 'tenant_id': 'tenid', 'shared': False,
'admin_state_up': True, 'status': 'ACTIVE'}})['id']
self.port = self.plugin.create_port(context.get_admin_context(), {
'port':
{'tenant_id': 'tenid', 'network_id': network_id,
'fixed_ips': n_const.ATTR_NOT_SPECIFIED,
'mac_address': '00:11:22:33:44:55',
'admin_state_up': True, 'device_id': 'FF',
'device_owner': 'pecan', 'name': 'pecan'}})
def test_member_crud(self):
with self.subnet(cidr='10.0.0.0/24') as s:
with self.loadbalancer(subnet=s) as lb:
lb_id = lb['loadbalancer']['id']
with self.listener(loadbalancer_id=lb_id) as l:
listener_id = l['listener']['id']
with self.pool(
protocol=lb_con.PROTOCOL_HTTP,
listener_id=listener_id) as p:
pool_id = p['pool']['id']
with self.member(
no_delete=True, address='10.0.1.10',
pool_id=pool_id, subnet=s) as m1:
member1_id = m1['member']['id']
self.driver_rest_call_mock.reset_mock()
rest_call_function_mock.__dict__.update(
{'WORKFLOW_MISSING': False})
with self.member(
no_delete=True, pool_id=pool_id,
subnet=s, address='10.0.1.20') as m2:
member2_id = m2['member']['id']
self.compare_apply_call()
self.driver_rest_call_mock.reset_mock()
m = self.plugin_instance.db.get_pool_member(
context.get_admin_context(),
m1['member']['id']).to_dict(pool=False)
m['weight'] = 2
self.plugin_instance.update_pool_member(
context.get_admin_context(),
m1['member']['id'], p['pool']['id'],
{'member': m})
self.update_member(pool_id, id=member1_id,
weight=2)
self.compare_apply_call()
self.driver_rest_call_mock.reset_mock()
self.plugin_instance.delete_pool_member(
context.get_admin_context(),
member2_id, pool_id)
self.delete_member(member2_id, pool_id)
self.compare_apply_call()
lb = self.plugin_instance.db.get_loadbalancer(
context.get_admin_context(),
lb_id).to_dict(listener=False)
self.assertEqual('ACTIVE',
lb['provisioning_status'])
def _flood_cache_for_query(self, rtype, **filter_kwargs):
"""Load info from server for first query.
Queries the server if this is the first time a given query for
rtype has been issued.
"""
query_ids = self._get_query_ids(rtype, filter_kwargs)
if query_ids.issubset(self._satisfied_server_queries):
# we've already asked the server this question so we don't
# ask directly again because any updates will have been
# pushed to us
return
context = n_ctx.get_admin_context()
resources = self._puller.bulk_pull(context, rtype,
filter_kwargs=filter_kwargs)
for resource in resources:
if self._is_stale(rtype, resource):
# if the server was slow enough to respond the object may have
# been updated already and pushed to us in another thread.
LOG.debug("Ignoring stale update for %s: %s", rtype, resource)
continue
self.record_resource_update(context, rtype, resource)
LOG.debug("%s resources returned for queries %s", len(resources),
query_ids)
self._satisfied_server_queries.update(query_ids)
def setUp(self):
super(TestDhcpSchedulerBaseTestCase, self).setUp()
self.setup_coreplugin(self.CORE_PLUGIN)
self.ctx = context.get_admin_context()
self.network = {'id': 'foo_network_id'}
self.network_id = 'foo_network_id'
self._save_networks([self.network_id])
def test_floatingip_update_qos_policy_id(self):
ctx = context.get_admin_context()
policy_obj_1 = policy.QosPolicy(ctx,
id=uuidutils.generate_uuid(),
project_id='tenant', name='pol2',
rules=[])
policy_obj_1.create()
policy_obj_2 = policy.QosPolicy(ctx,
id=uuidutils.generate_uuid(),
project_id='tenant', name='pol3',
rules=[])
policy_obj_2.create()
with self.subnet(cidr='11.0.0.0/24') as s:
network_id = s['subnet']['network_id']
self._set_net_external(network_id)
fip = self._make_floatingip(
self.fmt,
network_id,
qos_policy_id=policy_obj_1.id)
self.assertEqual(policy_obj_1.id,
fip['floatingip'][qos_consts.QOS_POLICY_ID])
body = self._show('floatingips', fip['floatingip']['id'])
self.assertEqual(policy_obj_1.id,
body['floatingip'][qos_consts.QOS_POLICY_ID])
body = self._update(
'floatingips', fip['floatingip']['id'],
{'floatingip': {qos_consts.QOS_POLICY_ID: policy_obj_2.id}})
self.assertEqual(policy_obj_2.id,
body['floatingip'][qos_consts.QOS_POLICY_ID])
def test_create_health_monitor(self):
with self.loadbalancer(no_delete=True) as loadbalancer:
lb_id = loadbalancer['loadbalancer']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE, lb_id)
with self.listener(loadbalancer_id=lb_id,
no_delete=True) as listener:
listener_id = listener['listener']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE,
lb_id)
with self.pool(listener_id=listener_id, loadbalancer_id=lb_id,
no_delete=True) as pool:
pool_id = pool['pool']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE,
lb_id)
with self.healthmonitor(pool_id=pool_id,
no_delete=True) as monitor:
hm_id = monitor['healthmonitor']['id']
calls = (
self.mock_api.create_healthmonitor.call_args_list)
_, called_hm, called_host = calls[0][0]
self.assertEqual(hm_id, called_hm.id)
self.assertEqual('host', called_host)
self.assertEqual(constants.PENDING_CREATE,
called_hm.provisioning_status)
ctx = context.get_admin_context()
lb = self.plugin_instance.db.get_loadbalancer(
ctx, lb_id)
self.assertEqual(constants.PENDING_UPDATE,
lb.provisioning_status)
def setUp(self):
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(OVSFlowClassifierDriverTestCase, 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()
self.driver = driver.OVSFlowClassifierDriver()
self.driver.initialize()
def create_port_changed_event(self, action, original_obj, returned_obj):
port = None
if action in ['update_port', 'delete_port']:
port = returned_obj['port']
elif action in ['update_floatingip', 'create_floatingip',
'delete_floatingip']:
# NOTE(arosen) if we are associating a floatingip the
# port_id is in the returned_obj. Otherwise on disassociate
# it's in the original_object
port_id = (returned_obj['floatingip'].get('port_id') or
original_obj.get('port_id'))
if port_id is None:
return
ctx = context.get_admin_context()
try:
port = directory.get_plugin().get_port(ctx, port_id)
except exc.PortNotFound:
LOG.debug("Port %s was deleted, no need to send any "
"notification", port_id)
return
if port and self._is_compute_port(port):
if action == 'delete_port':
return self._get_port_delete_event(port)
else:
return self._get_network_changed_event(port['device_id'])
def test_update_pool(self):
ctx = context.get_admin_context()
with self.loadbalancer(no_delete=True) as loadbalancer:
lb_id = loadbalancer['loadbalancer']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE, lb_id)
with self.listener(loadbalancer_id=lb_id,
no_delete=True) as listener:
listener_id = listener['listener']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE,
lb_id)
with self.pool(loadbalancer_id=lb_id, listener_id=listener_id,
no_delete=True) as pool:
pool_id = pool['pool']['id']
old_name = pool['pool']['name']
self._update_status(models.LoadBalancer, constants.ACTIVE,
lb_id)
new_name = 'new_name'
pool['pool']['name'] = new_name
self.plugin_instance.update_pool(ctx, pool_id, pool)
calls = self.mock_api.update_pool.call_args_list
(_, old_called_pool,
new_called_pool, called_host) = calls[0][0]
self.assertEqual(pool_id, new_called_pool.id)
self.assertEqual(pool_id, old_called_pool.id)
self.assertEqual(old_name, old_called_pool.name)
self.assertEqual(new_name, new_called_pool.name)
self.assertEqual(constants.PENDING_UPDATE,
new_called_pool.provisioning_status)
lb = self.plugin_instance.db.get_loadbalancer(ctx, lb_id)
self.assertEqual(constants.PENDING_UPDATE,
lb.provisioning_status)
self.assertEqual('host', called_host)
def test_create_member(self):
with self.loadbalancer(no_delete=True) as loadbalancer:
lb_id = loadbalancer['loadbalancer']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE, lb_id)
with self.listener(loadbalancer_id=lb_id,
no_delete=True) as listener:
listener_id = listener['listener']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE,
lb_id)
with self.pool(listener_id=listener_id, loadbalancer_id=lb_id,
no_delete=True) as pool:
pool_id = pool['pool']['id']
self._update_status(models.LoadBalancer, constants.ACTIVE,
lb_id)
with self.subnet(cidr='11.0.0.0/24') as subnet:
with self.member(pool_id=pool_id, subnet=subnet,
no_delete=True) as member:
member_id = member['member']['id']
calls = self.mock_api.create_member.call_args_list
_, called_member, called_host = calls[0][0]
self.assertEqual(member_id, called_member.id)
self.assertEqual('host', called_host)
self.assertEqual(constants.PENDING_CREATE,
called_member.provisioning_status)
ctx = context.get_admin_context()
lb = self.plugin_instance.db.get_loadbalancer(
ctx, lb_id)
self.assertEqual(constants.PENDING_UPDATE,
lb.provisioning_status)
def sync_allocations(self):
# determine current configured allocatable tunnel ids
tunnel_ids = set()
ranges = self.get_network_segment_ranges()
for tun_min, tun_max in ranges:
tunnel_ids |= set(moves.range(tun_min, tun_max + 1))
tunnel_id_getter = operator.attrgetter(self.segmentation_key)
tunnel_col = getattr(self.model, self.segmentation_key)
ctx = context.get_admin_context()
with db_api.CONTEXT_WRITER.using(ctx):
# remove from table unallocated tunnels not currently allocatable
# fetch results as list via all() because we'll be iterating
# through them twice
allocs = ctx.session.query(self.model).all()
# collect those vnis that needs to be deleted from db
unallocateds = (
tunnel_id_getter(a) for a in allocs if not a.allocated)
to_remove = (x for x in unallocateds if x not in tunnel_ids)
# Immediately delete tunnels in chunks. This leaves no work for
# flush at the end of transaction
for chunk in chunks(to_remove, self.BULK_SIZE):
(ctx.session.query(self.model).filter(tunnel_col.in_(chunk)).
filter_by(allocated=False).delete(synchronize_session=False))
# collect vnis that need to be added
existings = {tunnel_id_getter(a) for a in allocs}
missings = list(tunnel_ids - existings)
for chunk in chunks(missings, self.BULK_SIZE):
bulk = [{self.segmentation_key: x, 'allocated': False}
for x in chunk]
ctx.session.execute(self.model.__table__.insert(), bulk)
def __enter__(self):
try:
context = q_context.get_admin_context()
db_storage_driver = cert_utils.DbCertificateStorageDriver(
context)
with client_cert.ClientCertificateManager(
cert_utils.NSX_OPENSTACK_IDENTITY,
None,
db_storage_driver) as cert_manager:
if not cert_manager.exists():
msg = _("Unable to load from nsx-db")
raise nsx_exc.ClientCertificateException(err_msg=msg)
filename = self._filename
if not os.path.exists(os.path.dirname(filename)):
if len(os.path.dirname(filename)) > 0:
fileutils.ensure_tree(os.path.dirname(filename))
cert_manager.export_pem(filename)
expires_in_days = cert_manager.expires_in_days()
self._check_expiration(expires_in_days)
except Exception as e:
self._on_exit()
raise e
return self
def setUp(self):
plugin = 'neutron.tests.unit.extensions.test_agent.TestAgentPlugin'
# for these tests we need to enable overlapping ips
cfg.CONF.set_default('allow_overlapping_ips', True)
ext_mgr = AgentTestExtensionManager()
super(AgentDBTestCase, self).setUp(plugin=plugin, ext_mgr=ext_mgr)
self.adminContext = context.get_admin_context()
def test_network_create_with_bad_provider_attrs_400(self):
ctx = context.get_admin_context()
ctx.tenant_id = 'an_admin'
bad_data = {provider_net.SEGMENTATION_ID: "abc"}
res, _1 = self._post_network_with_bad_provider_attrs(ctx, bad_data,
True)
self.assertEqual(web_exc.HTTPBadRequest.code, res.status_int)
def _extract(self, resource_type, resource_id, field):
# NOTE(salv-orlando): This check currently assumes the parent
# resource is handled by the core plugin. It might be worth
# having a way to map resources to plugins so to make this
# check more general
plugin = directory.get_plugin()
if resource_type in service_const.EXT_PARENT_RESOURCE_MAPPING:
plugin = directory.get_plugin(
service_const.EXT_PARENT_RESOURCE_MAPPING[resource_type])
f = getattr(plugin, 'get_%s' % resource_type)
# f *must* exist, if not found it is better to let neutron
# explode. Check will be performed with admin context
try:
data = f(context.get_admin_context(),
resource_id,
fields=[field])
except exceptions.NotFound as e:
# NOTE(kevinbenton): a NotFound exception can occur if a
# list operation is happening at the same time as one of
# the parents and its children being deleted. So we issue
# a RetryRequest so the API will redo the lookup and the
# problem items will be gone.
raise db_exc.RetryRequest(e)
except Exception:
with excutils.save_and_reraise_exception():
LOG.exception('Policy check error while calling %s!', f)
return data[field]
def _ext_extend_subnet_dict(result, subnetdb):
ctx = n_context.get_admin_context()
# get the core plugin as this is a static method with no 'self'
plugin = directory.get_plugin()
with db_api.CONTEXT_WRITER.using(ctx):
plugin._extension_manager.extend_subnet_dict(
ctx.session, subnetdb, result)
def setUp(self):
super(QosCoreResourceExtensionTestCase, self).setUp()
self.core_extension = qos_core.QosCoreResourceExtension()
policy_p = mock.patch('neutron.objects.qos.policy.QosPolicy')
self.policy_m = policy_p.start()
self.context = context.get_admin_context()
self.non_admin_context = context.Context('user_id', 'tenant_id')
def setUp(self):
super(TestDriverController, self).setUp()
self.setup_coreplugin(DB_PLUGIN_KLASS)
self.fake_l3 = mock.Mock()
self.dc = driver_controller.DriverController(self.fake_l3)
self.fake_l3.l3_driver_controller = self.dc
self.ctx = context.get_admin_context()
def tag_default_ports(resource, event, trigger, **kwargs):
nsxlib = v3_utils.get_connected_nsxlib()
admin_cxt = neutron_context.get_admin_context()
filters = v3_utils.get_plugin_filters(admin_cxt)
# the plugin creation below will create the NS group and update the default
# OS section to have the correct applied to group
with v3_utils.NsxV3PluginWrapper() as _plugin:
neutron_ports = _plugin.get_ports(admin_cxt, filters=filters)
for port in neutron_ports:
neutron_id = port['id']
# get the network nsx id from the mapping table
nsx_id = plugin_utils.get_port_nsx_id(admin_cxt.session,
neutron_id)
if not nsx_id:
continue
device_owner = port['device_owner']
if (device_owner == l3_db.DEVICE_OWNER_ROUTER_INTF or
device_owner == const.DEVICE_OWNER_DHCP):
continue
ps = _plugin._get_port_security_binding(admin_cxt,
neutron_id)
if not ps:
continue
try:
nsx_port = nsxlib.logical_port.get(nsx_id)
except nsx_exc.ResourceNotFound:
continue
tags_update = nsx_port['tags']
tags_update += [{'scope': security.PORT_SG_SCOPE,
'tag': plugin.NSX_V3_DEFAULT_SECTION}]
nsxlib.logical_port.update(nsx_id, None,
tags_update=tags_update)
def delete_agent_gateway_port(self, context, **kwargs):
"""Delete Floatingip agent gateway port."""
network_id = kwargs.get('network_id')
host = kwargs.get('host')
admin_ctx = neutron_context.get_admin_context()
self.l3plugin.delete_floatingip_agent_gateway_port(
admin_ctx, host, network_id)
def setUp(self):
super(TestOVSDBData, self).setUp()
self.context = context.get_admin_context()
self.ovsdb_identifier = 'fake_ovsdb_id'
mock.patch.object(directory, 'get_plugin').start()
mock.patch.object(managers, 'TypeManager').start()
self.ovsdb_data = data.OVSDBData(self.ovsdb_identifier)
def setUp(self):
super(FlavorPluginTestCase, self).setUp()
self.config_parse()
cfg.CONF.set_override(
'service_plugins',
['neutron.tests.unit.extensions.test_flavors.DummyServicePlugin'])
self.useFixture(
fixtures.MonkeyPatch('neutron.manager.NeutronManager._instance'))
self.plugin = flavors_plugin.FlavorsPlugin()
self.ctx = context.get_admin_context()
providers = [DummyServiceDriver.get_service_type() +
":" + _provider + ":" + _driver]
self.service_manager = servicetype_db.ServiceTypeManager.get_instance()
self.service_providers = mock.patch.object(
provconf.NeutronModule, 'service_providers').start()
self.service_providers.return_value = providers
for provider in providers:
self.service_manager.add_provider_configuration(
provider.split(':')[0], provconf.ProviderConfiguration())
dbapi.context_manager.writer.get_engine()
def _register_agent(agent, plugin=None):
if not plugin:
plugin = FakePlugin()
admin_context = context.get_admin_context()
plugin.create_or_update_agent(admin_context, agent)
return plugin._get_agent_by_type_and_host(
admin_context, agent['agent_type'], agent['host'])
def setUp(self):
super(L3SchedulerBaseTest, self).setUp(PLUGIN_NAME)
self.l3_plugin = l3_router_plugin.L3RouterPlugin()
directory.add_plugin(plugin_constants.L3, self.l3_plugin)
self.adminContext = context.get_admin_context()
self.adminContext.tenant_id = _uuid()
def setUp(self):
super(TestSubnetAllocation, self).setUp()
self._tenant_id = 'test-tenant'
self.setup_coreplugin(test_db_base_plugin_v2.DB_PLUGIN_KLASS)
self.plugin = directory.get_plugin()
self.ctx = context.get_admin_context()
cfg.CONF.set_override('allow_overlapping_ips', True)
def set_agent_admin_state(agent_id, admin_state_up=False):
FakePlugin().update_agent(context.get_admin_context(), agent_id,
{'agent': {
'admin_state_up': admin_state_up
}})
def setUp(self):
super(TestIpamDriverLoader, self).setUp()
self.ctx = context.get_admin_context()
def context(self):
if 'neutron.context' not in self.environ:
self.environ['neutron.context'] = context.get_admin_context()
return self.environ['neutron.context']
def setUp(self):
super(TestHashRing, self).setUp()
self.admin_ctx = context.get_admin_context()
self.addCleanup(self._delete_objs)
def __init__(self):
super(NeutronDbClient, self)
self.context = neutron_context.get_admin_context()
def test_distributed_binding_multi_host_status(self):
ctx = context.get_admin_context()
with self.port(device_owner=const.DEVICE_OWNER_DVR_INTERFACE) as port:
port_id = port['port']['id']
# Update port to bind for 1st host.
self.plugin.update_distributed_port_binding(
ctx, port_id, {
'port': {
portbindings.HOST_ID: 'host-ovs-no_filter',
'device_id': 'router1'
}
})
# Mark 1st device up.
self.plugin.endpoints[0].update_device_up(
ctx,
agent_id="theAgentId",
device=port_id,
host='host-ovs-no_filter')
# Get port and verify status is ACTIVE.
port = self._show('ports', port_id)
self.assertEqual('ACTIVE', port['port']['status'])
# Update port to bind for a 2nd host.
self.plugin.update_distributed_port_binding(
ctx, port_id, {
'port': {
portbindings.HOST_ID: 'host-bridge-filter',
'device_id': 'router1'
}
})
# Mark 2nd device up.
self.plugin.endpoints[0].update_device_up(
ctx,
agent_id="the2ndAgentId",
device=port_id,
host='host-bridge-filter')
# Get port and verify status unchanged.
port = self._show('ports', port_id)
self.assertEqual('ACTIVE', port['port']['status'])
# Mark 1st device down.
self.plugin.endpoints[0].update_device_down(
ctx,
agent_id="theAgentId",
device=port_id,
host='host-ovs-no_filter')
# Get port and verify status unchanged.
port = self._show('ports', port_id)
self.assertEqual('ACTIVE', port['port']['status'])
# Mark 2nd device down.
self.plugin.endpoints[0].update_device_down(
ctx,
agent_id="the2ndAgentId",
device=port_id,
host='host-bridge-filter')
# Get port and verify status is DOWN.
port = self._show('ports', port_id)
self.assertEqual('DOWN', port['port']['status'])
def test_distributed_binding(self):
ctx = context.get_admin_context()
with self.port(device_owner=const.DEVICE_OWNER_DVR_INTERFACE) as port:
port_id = port['port']['id']
# Verify port's VIF type and status.
self.assertEqual(portbindings.VIF_TYPE_DISTRIBUTED,
port['port'][portbindings.VIF_TYPE])
self.assertEqual('DOWN', port['port']['status'])
# Update port to bind for a host.
self.plugin.update_distributed_port_binding(
ctx, port_id, {
'port': {
portbindings.HOST_ID: 'host-ovs-no_filter',
'device_id': 'router1'
}
})
# Get port and verify VIF type and status unchanged.
port = self._show('ports', port_id)
self.assertEqual(portbindings.VIF_TYPE_DISTRIBUTED,
port['port'][portbindings.VIF_TYPE])
self.assertEqual('DOWN', port['port']['status'])
# Get and verify binding details for host
details = self.plugin.endpoints[0].get_device_details(
ctx,
agent_id="theAgentId",
device=port_id,
host='host-ovs-no_filter')
self.assertEqual('local', details['network_type'])
# Get port and verify VIF type and changed status.
port = self._show('ports', port_id)
self.assertEqual(portbindings.VIF_TYPE_DISTRIBUTED,
port['port'][portbindings.VIF_TYPE])
self.assertEqual('BUILD', port['port']['status'])
# Mark device up.
self.plugin.endpoints[0].update_device_up(
ctx,
agent_id="theAgentId",
device=port_id,
host='host-ovs-no_filter')
# Get port and verify VIF type and changed status.
port = self._show('ports', port_id)
self.assertEqual(portbindings.VIF_TYPE_DISTRIBUTED,
port['port'][portbindings.VIF_TYPE])
self.assertEqual('ACTIVE', port['port']['status'])
# Mark device down.
self.plugin.endpoints[0].update_device_down(
ctx,
agent_id="theAgentId",
device=port_id,
host='host-ovs-no_filter')
# Get port and verify VIF type and changed status.
port = self._show('ports', port_id)
self.assertEqual(portbindings.VIF_TYPE_DISTRIBUTED,
port['port'][portbindings.VIF_TYPE])
self.assertEqual('DOWN', port['port']['status'])
def schedule_bgp_speaker_callback(self, resource, event, trigger, payload):
plugin = payload['plugin']
if event == events.AFTER_CREATE:
ctx = nl_context.get_admin_context()
plugin.schedule_bgp_speaker(ctx, payload['bgp_speaker'])
def setUp(self):
super(TestDbQuotaDriver, self).setUp()
self.plugin = FakePlugin()
self.context = context.get_admin_context()
def __init__(self, group_name):
self._hash_ring = None
self._last_time_loaded = None
self._cache_startup_timeout = True
self._group = group_name
self.admin_ctx = context.get_admin_context()
def setUp(self):
super(SecurityGroupDbMixinTestCase, self).setUp()
self.setup_coreplugin(core_plugin=DB_PLUGIN_KLASS)
self.ctx = context.get_admin_context()
self.mixin = SecurityGroupDbMixinImpl()
def setUp(self):
super(L3DvrTestCase, self).setUp(plugin='ml2')
self.core_plugin = directory.get_plugin()
self.ctx = context.get_admin_context()
self.mixin = FakeL3Plugin()
directory.add_plugin(plugin_constants.L3, self.mixin)
def __init__(self):
# initialize the availability zones
config.register_nsxv3_azs(cfg.CONF, cfg.CONF.nsx_v3.availability_zones)
super(NsxV3PluginWrapper, self).__init__()
self.context = context.get_admin_context()
def setUp(self):
super(Ml2DBTestCase, self).setUp()
self.ctx = context.get_admin_context()
self.setup_coreplugin(PLUGIN_NAME)
def test_floatingip_update_with_port_and_qos_scenarios(self):
ctx = context.get_admin_context()
policy_obj_1 = policy.QosPolicy(ctx,
id=uuidutils.generate_uuid(),
project_id='tenant',
name='pol2',
rules=[])
policy_obj_1.create()
policy_obj_2 = policy.QosPolicy(ctx,
id=uuidutils.generate_uuid(),
project_id='tenant',
name='pol3',
rules=[])
policy_obj_2.create()
with self.network() as ext_net:
network_id = ext_net['network']['id']
self._set_net_external(network_id)
with self.subnet(ext_net, cidr='10.10.10.0/24'), self.router(
) as router, self.subnet(
cidr='11.0.0.0/24') as private_subnet, self.port(
private_subnet) as port_1, self.port(
private_subnet) as port_2:
self._add_external_gateway_to_router(router['router']['id'],
network_id)
self._router_interface_action('add', router['router']['id'],
private_subnet['subnet']['id'],
None)
fip = self._make_floatingip(self.fmt, network_id)
self.assertIsNone(fip['floatingip'].get('port_id'))
self.assertIsNone(fip['floatingip'].get(
qos_consts.QOS_POLICY_ID))
# update from: {port_id: null, qos_policy_id: null}
# to : {port_id: port_id_1, qos_policy_id: null}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'], port_1['port']['id'], None)
# update from: {port_id: port_id_1, qos_policy_id: null}
# to : {port_id: port_id_1, qos_policy_id: policy_1}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'], port_1['port']['id'],
policy_obj_1.id)
# update from: {port_id: port_id_1, qos_policy_id: policy_1}
# to : {port_id: port_id_2, qos_policy_id: policy_2}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'], port_2['port']['id'],
policy_obj_2.id)
# update from: {port_id: port_id_2, qos_policy_id: policy_2}
# to : {port_id: port_id_1, qos_policy_id: null}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'], port_1['port']['id'], None)
# update from: {port_id: port_id_1, qos_policy_id: null}
# to : {port_id: null, qos_policy_id: policy_1}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'], None, policy_obj_1.id)
# update from: {port_id: null, qos_policy_id: policy_1}
# to : {port_id: null, qos_policy_id: null}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'])
def __init__(self):
super(NeutronDbClient, self).__init__()
self.context = context.get_admin_context()
self.filters = get_plugin_filters(self.context)
def setUp(self):
super(LoggingRpcCallbackTestCase, self).setUp()
self.context = context.get_admin_context()
self.rpc_callback = server_rpc.LoggingApiSkeleton()
def setUp(self):
super(LoggingDBApiTestCase, self).setUp()
self.context = context.get_admin_context()
self.sg_id, self.port_id, self.tenant_id = self._create_sg_and_port()
def setUp(self):
super(TestUtils, self).setUp()
self.ctx = context.get_admin_context()
def test_firewall_group_deleted_not_found(self):
ctx = context.get_admin_context()
observed = self.callbacks.firewall_group_deleted(ctx, 'notfound')
self.assertTrue(observed)
def get_ovn_db_revisions():
ctx = context.get_admin_context()
return [
row[0] for row in ctx.session.execute("SELECT version_num from %s;" %
OVN_ALEMBIC_TABLE_NAME)
] # nosec
def _create_quota_usage(self, resource, used, tenant_id=None):
tenant_id = tenant_id or self.tenant_id
return quota_api.set_quota_usage(context.get_admin_context(),
resource,
tenant_id,
in_use=used)
def port_mac_addresses():
ctx = context.get_admin_context()
return [
port[0]
for port in ctx.session.query(models_v2.Port.mac_address).all()
]
def get_network_availability_zones(self, net_db):
ctx = n_context.get_admin_context()
p = self._get_plugin_from_project(ctx, net_db['tenant_id'])
return p.get_network_availability_zones(net_db)
def check_for_inconsistencies(self):
# Only the worker holding a valid lock within OVSDB will run
# this periodic
if not self.has_lock:
return
admin_context = n_context.get_admin_context()
create_update_inconsistencies = (
revision_numbers_db.get_inconsistent_resources(admin_context))
delete_inconsistencies = (
revision_numbers_db.get_deleted_resources(admin_context))
if not any([create_update_inconsistencies, delete_inconsistencies]):
LOG.debug('Maintenance task: No inconsistencies found. Skipping')
return
LOG.debug('Maintenance task: Synchronizing Neutron '
'and OVN databases')
self._log_maintenance_inconsistencies(create_update_inconsistencies,
delete_inconsistencies)
self._sync_timer.restart()
dbg_log_msg = ('Maintenance task: Fixing resource %(res_uuid)s '
'(type: %(res_type)s) at %(type_)s')
# Fix the create/update resources inconsistencies
for row in create_update_inconsistencies:
LOG.debug(dbg_log_msg, {'res_uuid': row.resource_uuid,
'res_type': row.resource_type,
'type_': INCONSISTENCY_TYPE_CREATE_UPDATE})
try:
# NOTE(lucasagomes): The way to fix subnets is bit
# different than other resources. A subnet in OVN language
# is just a DHCP rule but, this rule only exist if the
# subnet in Neutron has the "enable_dhcp" attribute set
# to True. So, it's possible to have a consistent subnet
# resource even when it does not exist in the OVN database.
if row.resource_type == ovn_const.TYPE_SUBNETS:
self._fix_create_update_subnet(admin_context, row)
else:
self._fix_create_update(admin_context, row)
except Exception:
LOG.exception('Maintenance task: Failed to fix resource '
'%(res_uuid)s (type: %(res_type)s)',
{'res_uuid': row.resource_uuid,
'res_type': row.resource_type})
# Fix the deleted resources inconsistencies
for row in delete_inconsistencies:
LOG.debug(dbg_log_msg, {'res_uuid': row.resource_uuid,
'res_type': row.resource_type,
'type_': INCONSISTENCY_TYPE_DELETE})
try:
if row.resource_type == ovn_const.TYPE_SUBNETS:
self._ovn_client.delete_subnet(admin_context,
row.resource_uuid)
else:
self._fix_delete(admin_context, row)
except Exception:
LOG.exception('Maintenance task: Failed to fix deleted '
'resource %(res_uuid)s (type: %(res_type)s)',
{'res_uuid': row.resource_uuid,
'res_type': row.resource_type})
self._sync_timer.stop()
LOG.info('Maintenance task: Synchronization finished '
'(took %.2f seconds)', self._sync_timer.elapsed())
def get_router_availability_zones(self, router):
ctx = n_context.get_admin_context()
p = self._get_plugin_from_project(ctx, router['tenant_id'])
return p.get_router_availability_zones(router)
def get_networks():
ctx = context.get_admin_context()
query = model_query.get_collection_query(ctx, models_v2.Network)
return query.all()
def __init__(self, group):
self._group = group
self.ctx = n_context.get_admin_context()
def setUp(self):
self.context = context.get_admin_context()
super(NetworkRbacTestcase, self).setUp()
def table_exists(table_name):
ctx = context.get_admin_context()
tables = [t[0] for t in ctx.session.execute("SHOW TABLES;")]
return table_name in tables
