def setUp(self):
ml2_config.cfg.CONF.set_override('mechanism_drivers',
['logger', 'fake_agent'],
'ml2')
super(TestBagpipeServiceDriverCallbacks, self).setUp(self._plugin_name)
self.port_create_status = 'DOWN'
self.plugin = manager.NeutronManager.get_plugin()
self.plugin.start_rpc_listeners()
self.bagpipe_driver = self.bgpvpn_plugin.driver
self.patched_driver = mock.patch.object(
self.bgpvpn_plugin.driver,
'_retrieve_bgpvpn_network_info_for_port',
return_value=BGPVPN_INFO)
self.patched_driver.start()
self.mock_attach_rpc = self.mocked_bagpipeAPI.attach_port_on_bgpvpn
self.mock_detach_rpc = self.mocked_bagpipeAPI.detach_port_from_bgpvpn
self.mock_update_bgpvpn_rpc = self.mocked_bagpipeAPI.update_bgpvpn
self.mock_delete_bgpvpn_rpc = self.mocked_bagpipeAPI.delete_bgpvpn
# we choose an agent of type const.AGENT_TYPE_OFA
# because this is the type used by the fake_agent mech driver
helpers.register_ovs_agent(helpers.HOST, const.AGENT_TYPE_OFA)
helpers.register_l3_agent()
def test_get_agent_by_host(self):
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
agent = l2pop_db.get_agent_by_host(
self.ctx.session, helpers.HOST)
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_agent_by_host(self):
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
agent = l2pop_db.get_agent_by_host(self.ctx.session, helpers.HOST)
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_agent_by_host(self):
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
agent = self.db_mixin.get_agent_by_host(
context.get_admin_context().session, helpers.HOST)
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_ovs_bridge_name_not_set_when_not_trunk(self):
helpers.register_ovs_agent(host=helpers.HOST)
with self.port() as port:
port['port'][pb.HOST_ID] = helpers.HOST
bound_port = self.core_plugin.update_port(self.context,
port['port']['id'], port)
self.assertIsNone(bound_port[pb.VIF_DETAILS].get(
pb.VIF_DETAILS_BRIDGE_NAME))
def test_ovs_bridge_name_not_set_when_not_trunk(self):
helpers.register_ovs_agent(host=helpers.HOST)
with self.port() as port:
port['port'][pb.HOST_ID] = helpers.HOST
bound_port = self.core_plugin.update_port(self.context,
port['port']['id'], port)
self.assertIsNone(
bound_port[pb.VIF_DETAILS].get(pb.VIF_DETAILS_BRIDGE_NAME))
def test_get_agent_by_host(self):
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
agent = self.db_mixin.get_agent_by_host(
self.ctx.session, helpers.HOST)
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test__handle_port_binding_set_device_owner(self):
helpers.register_ovs_agent(host=helpers.HOST)
with self.port() as subport:
port = (
self.trunk_plugin._rpc_backend._skeleton._handle_port_binding(
self.context, subport['port']['id'], mock.ANY,
helpers.HOST))
self.assertEqual(constants.TRUNK_SUBPORT_OWNER,
port['device_owner'])
def _register_agent(self,
host,
mappings=None,
plugin=None,
start_flag=True):
helpers.register_ovs_agent(host=host,
bridge_mappings=mappings,
plugin=self.plugin,
start_flag=start_flag)
def test_ovs_bridge_name_set_to_integration_bridge_when_not_trunk(self):
helpers.register_ovs_agent(host=helpers.HOST,
integration_bridge='br-fake')
with self.port() as port:
port['port'][pb.HOST_ID] = helpers.HOST
bound_port = self.core_plugin.update_port(self.context,
port['port']['id'], port)
self.assertEqual('br-fake',
bound_port[pb.VIF_DETAILS].get(pb.VIF_DETAILS_BRIDGE_NAME))
def test__handle_port_binding_set_device_owner(self):
helpers.register_ovs_agent(host=helpers.HOST)
with self.port() as subport:
port = (
self.trunk_plugin.
_rpc_backend._skeleton._handle_port_binding(
self.context, subport['port']['id'],
mock.ANY, helpers.HOST))
self.assertEqual(
constants.TRUNK_SUBPORT_OWNER, port['device_owner'])
def test_ovs_bridge_name_set_to_integration_bridge_when_not_trunk(self):
helpers.register_ovs_agent(host=helpers.HOST,
integration_bridge='br-fake')
with self.port() as port:
port['port'][pb.HOST_ID] = helpers.HOST
bound_port = self.core_plugin.update_port(self.context,
port['port']['id'], port)
self.assertEqual(
'br-fake',
bound_port[pb.VIF_DETAILS].get(pb.VIF_DETAILS_BRIDGE_NAME))
def test_get_ha_agents_by_router_id(self):
helpers.register_dhcp_agent()
helpers.register_l3_agent()
helpers.register_ovs_agent()
self._create_ha_router()
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_ROUTER_SNAT,
device_id=TEST_ROUTER_ID)
agents = l2pop_db.get_ha_agents_by_router_id(self.ctx, TEST_ROUTER_ID)
ha_agents = [agent.host for agent in agents]
self.assertEqual(tools.UnorderedList([HOST, HOST_2]), ha_agents)
def test_get_nondvr_active_network_ports(self):
self._setup_port_binding(dvr=False)
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
fdb_network_ports = self.db_mixin.get_nondvr_active_network_ports(
self.ctx.session, 'network_id')
self.assertEqual(1, len(fdb_network_ports))
_, agent = fdb_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_dvr_active_network_ports(self):
self._setup_port_binding()
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
tunnel_network_ports = l2pop_db.get_dvr_active_network_ports(
self.ctx.session, 'network_id')
self.assertEqual(1, len(tunnel_network_ports))
_, agent = tunnel_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test__get_ha_router_interface_ids_with_ha_replicated_port(self):
helpers.register_dhcp_agent()
helpers.register_l3_agent()
helpers.register_ovs_agent()
self._create_ha_router()
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_HA_REPLICATED_INT,
device_id=TEST_ROUTER_ID)
ha_iface_ids = l2pop_db._get_ha_router_interface_ids(
self.ctx.session, TEST_NETWORK_ID)
self.assertEqual(1, len(list(ha_iface_ids)))
def test_ovs_bridge_name_not_set_if_integration_bridge_not_set(self):
"""This will only happen if a stein or later ml2 driver is
binding an interface for a pre stein ml2 agent.
"""
helpers.register_ovs_agent(host=helpers.HOST)
with self.port() as port:
port['port'][pb.HOST_ID] = helpers.HOST
bound_port = self.core_plugin.update_port(self.context,
port['port']['id'], port)
self.assertIsNone(bound_port[pb.VIF_DETAILS].get(
pb.VIF_DETAILS_BRIDGE_NAME))
def test_get_nondistributed_active_network_ports(self):
self._setup_port_binding(dvr=False)
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
fdb_network_ports = l2pop_db.get_nondistributed_active_network_ports(
self.ctx.session, TEST_NETWORK_ID)
self.assertEqual(1, len(fdb_network_ports))
_, agent = fdb_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_dvr_active_network_ports(self):
self._setup_port_binding()
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
tunnel_network_ports = l2pop_db.get_dvr_active_network_ports(
self.ctx.session, 'network_id')
self.assertEqual(1, len(tunnel_network_ports))
_, agent = tunnel_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_nondvr_active_network_ports(self):
self._setup_port_binding(dvr=False)
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
fdb_network_ports = self.db_mixin.get_nondvr_active_network_ports(
self.ctx.session, 'network_id')
self.assertEqual(1, len(fdb_network_ports))
_, agent = fdb_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_nondistributed_active_network_ports(self):
self._setup_port_binding(dvr=False)
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
fdb_network_ports = l2pop_db.get_nondistributed_active_network_ports(
self.ctx.session, TEST_NETWORK_ID)
self.assertEqual(1, len(fdb_network_ports))
_, agent = fdb_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_ovs_bridge_name_not_set_if_integration_bridge_not_set(self):
"""This will only happen if a stein or later ml2 driver is
binding an interface for a pre stein ml2 agent.
"""
helpers.register_ovs_agent(host=helpers.HOST)
with self.port() as port:
port['port'][pb.HOST_ID] = helpers.HOST
bound_port = self.core_plugin.update_port(self.context,
port['port']['id'], port)
self.assertIsNone(
bound_port[pb.VIF_DETAILS].get(pb.VIF_DETAILS_BRIDGE_NAME))
def test__get_ha_router_interface_ids_with_ha_replicated_port(self):
helpers.register_dhcp_agent()
helpers.register_l3_agent()
helpers.register_ovs_agent()
self._create_ha_router()
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_HA_REPLICATED_INT,
device_id=TEST_ROUTER_ID)
ha_iface_ids = l2pop_db._get_ha_router_interface_ids(
self.ctx.session, TEST_NETWORK_ID)
self.assertEqual(1, len(list(ha_iface_ids)))
def _register_ml2_agents(self):
helpers.register_ovs_agent(host=HOST, tunneling_ip='20.0.0.1')
helpers.register_ovs_agent(host=HOST_2, tunneling_ip='20.0.0.2')
helpers.register_ovs_agent(host=HOST_3, tunneling_ip='20.0.0.3',
tunnel_types=[])
helpers.register_ovs_agent(host=HOST_4, tunneling_ip='20.0.0.4')
helpers.register_ovs_agent(host=HOST_5, tunneling_ip='20.0.0.5',
binary='neutron-fake-agent',
tunnel_types=[],
interface_mappings={'physnet1': 'eth9'},
agent_type=constants.AGENT_TYPE_OFA,
l2pop_network_types=['vlan'])
def _register_ml2_agents(self):
helpers.register_ovs_agent(host=HOST, tunneling_ip='20.0.0.1')
helpers.register_ovs_agent(host=HOST_2, tunneling_ip='20.0.0.2')
helpers.register_ovs_agent(host=HOST_3, tunneling_ip='20.0.0.3',
tunnel_types=[])
helpers.register_ovs_agent(host=HOST_4, tunneling_ip='20.0.0.4')
helpers.register_ovs_agent(host=HOST_5, tunneling_ip='20.0.0.5',
binary='neutron-fake-agent',
tunnel_types=[],
interface_mappings={'physnet1': 'eth9'},
agent_type=constants.AGENT_TYPE_OFA,
l2pop_network_types=['vlan'])
def test_get_distributed_active_network_ports(self):
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_DVR_INTERFACE)
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
tunnel_network_ports = l2pop_db.get_distributed_active_network_ports(
self.ctx.session, TEST_NETWORK_ID)
self.assertEqual(1, len(tunnel_network_ports))
_, agent = tunnel_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_distributed_active_network_ports(self):
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_DVR_INTERFACE)
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
tunnel_network_ports = l2pop_db.get_distributed_active_network_ports(
self.ctx.session, TEST_NETWORK_ID)
self.assertEqual(1, len(tunnel_network_ports))
_, agent = tunnel_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_ha_agents_by_router_id(self):
helpers.register_dhcp_agent()
helpers.register_l3_agent()
helpers.register_ovs_agent()
self._create_ha_router()
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_ROUTER_SNAT,
device_id=TEST_ROUTER_ID)
agents = l2pop_db.get_ha_agents_by_router_id(
self.ctx.session, TEST_ROUTER_ID)
ha_agents = [agent.host for agent in agents]
self.assertEqual(tools.UnorderedList([HOST, HOST_2]), ha_agents)
def test_port_bind_successfully(self):
helpers.register_ovs_agent(host=helpers.HOST)
with self.network() as network:
with self.subnet(network=network) as subnet:
with self.port(
subnet=subnet, device_owner=DEVICE_OWNER_COMPUTE,
arg_list=(portbindings.HOST_ID, 'admin_state_up',),
**self.host_args) as port:
# Note: Port creation invokes _bind_port_if_needed(),
# therefore it is all we need in order to test a successful
# binding
self.assertEqual(port['port']['binding:vif_type'],
portbindings.VIF_TYPE_OVS)
def _register_ml2_agents(self):
helpers.register_ovs_agent(host=HOST, tunneling_ip="20.0.0.1")
helpers.register_ovs_agent(host=HOST_2, tunneling_ip="20.0.0.2")
helpers.register_ovs_agent(host=HOST_3, tunneling_ip="20.0.0.3", tunnel_types=[])
helpers.register_ovs_agent(host=HOST_4, tunneling_ip="20.0.0.4")
helpers.register_ovs_agent(
host=HOST_5,
tunneling_ip="20.0.0.5",
binary="neutron-fake-agent",
tunnel_types=[],
interface_mappings={"physnet1": "eth9"},
agent_type=constants.AGENT_TYPE_OFA,
l2pop_network_types=["vlan"],
)
def test_active_port_count_with_ha_dvr_snat_port(self):
helpers.register_dhcp_agent()
helpers.register_l3_agent()
helpers.register_ovs_agent()
self._create_ha_router()
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_ROUTER_SNAT,
device_id=TEST_ROUTER_ID)
port_count = l2pop_db.get_agent_network_active_port_count(
self.ctx.session, HOST, TEST_NETWORK_ID)
self.assertEqual(1, port_count)
port_count = l2pop_db.get_agent_network_active_port_count(
self.ctx.session, HOST_2, TEST_NETWORK_ID)
self.assertEqual(1, port_count)
def test_active_port_count_with_ha_dvr_snat_port(self):
helpers.register_dhcp_agent()
helpers.register_l3_agent()
helpers.register_ovs_agent()
self._create_ha_router()
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_ROUTER_SNAT,
device_id=TEST_ROUTER_ID)
port_count = l2pop_db.get_agent_network_active_port_count(
self.ctx.session, HOST, TEST_NETWORK_ID)
self.assertEqual(1, port_count)
port_count = l2pop_db.get_agent_network_active_port_count(
self.ctx.session, HOST_2, TEST_NETWORK_ID)
self.assertEqual(1, port_count)
def test_active_network_ports_with_dvr_snat_port(self):
# Test to get agent hosting dvr snat port
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
# create DVR router
self._create_router()
# setup DVR snat port
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_ROUTER_SNAT,
device_id=TEST_ROUTER_ID)
helpers.register_dhcp_agent()
fdb_network_ports = l2pop_db.get_nondistributed_active_network_ports(
self.ctx.session, TEST_NETWORK_ID)
self.assertEqual(1, len(fdb_network_ports))
def test_ovs_bridge_name_set_when_trunk_bound(self):
helpers.register_ovs_agent(host=helpers.HOST)
with self.port() as port:
trunk_port_id = port['port']['id']
trunk_req = {'port_id': trunk_port_id,
'tenant_id': 'test_tenant',
'sub_ports': []}
trunk_res = self.trunk_plugin.create_trunk(self.context,
{'trunk': trunk_req})
port['port'][pb.HOST_ID] = helpers.HOST
bound_port = self.core_plugin.update_port(self.context,
trunk_port_id, port)
self.assertEqual(
utils.gen_trunk_br_name(trunk_res['id']),
bound_port[pb.VIF_DETAILS][pb.VIF_DETAILS_BRIDGE_NAME])
def test_active_network_ports_with_dvr_snat_port(self):
# Test to get agent hosting dvr snat port
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
# create DVR router
self._create_router()
# setup DVR snat port
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_ROUTER_SNAT,
device_id=TEST_ROUTER_ID)
helpers.register_dhcp_agent()
fdb_network_ports = l2pop_db.get_nondistributed_active_network_ports(
self.ctx.session, TEST_NETWORK_ID)
self.assertEqual(1, len(fdb_network_ports))
def test_port_bind_successfully(self):
helpers.register_ovs_agent(host=helpers.HOST)
with self.network() as network:
with self.subnet(network=network) as subnet:
with self.port(subnet=subnet,
device_owner=DEVICE_OWNER_COMPUTE,
arg_list=(
portbindings.HOST_ID,
'admin_state_up',
),
**self.host_args) as port:
# Note: Port creation invokes _bind_port_if_needed(),
# therefore it is all we need in order to test a successful
# binding
self.assertEqual(port['port']['binding:vif_type'],
portbindings.VIF_TYPE_OVS)
def test_port_bind_retry(self):
agent = helpers.register_ovs_agent(host=helpers.HOST)
helpers.kill_agent(agent_id=agent.id)
with self.network() as network:
with self.subnet(network=network) as subnet:
with self.port(subnet=subnet,
device_owner=DEVICE_OWNER_COMPUTE,
arg_list=(
portbindings.HOST_ID,
'admin_state_up',
),
**self.host_args) as port:
# Since the agent is dead, expect binding to fail
self.assertEqual(port['port']['binding:vif_type'],
portbindings.VIF_TYPE_BINDING_FAILED)
helpers.revive_agent(agent.id)
# When an agent starts, The RPC call get_device_details()
# will invoke get_bound_port_context() which eventually use
# _bind_port_if_needed()
bound_context = self.plugin.get_bound_port_context(
self.admin_context, port['port']['id'], helpers.HOST)
# Since the agent is back online, expect binding to succeed
self.assertEqual(bound_context.vif_type,
portbindings.VIF_TYPE_OVS)
self.assertEqual(bound_context.current['binding:vif_type'],
portbindings.VIF_TYPE_OVS)
def test_ovs_bridge_name_set_when_trunk_bound(self):
helpers.register_ovs_agent(host=helpers.HOST)
with self.port() as port:
trunk_port_id = port['port']['id']
trunk_req = {
'port_id': trunk_port_id,
'tenant_id': 'test_tenant',
'sub_ports': []
}
trunk_res = self.trunk_plugin.create_trunk(self.context,
{'trunk': trunk_req})
port['port'][pb.HOST_ID] = helpers.HOST
bound_port = self.core_plugin.update_port(self.context,
trunk_port_id, port)
self.assertEqual(
utils.gen_trunk_br_name(trunk_res['id']),
bound_port[pb.VIF_DETAILS][pb.VIF_DETAILS_BRIDGE_NAME])
def test_active_network_ports_with_ha_dvr_snat_port(self):
# test to get HA agents hosting HA+DVR snat port
helpers.register_dhcp_agent()
helpers.register_l3_agent()
helpers.register_ovs_agent()
# create HA+DVR router
self._create_ha_router()
# setup HA snat port
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_ROUTER_SNAT,
device_id=TEST_ROUTER_ID)
fdb_network_ports = l2pop_db.get_nondistributed_active_network_ports(
self.ctx, TEST_NETWORK_ID)
self.assertEqual(0, len(fdb_network_ports))
ha_ports = l2pop_db.get_ha_active_network_ports(
self.ctx, TEST_NETWORK_ID)
self.assertEqual(2, len(ha_ports))
def test_active_network_ports_with_ha_dvr_snat_port(self):
# test to get HA agents hosting HA+DVR snat port
helpers.register_dhcp_agent()
helpers.register_l3_agent()
helpers.register_ovs_agent()
# create HA+DVR router
self._create_ha_router()
# setup HA snat port
self._setup_port_binding(
device_owner=constants.DEVICE_OWNER_ROUTER_SNAT,
device_id=TEST_ROUTER_ID)
fdb_network_ports = l2pop_db.get_nondistributed_active_network_ports(
self.ctx, TEST_NETWORK_ID)
self.assertEqual(0, len(fdb_network_ports))
ha_ports = l2pop_db.get_ha_active_network_ports(
self.ctx, TEST_NETWORK_ID)
self.assertEqual(2, len(ha_ports))
def _create_ha_router(self, distributed=False):
helpers.register_l3_agent(HOST_2)
helpers.register_ovs_agent(HOST_2, tunneling_ip=HOST_2_TUNNELING_IP)
# Register l3 agent on host3, which doesn't host any HA router.
# Tests should test that host3 is not a HA agent host.
helpers.register_l3_agent(HOST_3)
helpers.register_ovs_agent(HOST_3, tunneling_ip=HOST_3_TUNNELING_IP)
with db_api.CONTEXT_WRITER.using(self.ctx):
network_obj.Network(self.ctx, id=TEST_HA_NETWORK_ID).create()
self._create_router(distributed=distributed, ha=True)
for state, host in [(constants.HA_ROUTER_STATE_ACTIVE, HOST),
(constants.HA_ROUTER_STATE_STANDBY, HOST_2)]:
self._setup_port_binding(
network_id=TEST_HA_NETWORK_ID,
device_owner=constants.DEVICE_OWNER_ROUTER_HA_INTF,
device_id=TEST_ROUTER_ID,
host_state=state,
host=host)
def _create_ha_router(self, distributed=False):
helpers.register_l3_agent(HOST_2)
helpers.register_ovs_agent(HOST_2, tunneling_ip=HOST_2_TUNNELING_IP)
# Register l3 agent on host3, which doesn't host any HA router.
# Tests should test that host3 is not a HA agent host.
helpers.register_l3_agent(HOST_3)
helpers.register_ovs_agent(HOST_3, tunneling_ip=HOST_3_TUNNELING_IP)
with self.ctx.session.begin(subtransactions=True):
self.ctx.session.add(models_v2.Network(id=TEST_HA_NETWORK_ID))
self._create_router(distributed=distributed, ha=True)
for state, host in [(n_const.HA_ROUTER_STATE_ACTIVE, HOST),
(n_const.HA_ROUTER_STATE_STANDBY, HOST_2)]:
self._setup_port_binding(
network_id=TEST_HA_NETWORK_ID,
device_owner=constants.DEVICE_OWNER_ROUTER_HA_INTF,
device_id=TEST_ROUTER_ID,
host_state=state,
host=host)
def _create_ha_router(self, distributed=False):
helpers.register_l3_agent(HOST_2)
helpers.register_ovs_agent(HOST_2, tunneling_ip=HOST_2_TUNNELING_IP)
# Register l3 agent on host3, which doesn't host any HA router.
# Tests should test that host3 is not a HA agent host.
helpers.register_l3_agent(HOST_3)
helpers.register_ovs_agent(HOST_3, tunneling_ip=HOST_3_TUNNELING_IP)
with self.ctx.session.begin(subtransactions=True):
self.ctx.session.add(models_v2.Network(id=TEST_HA_NETWORK_ID))
self._create_router(distributed=distributed, ha=True)
for state, host in [(n_const.HA_ROUTER_STATE_ACTIVE, HOST),
(n_const.HA_ROUTER_STATE_STANDBY, HOST_2)]:
self._setup_port_binding(
network_id=TEST_HA_NETWORK_ID,
device_owner=constants.DEVICE_OWNER_ROUTER_HA_INTF,
device_id=TEST_ROUTER_ID,
host_state=state,
host=host)
def setUp(self):
ml2_config.cfg.CONF.set_override('mechanism_drivers',
['logger', 'fake_agent'], 'ml2')
super(TestBagpipeServiceDriverCallbacks, self).setUp(self._plugin_name)
self.port_create_status = 'DOWN'
self.plugin = directory.get_plugin()
self.plugin.start_rpc_listeners()
self.bagpipe_driver = self.bgpvpn_plugin.driver
self.patched_driver = mock.patch.object(
self.bgpvpn_plugin.driver,
'_retrieve_bgpvpn_network_info_for_port',
return_value=BGPVPN_INFO)
self.patched_driver.start()
# we choose an agent of type const.AGENT_TYPE_OFA
# because this is the type used by the fake_agent mech driver
helpers.register_ovs_agent(helpers.HOST, const.AGENT_TYPE_OFA)
helpers.register_l3_agent()
def test_dhcp_scheduler_filters_hosts_without_network_access(self):
dhcp_agent1 = helpers.register_dhcp_agent(host='host1')
dhcp_agent2 = helpers.register_dhcp_agent(host='host2')
dhcp_agent3 = helpers.register_dhcp_agent(host='host3')
dhcp_agents = [dhcp_agent1, dhcp_agent2, dhcp_agent3]
helpers.register_ovs_agent(host='host1',
bridge_mappings={'physnet1': 'br-eth-1'})
helpers.register_ovs_agent(host='host2',
bridge_mappings={'physnet2': 'br-eth-1'})
helpers.register_ovs_agent(host='host3',
bridge_mappings={'physnet2': 'br-eth-1'})
admin_context = context.get_admin_context()
net = self.driver.create_network(
admin_context, {
'network': {
'name': 'net1',
providernet.NETWORK_TYPE: 'vlan',
providernet.PHYSICAL_NETWORK: 'physnet1',
providernet.SEGMENTATION_ID: 1,
'tenant_id': 'tenant_one',
'admin_state_up': True,
'shared': True
}
})
self.driver.create_subnet(
admin_context, {
'subnet': {
'name': 'name',
'ip_version': constants.IP_VERSION_4,
'network_id': net['id'],
'cidr': '10.0.0.0/24',
'gateway_ip': constants.ATTR_NOT_SPECIFIED,
'allocation_pools': constants.ATTR_NOT_SPECIFIED,
'dns_nameservers': constants.ATTR_NOT_SPECIFIED,
'host_routes': constants.ATTR_NOT_SPECIFIED,
'tenant_id': 'tenant_one',
'enable_dhcp': True
}
})
self.plugin.schedule_network(admin_context, net)
dhcp_agents = self.driver.get_dhcp_agents_hosting_networks(
admin_context, [net['id']])
self.assertEqual(1, len(dhcp_agents))
self.assertEqual('host1', dhcp_agents[0]['host'])
def test_port_bind_retry(self):
agent = helpers.register_ovs_agent(host=helpers.HOST)
helpers.kill_agent(agent_id=agent.id)
with self.network() as network:
with self.subnet(network=network) as subnet:
with self.port(
subnet=subnet, device_owner=DEVICE_OWNER_COMPUTE,
arg_list=(portbindings.HOST_ID, 'admin_state_up',),
**self.host_args) as port:
# Since the agent is dead, expect binding to fail
self.assertEqual(port['port']['binding:vif_type'],
portbindings.VIF_TYPE_BINDING_FAILED)
helpers.revive_agent(agent.id)
# When an agent starts, The RPC call get_device_details()
# will invoke get_bound_port_context() which eventually use
# _bind_port_if_needed()
bound_context = self.plugin.get_bound_port_context(
self.admin_context, port['port']['id'], helpers.HOST)
# Since the agent is back online, expect binding to succeed
self.assertEqual(bound_context.vif_type,
portbindings.VIF_TYPE_OVS)
self.assertEqual(bound_context.current['binding:vif_type'],
portbindings.VIF_TYPE_OVS)
def test_dhcp_scheduler_filters_hosts_without_network_access(self):
dhcp_agent1 = helpers.register_dhcp_agent(host='host1')
dhcp_agent2 = helpers.register_dhcp_agent(host='host2')
dhcp_agent3 = helpers.register_dhcp_agent(host='host3')
dhcp_agents = [dhcp_agent1, dhcp_agent2, dhcp_agent3]
helpers.register_ovs_agent(
host='host1', bridge_mappings={'physnet1': 'br-eth-1'})
helpers.register_ovs_agent(
host='host2', bridge_mappings={'physnet2': 'br-eth-1'})
helpers.register_ovs_agent(
host='host3', bridge_mappings={'physnet2': 'br-eth-1'})
admin_context = context.get_admin_context()
net = self.driver.create_network(
admin_context,
{'network': {'name': 'net1',
providernet.NETWORK_TYPE: 'vlan',
providernet.PHYSICAL_NETWORK: 'physnet1',
providernet.SEGMENTATION_ID: 1,
'tenant_id': 'tenant_one',
'admin_state_up': True,
'shared': True}})
self.driver.create_subnet(
admin_context,
{'subnet':
{'name': 'name',
'ip_version': 4,
'network_id': net['id'],
'cidr': '10.0.0.0/24',
'gateway_ip': constants.ATTR_NOT_SPECIFIED,
'allocation_pools': constants.ATTR_NOT_SPECIFIED,
'dns_nameservers': constants.ATTR_NOT_SPECIFIED,
'host_routes': constants.ATTR_NOT_SPECIFIED,
'tenant_id': 'tenant_one',
'enable_dhcp': True}})
self.plugin.schedule_network(admin_context, net)
dhcp_agents = self.driver.get_dhcp_agents_hosting_networks(
admin_context, [net['id']])
self.assertEqual(1, len(dhcp_agents))
self.assertEqual('host1', dhcp_agents[0]['host'])
def setUp(self):
if ENABLE_LOGGING:
self.useFixture(log_fixture.SetLogLevel(['neutron'],
logging.DEBUG))
if ENABLE_PROFILER:
self.pr = cProfile.Profile()
self.pr.enable()
utils.setup_arista_wrapper_config(cfg)
cfg.CONF.set_override('vni_ranges',
['10000:11000'],
group='ml2_type_vxlan')
super(MechTestBase, self).setUp()
self.plugin.notifier.port_update = self._mock_port_update
self.plugin.start_rpc_listeners()
self.host1 = 'host1'
self.host2 = 'host2'
self.host3 = 'host3'
# Hack to ensure agents report being alive
cfg.CONF.set_override('agent_down_time', 1000)
helpers.register_ovs_agent(
host=self.host1, bridge_mappings={self.physnet: 'br-eth1'})
helpers.register_ovs_agent(
host=self.host2, bridge_mappings={self.physnet: 'br-eth1'})
helpers.register_ovs_agent(
host=self.host3, bridge_mappings={self.physnet2: 'br-eth1'})
self.region = 'region'
self.cvx = utils.MockCvx(self.region)
self.drv = self.driver.mechanism_manager.mech_drivers['arista'].obj
# multiprocessing.Queue's get() fails to wake up a thread, swap
# it out for a LightQueue for testing purposes
self.drv.provision_queue = queue.LightQueue()
for worker in self.driver._workers:
if isinstance(worker, arista_sync.AristaSyncWorker):
self.ar_sync = worker
self.ar_sync._rpc = self.cvx
self.ar_sync.provision_queue = self.drv.provision_queue
worker.start()
self.trunk_plugin = directory.get_plugin('trunk')
self.net_count = 0
def _register_agent(self, host, mappings=None, plugin=None,
start_flag=True):
helpers.register_ovs_agent(host=host, bridge_mappings=mappings,
plugin=self.plugin, start_flag=start_flag)
