def _setUp(self):
super(LocalVlanManagerFixture, self)._setUp()
self.vlan_manager = vlanmanager.LocalVlanManager()
self.addCleanup(self.restore_manager)
# Remove _instance attribute from VlanManager in order to not obtain a
# singleton
del vlanmanager.LocalVlanManager._instance
self.manager = vlanmanager.LocalVlanManager()
def setUp(self):
super(BaseTestBaGPipeBGPAgentOVS, self).setUp()
self.mock_int_br = mock.Mock()
self.mock_int_br.add_patch_port = mock.Mock()
self.mock_int_br.add_patch_port.side_effect = PATCH_INT_OFPORTS
self.mock_int_br.get_vif_port_by_id = mock.Mock()
self.mock_tun_br = mock.Mock()
self.mock_tun_br.add_patch_port = mock.Mock()
self.mock_tun_br.add_patch_port.side_effect = PATCH_TUN_OFPORTS
self.mock_tun_br.get_port_ofport = mock.Mock()
with mock.patch('neutron.agent.common.ovs_lib.OVSBridge.'
'bridge_exists', return_value=True), \
mock.patch('neutron.agent.common.ovs_lib.OVSBridge.'
'add_patch_port', side_effect=PATCH_MPLS_OFPORTS):
self.agent = BaGPipeBGPAgent(n_const.AGENT_TYPE_OVS,
mock.Mock(),
int_br=self.mock_int_br,
tun_br=self.mock_tun_br)
self.vlan_manager = vlanmanager.LocalVlanManager()
for net_id, vlan in LOCAL_VLAN_MAP.items():
try:
self.vlan_manager.add(net_id, vlan, None, None, None)
except vlanmanager.MappingAlreadyExists:
pass
def __init__(self, agent_type, connection, int_br=None, tun_br=None):
"""Create a new BaGPipe-BGP REST service client.
:param agent_type: bagpipe-bgp agent type (Linux bridge or OVS)
:param connection: RPC Connection
:param int_br: OVS integration bridge
:param tun_br: OVS tunnel bridge
"""
super(BaGPipeBGPAgent,
self).__init__(cfg.CONF.BAGPIPE.bagpipe_bgp_ip,
cfg.CONF.BAGPIPE.bagpipe_bgp_port, agent_type)
self.agent_type = agent_type
self.ping_interval = cfg.CONF.BAGPIPE.ping_interval
# Store all ports level network and service informations
self.ports_info = keydefaultdict(PortInfo)
# Store all networks level network and service informations
self.networks_info = keydefaultdict(NetworkInfo)
self.bagpipe_bgp_status = self.BAGPIPEBGP_DOWN
self.seq_num = 0
# OVS-specific setup
if self.agent_type == n_const.AGENT_TYPE_OVS:
self.int_br = int_br
self.tun_br = tun_br
self._setup_mpls_br()
registry.subscribe(self.ovs_restarted,
resources.AGENT,
events.OVS_RESTARTED)
# RPC setup
if self.agent_type == n_const.AGENT_TYPE_LINUXBRIDGE:
connection.create_consumer(topics.get_topic_name(topics.AGENT,
topics_BAGPIPE,
topics.UPDATE,
cfg.CONF.host),
[self], fanout=False)
else:
LOG.info("bagpipe-l2 RPCs disabled for OVS bridge")
connection.create_consumer(topics.get_topic_name(topics.AGENT,
topics_BAGPIPE_BGPVPN,
topics.UPDATE),
[self], fanout=True)
connection.create_consumer(topics.get_topic_name(topics.AGENT,
topics_BAGPIPE_BGPVPN,
topics.UPDATE,
cfg.CONF.host),
[self], fanout=False)
# Starts a greenthread for bagpipe-bgp status polling
self._start_bagpipe_bgp_status_polling(self.ping_interval)
self.vlan_manager = vlanmanager.LocalVlanManager()
def initialize(self):
self.br_int = ovs_ext_lib.SfcOVSBridgeExt(
self.agent_api.request_int_br())
self.br_int.set_protocols(SfcOVSAgentDriver.REQUIRED_PROTOCOLS)
self.local_ip = cfg.CONF.OVS.local_ip
self.patch_tun_ofport = self.br_int.get_port_ofport(
cfg.CONF.OVS.int_peer_patch_port)
self.vlan_manager = vlanmanager.LocalVlanManager()
self._clear_sfc_flow_on_int_br()
def initialize(self, connection, driver_type):
"""Perform Agent Extension initialization"""
self.conf = cfg.CONF
int_br = self.agent_api.request_int_br()
self.vlan_manager = vlanmanager.LocalVlanManager()
fw_l2_driver_cls = self._load_l2_driver_class(driver_type)
sg_enabled = securitygroups_rpc.is_firewall_enabled()
self.driver = manager.NeutronManager.load_class_for_provider(
FWAAS_L2_DRIVER, fw_l2_driver_cls)(int_br, sg_enabled)
self.plugin_rpc = FWaaSL2PluginApi(consts.FIREWALL_PLUGIN,
self.conf.host)
self.start_rpc_listeners()
self.fwg_map = PortFirewallGroupMap()
def get_agent_ports(self, fdb_entries):
"""Generator to yield port info.
For each known (i.e found in VLAN manager) network in
fdb_entries, yield (lvm, fdb_entries[network_id]['ports']) pair.
:param fdb_entries: l2pop fdb entries
"""
vlan_manager = vlanmanager.LocalVlanManager()
for network_id, values in fdb_entries.items():
try:
lvm = vlan_manager.get(network_id)
except vlanmanager.MappingNotFound:
continue
agent_ports = values.get('ports')
yield (lvm, agent_ports)
def initialize(self):
self.br_int = ovs_ext_lib.SfcOVSBridgeExt(
self.agent_api.request_int_br())
self.local_ip = cfg.CONF.OVS.local_ip
self.patch_tun_ofport = self.br_int.get_port_ofport(
cfg.CONF.OVS.int_peer_patch_port)
self.vlan_manager = vlanmanager.LocalVlanManager()
self._clear_sfc_flow_on_int_br()
self.br_tun = ovs_ext_lib.SfcOVSBridgeExt(
self.agent_api.request_tun_br())
self.patch_int_ofport = self.br_tun.get_port_ofport(
cfg.CONF.OVS.tun_peer_patch_port)
self._clear_sfc_flow_on_tun_br()
def fdb_chg_ip_tun(self, context, br, fdb_entries, local_ip):
'''fdb update when an IP of a port is updated.
The ML2 l2-pop mechanism driver sends an fdb update rpc message when an
IP of a port is updated.
:param context: RPC context.
:param br: represent the bridge on which fdb_chg_ip_tun should be
applied.
:param fdb_entries: fdb dicts that contain all mac/IP information per
agent and network.
{'net1':
{'agent_ip':
{'before': PortInfo,
'after': PortInfo
}
}
'net2':
...
}
PortInfo has .mac_address and .ip_address attrs.
:param local_ip: local IP address of this agent.
'''
vlan_manager = vlanmanager.LocalVlanManager()
for network_id, agent_ports in fdb_entries.items():
try:
lvm = vlan_manager.get(network_id)
except vlanmanager.MappingNotFound:
continue
for agent_ip, state in agent_ports.items():
if agent_ip == local_ip:
continue
after = state.get('after', [])
for mac_ip in after:
self.setup_entry_for_arp_reply(br, 'add', lvm.vlan,
mac_ip.mac_address,
mac_ip.ip_address)
before = state.get('before', [])
for mac_ip in before:
self.setup_entry_for_arp_reply(br, 'remove', lvm.vlan,
mac_ip.mac_address,
mac_ip.ip_address)
def setUp(self):
ovs_test_base.OVSOFCtlTestBase.setUp(self)
BaseTestAgentExtension.setUp(self)
self.int_br = self.br_int_cls("br-int")
self.int_br.add_patch_port = mock.Mock(side_effect=add_patch_port_int)
self.int_br.get_port_ofport = mock.Mock(
side_effect=get_port_ofport_int_br)
self.int_br.add_flow = mock.Mock()
self.int_br.delete_flows = mock.Mock()
self.int_br.use_at_least_protocol = mock.Mock()
self.tun_br = self.br_tun_cls("br-tun")
self.tun_br.add_patch_port = mock.Mock(side_effect=add_patch_port_tun)
self.tun_br.get_port_ofport = mock.Mock(
side_effect=get_port_ofport_tun_br)
self.tun_br.add_flow = mock.Mock()
self.tun_br.delete_flows = mock.Mock()
agent_extension_api = ovs_ext_agt.OVSAgentExtensionAPI(
self.int_br, self.tun_br)
self.agent_ext.consume_api(agent_extension_api)
br_exists_patcher = mock.patch(
'neutron.agent.common.ovs_lib.OVSBridge.bridge_exists',
return_value=True)
br_exists_patcher.start()
self.addCleanup(br_exists_patcher.stop)
add_patch_patcher = mock.patch(
'neutron.agent.common.ovs_lib.OVSBridge'
'.add_patch_port',
side_effect=add_patch_port_mpls)
add_patch_patcher.start()
self.addCleanup(add_patch_patcher.stop)
self.agent_ext.initialize(self.connection,
ovs_agt_constants.EXTENSION_DRIVER_TYPE)
self.vlan_manager = vlanmanager.LocalVlanManager()
for net_id, vlan in LOCAL_VLAN_MAP.items():
try:
self.vlan_manager.add(net_id, vlan, None, None, None)
except vlanmanager.MappingAlreadyExists:
pass
def initialize(self, connection, driver_type):
self.driver_type = driver_type
if self._is_ovs_extension():
self.int_br = self.agent_api.request_int_br()
self.tun_br = self.agent_api.request_tun_br()
if self.tun_br is None:
raise Exception("tunneling is not enabled in OVS agent, "
"however bagpipe_bgpvpn extensions needs it")
if cfg.CONF.SECURITYGROUP.firewall_driver != "openvswitch":
LOG.warning('Neutron router fallback supported only with the '
'"openvswitch" firewall driver, or if l3agent is '
'always deployed on servers distinct from compute '
'nodes.')
self.bagpipe_bgp_agent = (
bagpipe_bgp_agent.BaGPipeBGPAgent.get_instance(
n_const.AGENT_TYPE_OVS))
self._setup_ovs_bridge()
self.vlan_manager = vlanmanager.LocalVlanManager()
registry.subscribe(self.ovs_restarted, resources.AGENT,
events.OVS_RESTARTED)
elif self._is_linuxbridge_extension():
self.bagpipe_bgp_agent = (
bagpipe_bgp_agent.BaGPipeBGPAgent.get_instance(
n_const.AGENT_TYPE_LINUXBRIDGE))
else:
raise Exception("driver type not supported: %s", driver_type)
self.bagpipe_bgp_agent.register_build_callback(
bgpvpn_const.BGPVPN_SERVICE, self.build_bgpvpn_attach_info)
# NOTE(tmorin): replace by callback, so that info can be derived
# from self.ports_info.keys() instead of being duplicated into
# self.ports
self.bagpipe_bgp_agent.register_port_list(bgpvpn_const.BGPVPN_SERVICE,
self.ports)
# OVO-based BGPVPN RPCs
self._setup_rpc(connection)
def get_lvm_from_manager(net_id, local_vlan_map):
vlan_manager = vlanmanager.LocalVlanManager()
return vlan_manager.get(net_id)
def test_is_singleton(self):
self.vlan_manager.add(1, None, None, None, None)
new_vlan_manager = vlanmanager.LocalVlanManager()
self.assertIs(new_vlan_manager, self.vlan_manager)
self.assertItemsEqual(new_vlan_manager.mapping,
self.vlan_manager.mapping)
