def test_security_group_precommit_create_event_fail(self):
registry.subscribe(fake_callback, resources.SECURITY_GROUP, events.PRECOMMIT_CREATE)
with mock.patch.object(sqlalchemy.orm.session.SessionTransaction, "rollback") as mock_rollback:
self.assertRaises(
securitygroup.SecurityGroupConflict, self.mixin.create_security_group, self.ctx, FAKE_SECGROUP
)
self.assertTrue(mock_rollback.called)
def register(callback, agent_type):
"""Subscribe callback to init event for the specified agent.
:param agent_type: an agent type as defined in neutron_lib.constants.
:param callback: a callback that can process the agent init event.
"""
registry.subscribe(callback, agent_type, events.AFTER_INIT)
def subscribe(self):
# REVISIT(Ryu): Keep an extra set of strong references to the callback
# methods so that they are not prematurely garbage collected.
# This hack is required in the Liberty branch (not stable/kilo) because
# currently the Liberty mechanism driver is expected to work with Kilo
# ML2 plugin for MidoNet, and in Kilo ML2, there is a bug in which
# these methods were referenced as weakrefs where a garbage collection
# could remove these callbacks if they were part of an object.
self._create_sg_f = self.create_security_group
self._update_sg_f = self.update_security_group
self._delete_sg_f = self.delete_security_group
self._create_sgr_f = self.create_security_group_rule
self._delete_sgr_f = self.delete_security_group_rule
registry.subscribe(
self._create_sg_f, resources.SECURITY_GROUP, events.AFTER_CREATE)
registry.subscribe(
self._update_sg_f, resources.SECURITY_GROUP, events.AFTER_UPDATE)
registry.subscribe(
self._delete_sg_f, resources.SECURITY_GROUP, events.AFTER_DELETE)
registry.subscribe(
self._create_sgr_f, resources.SECURITY_GROUP_RULE,
events.AFTER_CREATE)
registry.subscribe(
self._delete_sgr_f, resources.SECURITY_GROUP_RULE,
events.AFTER_DELETE)
def setUp(self):
super(TestStatusBarriers, self).setUp()
self.ctx = n_ctx.get_admin_context()
self.provisioned = mock.Mock()
self.port = self._make_port()
registry.subscribe(self.provisioned, resources.PORT,
pb.PROVISIONING_COMPLETE)
def subscribe():
registry.subscribe(_update_segment_host_mapping_for_agent,
resources.AGENT,
events.AFTER_CREATE)
registry.subscribe(_update_segment_host_mapping_for_agent,
resources.AGENT,
events.AFTER_UPDATE)
def __init__(self):
# FIXME(jamielennox): A notifier is being created for each Controller
# and each Notifier is handling it's own auth. That means that we are
# authenticating the exact same thing len(controllers) times. This
# should be an easy thing to optimize.
# FIXME(kevinbenton): remove this comment and the one above once the
# switch to pecan is complete since only one notifier is constructed
# in the pecan notification hook.
auth = ks_loading.load_auth_from_conf_options(cfg.CONF, 'nova')
session = ks_loading.load_session_from_conf_options(
cfg.CONF,
'nova',
auth=auth)
extensions = [
ext for ext in nova_client.discover_extensions(NOVA_API_VERSION)
if ext.name == "server_external_events"]
self.nclient = nova_client.Client(
NOVA_API_VERSION,
session=session,
region_name=cfg.CONF.nova.region_name,
endpoint_type=cfg.CONF.nova.endpoint_type,
extensions=extensions)
self.batch_notifier = batch_notifier.BatchNotifier(
cfg.CONF.send_events_interval, self.send_events)
# register callbacks for events pertaining resources affecting Nova
callback_resources = (
resources.FLOATING_IP,
resources.PORT,
)
for resource in callback_resources:
registry.subscribe(self._send_nova_notification,
resource, events.BEFORE_RESPONSE)
def __init__(self):
auth = ks_loading.load_auth_from_conf_options(cfg.CONF, 'nova')
session = ks_loading.load_session_from_conf_options(
cfg.CONF,
'nova',
auth=auth)
extensions = [
ext for ext in nova_client.discover_extensions(NOVA_API_VERSION)
if ext.name == "server_external_events"]
self.nclient = nova_client.Client(
NOVA_API_VERSION,
session=session,
region_name=cfg.CONF.nova.region_name,
endpoint_type=cfg.CONF.nova.endpoint_type,
extensions=extensions)
self.batch_notifier = batch_notifier.BatchNotifier(
cfg.CONF.send_events_interval, self.send_events)
# register callbacks for events pertaining resources affecting Nova
callback_resources = (
resources.FLOATING_IP,
resources.PORT,
)
for resource in callback_resources:
registry.subscribe(self._send_nova_notification,
resource, events.BEFORE_RESPONSE)
def __init__(self, l3_agent):
self.metadata_port = l3_agent.conf.metadata_port
self.metadata_access_mark = l3_agent.conf.metadata_access_mark
registry.subscribe(
after_router_added, resources.ROUTER, events.AFTER_CREATE)
registry.subscribe(
before_router_removed, resources.ROUTER, events.BEFORE_DELETE)
def setup_sg_rpc_callbacks(self):
# following way to register call back functions start in kilo
self._create_sg_f = self.bsn_create_sg_callback
self._delete_sg_f = self.bsn_delete_sg_callback
self._update_sg_f = self.bsn_update_sg_callback
self._create_sg_rule_f = self.bsn_create_sg_rule_callback
self._delete_sg_rule_f = self.bsn_delete_sg_rule_callback
registry.subscribe(self._create_sg_f,
resources.SECURITY_GROUP, events.AFTER_CREATE)
registry.subscribe(self._delete_sg_f,
resources.SECURITY_GROUP, events.AFTER_DELETE)
registry.subscribe(self._update_sg_f,
resources.SECURITY_GROUP, events.AFTER_UPDATE)
registry.subscribe(self._create_sg_rule_f,
resources.SECURITY_GROUP_RULE, events.AFTER_CREATE)
registry.subscribe(self._delete_sg_rule_f,
resources.SECURITY_GROUP_RULE, events.AFTER_DELETE)
# the above does not cover the cases where security groups are
# initially created or when they are deleted since those actions
# aren't needed by the L2 agent. In order to receive those, we
# subscribe to the notifications topic that receives all of the
# API create/update/delete events.
# Notifications are published at the 'info' level so they will result
# in a call to the 'info' function below. From there we can check
# the event type and determine what to do from there.
target = oslo_messaging.Target(topic='#',
server=cfg.CONF.host)
keystone_target = oslo_messaging.Target(
topic='#', exchange='keystone', server=cfg.CONF.host)
self.listener = oslo_messaging.get_notification_listener(
n_rpc.TRANSPORT, [target, keystone_target], [self],
executor='eventlet', allow_requeue=False)
self.listener.start()
def setup_sg_rpc_callbacks(self):
# following way to register call back functions start in kilo
self._create_sg_f = self.bsn_create_sg_callback
self._delete_sg_f = self.bsn_delete_sg_callback
self._update_sg_f = self.bsn_update_sg_callback
self._create_sg_rule_f = self.bsn_create_sg_rule_callback
self._delete_sg_rule_f = self.bsn_delete_sg_rule_callback
registry.subscribe(self._create_sg_f, resources.SECURITY_GROUP,
events.AFTER_CREATE)
registry.subscribe(self._delete_sg_f, resources.SECURITY_GROUP,
events.AFTER_DELETE)
registry.subscribe(self._update_sg_f, resources.SECURITY_GROUP,
events.AFTER_UPDATE)
registry.subscribe(self._create_sg_rule_f,
resources.SECURITY_GROUP_RULE, events.AFTER_CREATE)
registry.subscribe(self._delete_sg_rule_f,
resources.SECURITY_GROUP_RULE, events.AFTER_DELETE)
# the above does not cover the cases where security groups are
# initially created or when they are deleted since those actions
# aren't needed by the L2 agent. In order to receive those, we
# subscribe to the notifications topic that receives all of the
# API create/update/delete events.
# Notifications are published at the 'info' level so they will result
# in a call to the 'info' function below. From there we can check
# the event type and determine what to do from there.
target = oslo_messaging.Target(topic='#', server=cfg.CONF.host)
keystone_target = oslo_messaging.Target(topic='#',
exchange='keystone',
server=cfg.CONF.host)
self.listener = oslo_messaging.get_notification_listener(
n_rpc.TRANSPORT, [target, keystone_target], [self],
executor='eventlet',
allow_requeue=False)
self.listener.start()
def setUp(self):
super(TestStatusBarriers, self).setUp()
self.ctx = n_ctx.get_admin_context()
self.provisioned = mock.Mock()
self.port = self._make_port()
registry.subscribe(self.provisioned, resources.PORT,
pb.PROVISIONING_COMPLETE)
def register():
"""Register the driver."""
global DRIVER
DRIVER = OVSDriver.create()
# To set the bridge_name in a parent port's vif_details.
registry.subscribe(vif_details_bridge_name_handler, agent_consts.OVS_BRIDGE_NAME, events.BEFORE_READ)
LOG.debug("Open vSwitch trunk driver registered")
def __init__(self, l3_agent):
self.metadata_port = l3_agent.conf.metadata_port
self.metadata_access_mark = l3_agent.conf.metadata_access_mark
registry.subscribe(after_router_added, resources.ROUTER,
events.AFTER_CREATE)
registry.subscribe(before_router_removed, resources.ROUTER,
events.BEFORE_DELETE)
def __init__(self):
db_base_plugin_v2.NeutronDbPluginV2.register_dict_extend_funcs(
attributes.PORTS, [_extend_port_trunk_details])
self._segmentation_types = {}
registry.subscribe(rules.enforce_port_deletion_rules,
resources.PORT, events.BEFORE_DELETE)
registry.notify(constants.TRUNK_PLUGIN, events.AFTER_INIT, self)
LOG.debug('Trunk plugin loaded')
def __init__(self, trunk_manager):
self._context = n_context.get_admin_context_without_session()
self.trunk_manager = trunk_manager
self.trunk_rpc = agent.TrunkStub()
registry.subscribe(self.process_trunk_port_events,
ovs_agent_constants.OVSDB_RESOURCE,
events.AFTER_READ)
def __init__(self):
db_base_plugin_v2.NeutronDbPluginV2.register_dict_extend_funcs(
attributes.PORTS, [_extend_port_trunk_details])
self._segmentation_types = {}
registry.subscribe(rules.enforce_port_deletion_rules, resources.PORT,
events.BEFORE_DELETE)
registry.notify(constants.TRUNK_PLUGIN, events.AFTER_INIT, self)
LOG.debug('Trunk plugin loaded')
def __new__(cls, *args, **kwargs):
inst = super(RouterAvailabilityZoneMixin, cls).__new__(
cls, *args, **kwargs)
registry.subscribe(inst._process_az_request,
resources.ROUTER, events.PRECOMMIT_CREATE)
db_base_plugin_v2.NeutronDbPluginV2.register_dict_extend_funcs(
l3.ROUTERS, [inst._add_az_to_response])
return inst
def __init__(self, rcache):
self.rcache = rcache
registry.subscribe(self._clear_child_sg_rules, 'SecurityGroup',
events.AFTER_DELETE)
registry.subscribe(self._add_child_sg_rules, 'SecurityGroup',
events.AFTER_UPDATE)
# set this attr so agent can adjust the timeout of the client
self.client = resources_rpc.ResourcesPullRpcApi().client
def __init__(self, plumber=None, trunk_api=None):
self._plumber = plumber or trunk_plumber.Plumber()
self._tapi = trunk_api or _TrunkAPI(trunk_rpc.TrunkStub())
registry.subscribe(self.agent_port_change, local_resources.PORT_DEVICE,
local_events.AFTER_UPDATE)
registry.subscribe(self.agent_port_delete, local_resources.PORT_DEVICE,
local_events.AFTER_DELETE)
super(LinuxBridgeTrunkDriver, self).__init__()
def register():
"""Register the driver."""
global DRIVER
DRIVER = OVSDriver.create()
# To set the bridge_name in a parent port's vif_details.
registry.subscribe(vif_details_bridge_name_handler,
agent_consts.OVS_BRIDGE_NAME, events.BEFORE_READ)
LOG.debug('Open vSwitch trunk driver registered')
def __init__(self, trunk_manager):
self._context = n_context.get_admin_context_without_session()
self.trunk_manager = trunk_manager
self.trunk_rpc = agent.TrunkStub()
registry.subscribe(self.process_trunk_port_events,
ovs_agent_constants.OVSDB_RESOURCE,
events.AFTER_READ)
def test_treat_devices_removed_notify(self):
handler = mock.Mock()
registry.subscribe(handler, resources.PORT_DEVICE, events.AFTER_DELETE)
devices = [DEVICE_1]
self.agent.treat_devices_removed(devices)
handler.assert_called_once_with(mock.ANY, mock.ANY, self.agent,
context=mock.ANY, device=DEVICE_1,
port_id=mock.ANY)
def test_security_group_precommit_create_event_fail(self):
registry.subscribe(fake_callback, resources.SECURITY_GROUP,
events.PRECOMMIT_CREATE)
with mock.patch.object(sqlalchemy.orm.session.SessionTransaction,
'rollback') as mock_rollback:
self.assertRaises(securitygroup.SecurityGroupConflict,
self.mixin.create_security_group, self.ctx,
FAKE_SECGROUP)
self.assertTrue(mock_rollback.called)
def __init__(self, topic=topics.DHCP_AGENT, plugin=None):
self._plugin = plugin
target = oslo_messaging.Target(topic=topic, version='1.0')
self.client = n_rpc.get_client(target)
# register callbacks for router interface changes
registry.subscribe(self._after_router_interface_created,
resources.ROUTER_INTERFACE, events.AFTER_CREATE)
registry.subscribe(self._after_router_interface_deleted,
resources.ROUTER_INTERFACE, events.AFTER_DELETE)
def __init__(self, topic=topics.DHCP_AGENT, plugin=None):
self._plugin = plugin
target = oslo_messaging.Target(topic=topic, version='1.0')
self.client = n_rpc.get_client(target)
# register callbacks for router interface changes
registry.subscribe(self._after_router_interface_created,
resources.ROUTER_INTERFACE, events.AFTER_CREATE)
registry.subscribe(self._after_router_interface_deleted,
resources.ROUTER_INTERFACE, events.AFTER_DELETE)
def register(self, resource, event, trigger, **kwargs):
super(OVNTrunkDriver, self).register(resource, event, trigger,
**kwargs)
self._handler = OVNTrunkHandler(self.plugin_driver)
for event in (events.AFTER_CREATE, events.AFTER_DELETE):
registry.subscribe(self._handler.trunk_event, trunk_consts.TRUNK,
event)
registry.subscribe(self._handler.subport_event,
trunk_consts.SUBPORTS, event)
def __init__(self, resource, object_class, resource_push_api):
self._resource = resource
self._obj_class = object_class
self._resource_push_api = resource_push_api
self._resources_to_push = {}
self._worker_pool = eventlet.GreenPool()
for event in (events.AFTER_CREATE, events.AFTER_UPDATE,
events.AFTER_DELETE):
registry.subscribe(self.handle_event, resource, event)
def test_record_resource_delete_ignores_dups(self):
received_kw = []
receiver = lambda *a, **k: received_kw.append(k)
registry.subscribe(receiver, 'goose', events.AFTER_DELETE)
self.rcache.record_resource_delete(self.ctx, 'goose', 3)
self.assertEqual(1, len(received_kw))
self.rcache.record_resource_delete(self.ctx, 'goose', 4)
self.assertEqual(2, len(received_kw))
self.rcache.record_resource_delete(self.ctx, 'goose', 3)
self.assertEqual(2, len(received_kw))
def test_security_group_precommit_delete_event_fail(self):
registry.subscribe(fake_callback, resources.SECURITY_GROUP,
events.PRECOMMIT_DELETE)
sg_dict = self.mixin.create_security_group(self.ctx, FAKE_SECGROUP)
with mock.patch.object(sqlalchemy.orm.session.SessionTransaction,
'rollback') as mock_rollback:
self.assertRaises(securitygroup.SecurityGroupInUse,
self.mixin.delete_security_group,
self.ctx, sg_dict['id'])
self.assertTrue(mock_rollback.called)
def initialize(self):
self._nsxv = vcns_driver.VcnsDriver(None)
self.init_profile_id()
self.init_security_group()
self.init_security_group_in_profile()
# register an event to the end of the init to handle the first upgrade
if self._is_new_security_group:
registry.subscribe(self.init_complete, resources.PROCESS,
events.BEFORE_SPAWN)
def __init__(self, plumber=None, trunk_api=None):
self._plumber = plumber or trunk_plumber.Plumber()
self._tapi = trunk_api or _TrunkAPI(trunk_rpc.TrunkStub())
registry.subscribe(self.agent_port_change,
local_resources.PORT_DEVICE,
local_events.AFTER_UPDATE)
registry.subscribe(self.agent_port_delete,
local_resources.PORT_DEVICE,
local_events.AFTER_DELETE)
super(LinuxBridgeTrunkDriver, self).__init__()
def __init__(self):
super(OVNPlugin, self).__init__()
LOG.info(_("Starting OVNPlugin"))
self.vif_type = portbindings.VIF_TYPE_OVS
# When set to True, Nova plugs the VIF directly into the ovs bridge
# instead of using the hybrid mode.
self.vif_details = {portbindings.CAP_PORT_FILTER: True}
registry.subscribe(self.post_fork_initialize, resources.PROCESS, events.AFTER_CREATE)
self._setup_dhcp()
self._start_rpc_notifiers()
def test_record_resource_delete_ignores_dups(self):
received_kw = []
receiver = lambda *a, **k: received_kw.append(k)
registry.subscribe(receiver, 'goose', events.AFTER_DELETE)
self.rcache.record_resource_delete(self.ctx, 'goose', 3)
self.assertEqual(1, len(received_kw))
self.rcache.record_resource_delete(self.ctx, 'goose', 4)
self.assertEqual(2, len(received_kw))
self.rcache.record_resource_delete(self.ctx, 'goose', 3)
self.assertEqual(2, len(received_kw))
def register_legacy_notification_callbacks(self, legacy_interface):
"""Emulates the server-side notifications from ml2 AgentNotifierApi.
legacy_interface is an object with 'delete'/'update' methods for
core resources.
"""
self._legacy_interface = legacy_interface
for e in (callback_events.AFTER_UPDATE, callback_events.AFTER_DELETE):
for r in (resources.PORT, resources.NETWORK):
registry.subscribe(self._legacy_notifier, r, e)
def register(self, resource, event, trigger, **kwargs):
super(NsxV3TrunkDriver, self).register(resource, event, trigger,
**kwargs)
self._handler = NsxV3TrunkHandler(self.plugin_driver)
for event in (events.AFTER_CREATE, events.AFTER_DELETE):
registry.subscribe(self._handler.trunk_event, trunk_consts.TRUNK,
event)
registry.subscribe(self._handler.subport_event,
trunk_consts.SUBPORTS, event)
LOG.debug("VMware NSXv3 trunk driver initialized.")
def register(self, resource, event, trigger, **kwargs):
super(NexusTrunkDriver, self).register(resource, event, trigger,
**kwargs)
self._handler = NexusTrunkHandler()
registry.subscribe(self._handler.trunk_update_postcommit,
bc.trunk_consts.TRUNK, events.AFTER_UPDATE)
for event in (events.AFTER_CREATE, events.AFTER_DELETE):
registry.subscribe(self._handler.subport_postcommit,
bc.trunk_consts.SUBPORTS, event)
def __init__(self, service_plugin):
super(BaGPipeBGPVPNDriver, self).__init__(service_plugin)
self.agent_rpc = rpc_client.BGPVPNAgentNotifyApi()
registry.subscribe(self.registry_port_updated, resources.PORT,
events.AFTER_UPDATE)
registry.subscribe(self.registry_port_deleted, resources.PORT,
events.AFTER_DELETE)
def __init__(self):
common_db_mixin.CommonDbMixin.register_dict_extend_funcs(
attributes.NETWORKS, [_extend_network_dict_binding])
common_db_mixin.CommonDbMixin.register_dict_extend_funcs(
attributes.SUBNETS, [_extend_subnet_dict_binding])
common_db_mixin.CommonDbMixin.register_dict_extend_funcs(
attributes.PORTS, [_extend_port_dict_binding])
registry.subscribe(self._prevent_segment_delete_with_subnet_associated,
resources.SEGMENT, events.BEFORE_DELETE)
def __new__(cls, *args, **kwargs):
# NOTE(kevinbenton): we subscribe on object construction because
# the tests blow away the callback manager for each run
new = super(AutoAllocatedTopologyMixin, cls).__new__(cls, *args,
**kwargs)
registry.subscribe(_ensure_external_network_default_value_callback,
resources.EXTERNAL_NETWORK, events.PRECOMMIT_CREATE)
registry.subscribe(_ensure_external_network_default_value_callback,
resources.EXTERNAL_NETWORK, events.BEFORE_UPDATE)
return new
def register_legacy_notification_callbacks(self, legacy_interface):
"""Emulates the server-side notifications from ml2 AgentNotifierApi.
legacy_interface is an object with 'delete'/'update' methods for
core resources.
"""
self._legacy_interface = legacy_interface
for e in (callback_events.AFTER_UPDATE, callback_events.AFTER_DELETE):
for r in (resources.PORT, resources.NETWORK):
registry.subscribe(self._legacy_notifier, r, e)
def test_treat_devices_removed_notify(self):
handler = mock.Mock()
registry.subscribe(handler, resources.PORT_DEVICE, events.AFTER_DELETE)
devices = [DEVICE_1]
self.agent.treat_devices_removed(devices)
handler.assert_called_once_with(mock.ANY,
mock.ANY,
self.agent,
context=mock.ANY,
device=DEVICE_1,
port_id=mock.ANY)
def subscribe(mech_driver):
registry.subscribe(mech_driver.secgroup_callback, resources.SECURITY_GROUP,
events.BEFORE_DELETE)
registry.subscribe(mech_driver.secgroup_callback, resources.SECURITY_GROUP,
events.BEFORE_UPDATE)
registry.subscribe(mech_driver.secgroup_callback,
resources.SECURITY_GROUP_RULE, events.BEFORE_DELETE)
registry.subscribe(mech_driver.secgroup_callback,
resources.SECURITY_GROUP_RULE, events.BEFORE_UPDATE)
registry.subscribe(mech_driver.secgroup_callback,
resources.SECURITY_GROUP_RULE, events.BEFORE_CREATE)
def subscribe():
registry.subscribe(
gateway_device_callback, resources.ROUTER, events.BEFORE_DELETE)
# We can only add PRECOMMIT_DELETE events in MidoNet ML2 mechanism driver
# while we can add both BEFORE_DELETE and PRECOMMIT_DELETE in MidoNet
# plugin. To keep the ML2 and plugin behavior the same, use
# PRECOMMIT_DELETE event for both ML2 and plugin.
registry.subscribe(
gateway_device_callback, midonet_const.MIDONET_NETWORK,
events.PRECOMMIT_DELETE)
def test__set_bridge_name_notify(self):
def fake_callback(resource, event, trigger, **kwargs):
trigger('fake-br-name')
registry.subscribe(fake_callback, a_const.OVS_BRIDGE_NAME,
events.BEFORE_READ)
fake_vif_details = {}
self.driver._set_bridge_name('foo', fake_vif_details)
self.assertEqual(
'fake-br-name',
fake_vif_details.get(portbindings.VIF_DETAILS_BRIDGE_NAME, ''))
def __init__(self):
resource_extend.register_funcs(attributes.NETWORKS,
[_extend_network_dict_binding])
resource_extend.register_funcs(attributes.SUBNETS,
[_extend_subnet_dict_binding])
resource_extend.register_funcs(attributes.PORTS,
[_extend_port_dict_binding])
self.nova_updater = NovaSegmentNotifier()
registry.subscribe(self._prevent_segment_delete_with_subnet_associated,
resources.SEGMENT, events.BEFORE_DELETE)
def register(self, resource, event, trigger, **kwargs):
super(OVNTrunkDriver, self).register(
resource, event, trigger, **kwargs)
self._handler = OVNTrunkHandler(self.plugin_driver)
for event in (events.AFTER_CREATE, events.AFTER_DELETE):
registry.subscribe(self._handler.trunk_event,
trunk_consts.TRUNK,
event)
registry.subscribe(self._handler.subport_event,
trunk_consts.SUBPORTS,
event)
def test_adding_component_for_new_resource_type(self):
provisioned = mock.Mock()
registry.subscribe(provisioned, 'NETWORK', pb.PROVISIONING_COMPLETE)
net = self._make_net()
# expect failed because the model was not registered for the type
with testtools.ExpectedException(RuntimeError):
pb.add_provisioning_component(self.ctx, net.id, 'NETWORK', 'ent')
pb.add_model_for_resource('NETWORK', models_v2.Network)
pb.add_provisioning_component(self.ctx, net.id, 'NETWORK', 'ent')
pb.provisioning_complete(self.ctx, net.id, 'NETWORK', 'ent')
self.assertTrue(provisioned.called)
def test_adding_component_for_new_resource_type(self):
provisioned = mock.Mock()
registry.subscribe(provisioned, 'NETWORK', pb.PROVISIONING_COMPLETE)
net = self._make_net()
# expect failed because the model was not registered for the type
with testtools.ExpectedException(RuntimeError):
pb.add_provisioning_component(self.ctx, net.id, 'NETWORK', 'ent')
pb.add_model_for_resource('NETWORK', models_v2.Network)
pb.add_provisioning_component(self.ctx, net.id, 'NETWORK', 'ent')
pb.provisioning_complete(self.ctx, net.id, 'NETWORK', 'ent')
self.assertTrue(provisioned.called)
def subscribe(self, event_type):
registry.subscribe(self.sg_callback, resources.SECURITY_GROUP,
getattr(events, "%s_CREATE" % event_type))
registry.subscribe(self.sg_callback, resources.SECURITY_GROUP,
getattr(events, "%s_UPDATE" % event_type))
registry.subscribe(self.sg_callback, resources.SECURITY_GROUP,
getattr(events, "%s_DELETE" % event_type))
registry.subscribe(self.sg_callback, resources.SECURITY_GROUP_RULE,
getattr(events, "%s_CREATE" % event_type))
registry.subscribe(self.sg_callback, resources.SECURITY_GROUP_RULE,
getattr(events, "%s_DELETE" % event_type))
def test_security_group_rule_precommit_create_event_fail(self):
registry.subscribe(fake_callback, resources.SECURITY_GROUP_RULE, events.PRECOMMIT_CREATE)
sg_dict = self.mixin.create_security_group(self.ctx, FAKE_SECGROUP)
fake_rule = FAKE_SECGROUP_RULE
fake_rule["security_group_rule"]["security_group_id"] = sg_dict["id"]
with mock.patch.object(
sqlalchemy.orm.session.SessionTransaction, "rollback"
) as mock_rollback, mock.patch.object(self.mixin, "_get_security_group"):
self.assertRaises(
securitygroup.SecurityGroupConflict, self.mixin.create_security_group_rule, self.ctx, fake_rule
)
self.assertTrue(mock_rollback.called)
def __init__(self):
common_db_mixin.CommonDbMixin.register_dict_extend_funcs(
attributes.NETWORKS, [_extend_network_dict_binding])
common_db_mixin.CommonDbMixin.register_dict_extend_funcs(
attributes.SUBNETS, [_extend_subnet_dict_binding])
common_db_mixin.CommonDbMixin.register_dict_extend_funcs(
attributes.PORTS, [_extend_port_dict_binding])
registry.subscribe(
self._prevent_segment_delete_with_subnet_associated,
resources.SEGMENT,
events.BEFORE_DELETE)
def test__set_bridge_name_notify(self):
def fake_callback(resource, event, trigger, **kwargs):
trigger('fake-br-name')
registry.subscribe(fake_callback, a_const.OVS_BRIDGE_NAME,
events.BEFORE_READ)
fake_vif_details = {}
self.driver._set_bridge_name('foo', fake_vif_details)
self.assertEqual(
'fake-br-name',
fake_vif_details.get(portbindings.VIF_DETAILS_BRIDGE_NAME, ''))
def subscribe(self):
# Subscribe to the events related to security groups and rules
registry.subscribe(self.create_security_group,
resources.SECURITY_GROUP, events.AFTER_CREATE)
registry.subscribe(self.update_security_group,
resources.SECURITY_GROUP, events.AFTER_UPDATE)
registry.subscribe(self.delete_security_group,
resources.SECURITY_GROUP, events.BEFORE_DELETE)
registry.subscribe(self.create_security_group_rule,
resources.SECURITY_GROUP_RULE, events.AFTER_CREATE)
registry.subscribe(self.delete_security_group_rule,
resources.SECURITY_GROUP_RULE, events.BEFORE_DELETE)
def __init__(self):
super(DFPlugin, self).__init__()
LOG.info(_LI("Starting DFPlugin"))
self.vif_type = portbindings.VIF_TYPE_OVS
self._set_base_port_binding()
# When set to True, Nova plugs the VIF directly into the ovs bridge
# instead of using the hybrid mode.
self.vif_details = {portbindings.CAP_PORT_FILTER: True}
registry.subscribe(self.post_fork_initialize, resources.PROCESS,
events.AFTER_CREATE)
self._setup_dhcp()
self._start_rpc_notifiers()
def test_security_group_rule_precommit_create_event_fail(self):
registry.subscribe(fake_callback, resources.SECURITY_GROUP_RULE,
events.PRECOMMIT_CREATE)
sg_dict = self.mixin.create_security_group(self.ctx, FAKE_SECGROUP)
fake_rule = FAKE_SECGROUP_RULE
fake_rule['security_group_rule']['security_group_id'] = sg_dict['id']
with mock.patch.object(sqlalchemy.orm.session.SessionTransaction,
'rollback') as mock_rollback,\
mock.patch.object(self.mixin, '_get_security_group'):
self.assertRaises(securitygroup.SecurityGroupConflict,
self.mixin.create_security_group_rule, self.ctx,
fake_rule)
self.assertTrue(mock_rollback.called)
def test_security_groups_created_outside_transaction(self):
def record_after_state(r, e, t, context, *args, **kwargs):
self.was_active = context.session.is_active
registry.subscribe(record_after_state, resources.SECURITY_GROUP,
events.AFTER_CREATE)
with self.subnet() as s:
self.assertFalse(self.was_active)
self._delete(
'security-groups',
self._list('security-groups')['security_groups'][0]['id'])
with self.port(subnet=s):
self.assertFalse(self.was_active)
def subscribe(self):
registry.subscribe(
self.sg_callback, resources.SECURITY_GROUP, events.AFTER_CREATE)
registry.subscribe(
self.sg_callback, resources.SECURITY_GROUP, events.AFTER_UPDATE)
registry.subscribe(
self.sg_callback, resources.SECURITY_GROUP, events.AFTER_DELETE)
registry.subscribe(
self.sg_callback, resources.SECURITY_GROUP_RULE,
events.AFTER_CREATE)
registry.subscribe(
self.sg_callback, resources.SECURITY_GROUP_RULE,
events.AFTER_DELETE)
def __init__(self):
super(DFPlugin, self).__init__()
LOG.info(_LI("Starting DFPlugin"))
self.vif_type = portbindings.VIF_TYPE_OVS
self._set_base_port_binding()
# When set to True, Nova plugs the VIF directly into the ovs bridge
# instead of using the hybrid mode.
self.vif_details = {portbindings.CAP_PORT_FILTER: True}
registry.subscribe(self.post_fork_initialize, resources.PROCESS, events.AFTER_CREATE)
nb_driver_class = importutils.import_class(cfg.CONF.df.nb_db_class)
self.nb_api = api_nb.NbApi(nb_driver_class())
self.nb_api.initialize(db_ip=cfg.CONF.df.remote_db_ip, db_port=cfg.CONF.df.remote_db_port)
self._setup_dhcp()
self._start_rpc_notifiers()
