def test_schedule_loadbalancer_with_disabled_agent(self):
lbaas_hosta = {
'binary': 'neutron-loadbalancer-agent',
'host': LBAAS_HOSTA,
'topic': 'LOADBALANCER_AGENT',
'configurations': {
'device_drivers':
[plugin_driver.HaproxyOnHostPluginDriver.device_driver]
},
'agent_type': lb_const.AGENT_TYPE_LOADBALANCERV2
}
helpers._register_agent(lbaas_hosta)
with self.loadbalancer() as loadbalancer:
lbaas_agent = self._get_lbaas_agent_hosting_loadbalancer(
loadbalancer['loadbalancer']['id'])
self.assertIsNotNone(lbaas_agent)
self.lbaas_plugin.db.update_loadbalancer_provisioning_status(
self.adminContext, loadbalancer['loadbalancer']['id'])
agents = self._list_agents()
self._disable_agent(agents['agents'][0]['id'])
subnet = self.core_plugin.get_subnets(self.adminContext)[0]
lb = {
'loadbalancer': {
'vip_subnet_id': subnet['id'],
'provider': 'lbaas',
'flavor_id': n_constants.ATTR_NOT_SPECIFIED,
'vip_address': n_constants.ATTR_NOT_SPECIFIED,
'admin_state_up': True,
'tenant_id': self._tenant_id,
'listeners': []
}
}
self.assertRaises(lbaas_agentschedulerv2.NoEligibleLbaasAgent,
self.lbaas_plugin.create_loadbalancer,
self.adminContext, lb)
def test_schedule_loadbalancer_with_disabled_agent(self):
lbaas_hosta = {
'binary': 'neutron-loadbalancer-agent',
'host': LBAAS_HOSTA,
'topic': 'LOADBALANCER_AGENT',
'configurations': {'device_drivers': [
plugin_driver.HaproxyOnHostPluginDriver.device_driver
]},
'agent_type': lb_const.AGENT_TYPE_LOADBALANCERV2}
helpers._register_agent(lbaas_hosta)
with self.loadbalancer() as loadbalancer:
lbaas_agent = self._get_lbaas_agent_hosting_loadbalancer(
loadbalancer['loadbalancer']['id'])
self.assertIsNotNone(lbaas_agent)
self.lbaas_plugin.db.update_loadbalancer_provisioning_status(
self.adminContext, loadbalancer['loadbalancer']['id']
)
agents = self._list_agents()
self._disable_agent(agents['agents'][0]['id'])
subnet = self.core_plugin.get_subnets(self.adminContext)[0]
lb = {
'loadbalancer': {
'vip_subnet_id': subnet['id'],
'provider': 'lbaas',
'flavor_id': n_constants.ATTR_NOT_SPECIFIED,
'vip_address': n_constants.ATTR_NOT_SPECIFIED,
'admin_state_up': True,
'tenant_id': self._tenant_id,
'listeners': []}}
self.assertRaises(lbaas_agentschedulerv2.NoEligibleLbaasAgent,
self.lbaas_plugin.create_loadbalancer,
self.adminContext, lb)
def test_schedule_loadbalancer_with_down_agent(self):
lbaas_hosta = {
'binary': 'neutron-loadbalancer-agent',
'host': LBAAS_HOSTA,
'topic': 'LOADBALANCER_AGENT',
'configurations': {'device_drivers': [
plugin_driver.HaproxyOnHostPluginDriver.device_driver
]},
'agent_type': lb_const.AGENT_TYPE_LOADBALANCERV2}
helpers._register_agent(lbaas_hosta)
is_agent_down_str = 'neutron.db.agents_db.AgentDbMixin.is_agent_down'
with mock.patch(is_agent_down_str) as mock_is_agent_down:
mock_is_agent_down.return_value = False
with self.loadbalancer() as loadbalancer:
lbaas_agent = self._get_lbaas_agent_hosting_loadbalancer(
loadbalancer['loadbalancer']['id'])
self.lbaas_plugin.db.update_loadbalancer_provisioning_status(
self.adminContext, loadbalancer['loadbalancer']['id']
)
self.assertIsNotNone(lbaas_agent)
with mock.patch(is_agent_down_str) as mock_is_agent_down:
mock_is_agent_down.return_value = True
subnet = self.core_plugin.get_subnets(self.adminContext)[0]
lb = {
'loadbalancer': {
'vip_subnet_id': subnet['id'],
'provider': 'lbaas',
'flavor_id': attributes.ATTR_NOT_SPECIFIED,
'vip_address': attributes.ATTR_NOT_SPECIFIED,
'admin_state_up': True,
'tenant_id': self._tenant_id}}
self.assertRaises(lbaas_agentschedulerv2.NoEligibleLbaasAgent,
self.lbaas_plugin.create_loadbalancer,
self.adminContext, lb)
def test_schedule_pool_with_down_agent(self):
lbaas_hosta = {
'binary': 'neutron-loadbalancer-agent',
'host': LBAAS_HOSTA,
'topic': 'LOADBALANCER_AGENT',
'configurations': {'device_drivers': ['haproxy_ns']},
'agent_type': constants.AGENT_TYPE_LOADBALANCER}
helpers._register_agent(lbaas_hosta)
is_agent_down_str = 'neutron.db.agents_db.AgentDbMixin.is_agent_down'
with mock.patch(is_agent_down_str) as mock_is_agent_down:
mock_is_agent_down.return_value = False
with self.pool() as pool:
lbaas_agent = self._get_lbaas_agent_hosting_pool(
pool['pool']['id'])
self.assertIsNotNone(lbaas_agent)
with mock.patch(is_agent_down_str) as mock_is_agent_down:
mock_is_agent_down.return_value = True
pool = {'pool': {'name': 'test',
'subnet_id': 'test',
'lb_method': 'ROUND_ROBIN',
'protocol': 'HTTP',
'provider': 'lbaas',
'admin_state_up': True,
'tenant_id': 'test',
'description': 'test'}}
lbaas_plugin = manager.NeutronManager.get_service_plugins()[
plugin_const.LOADBALANCER]
self.assertRaises(loadbalancer.NoEligibleBackend,
lbaas_plugin.create_pool,
self.adminContext, pool)
pools = lbaas_plugin.get_pools(self.adminContext)
self.assertEqual('ERROR', pools[0]['status'])
self.assertEqual('No eligible backend',
pools[0]['status_description'])
def test_schedule_pool_with_down_agent(self):
lbaas_hosta = {
'binary': 'neutron-loadbalancer-agent',
'host': LBAAS_HOSTA,
'topic': 'LOADBALANCER_AGENT',
'configurations': {'device_drivers': ['haproxy_ns']},
'agent_type': constants.AGENT_TYPE_LOADBALANCER}
helpers._register_agent(lbaas_hosta)
is_agent_down_str = 'neutron.db.agents_db.AgentDbMixin.is_agent_down'
with mock.patch(is_agent_down_str) as mock_is_agent_down:
mock_is_agent_down.return_value = False
with self.pool() as pool:
lbaas_agent = self._get_lbaas_agent_hosting_pool(
pool['pool']['id'])
self.assertIsNotNone(lbaas_agent)
with mock.patch(is_agent_down_str) as mock_is_agent_down:
mock_is_agent_down.return_value = True
pool = {'pool': {'name': 'test',
'subnet_id': 'test',
'lb_method': 'ROUND_ROBIN',
'protocol': 'HTTP',
'provider': 'lbaas',
'admin_state_up': True,
'tenant_id': 'test',
'description': 'test'}}
lbaas_plugin = manager.NeutronManager.get_service_plugins()[
plugin_const.LOADBALANCER]
self.assertRaises(loadbalancer.NoEligibleBackend,
lbaas_plugin.create_pool,
self.adminContext, pool)
pools = lbaas_plugin.get_pools(self.adminContext)
self.assertEqual('ERROR', pools[0]['status'])
self.assertEqual('No eligible backend',
pools[0]['status_description'])
def test_schedule_loadbalancer_with_disabled_agent(self):
lbaas_hosta = {
"binary": "neutron-loadbalancer-agent",
"host": LBAAS_HOSTA,
"topic": "LOADBALANCER_AGENT",
"configurations": {"device_drivers": [plugin_driver.HaproxyOnHostPluginDriver.device_driver]},
"agent_type": lb_const.AGENT_TYPE_LOADBALANCERV2,
}
helpers._register_agent(lbaas_hosta)
with self.loadbalancer() as loadbalancer:
lbaas_agent = self._get_lbaas_agent_hosting_loadbalancer(loadbalancer["loadbalancer"]["id"])
self.assertIsNotNone(lbaas_agent)
self.lbaas_plugin.db.update_loadbalancer_provisioning_status(
self.adminContext, loadbalancer["loadbalancer"]["id"]
)
agents = self._list_agents()
self._disable_agent(agents["agents"][0]["id"])
subnet = self.core_plugin.get_subnets(self.adminContext)[0]
lb = {
"loadbalancer": {
"vip_subnet_id": subnet["id"],
"provider": "lbaas",
"vip_address": attributes.ATTR_NOT_SPECIFIED,
"admin_state_up": True,
"tenant_id": self._tenant_id,
}
}
self.assertRaises(
lbaas_agentschedulerv2.NoEligibleLbaasAgent, self.lbaas_plugin.create_loadbalancer, self.adminContext, lb
)
def register_linuxbridge_agent(host=HOST,
agent_type=n_consts.AGENT_TYPE_LINUXBRIDGE,
binary='bagpipe-linuxbridge-agent',
bridge_mappings=None,
interface_mappings=None):
agent = _get_linuxbridge_agent_dict(host, agent_type, binary,
bridge_mappings, interface_mappings)
return helpers._register_agent(agent)
def register_linuxbridge_agent(host=HOST,
agent_type=n_consts.AGENT_TYPE_LINUXBRIDGE,
binary='bagpipe-linuxbridge-agent',
bridge_mappings=None,
interface_mappings=None):
agent = _get_linuxbridge_agent_dict(host, agent_type, binary,
bridge_mappings,
interface_mappings)
return helpers._register_agent(agent)
def register_bgp_dragent(host=helpers.HOST, admin_state_up=True, alive=True):
agent = helpers._register_agent(_get_bgp_dragent_dict(host))
if not admin_state_up:
helpers.set_agent_admin_state(agent['id'])
if not alive:
helpers.kill_agent(agent['id'])
return helpers.FakePlugin()._get_agent_by_type_and_host(
context.get_admin_context(), agent['agent_type'], agent['host'])
def register_bgp_dragent(host=helpers.HOST, admin_state_up=True,
alive=True):
agent = helpers._register_agent(
_get_bgp_dragent_dict(host))
if not admin_state_up:
helpers.set_agent_admin_state(agent['id'])
if not alive:
helpers.kill_agent(agent['id'])
return helpers.FakePlugin()._get_agent_by_type_and_host(
context.get_admin_context(), agent['agent_type'], agent['host'])
def test_schedule_loadbalancer_with_down_agent(self):
lbaas_hosta = {
'binary': 'neutron-loadbalancer-agent',
'host': LBAAS_HOSTA,
'topic': 'LOADBALANCER_AGENT',
'configurations': {
'device_drivers':
[plugin_driver.HaproxyOnHostPluginDriver.device_driver]
},
'agent_type': lb_const.AGENT_TYPE_LOADBALANCERV2
}
helpers._register_agent(lbaas_hosta)
is_agent_down_str = 'neutron.db.agents_db.AgentDbMixin.is_agent_down'
with mock.patch(is_agent_down_str) as mock_is_agent_down:
mock_is_agent_down.return_value = False
with self.loadbalancer() as loadbalancer:
lbaas_agent = self._get_lbaas_agent_hosting_loadbalancer(
loadbalancer['loadbalancer']['id'])
self.lbaas_plugin.db.update_loadbalancer_provisioning_status(
self.adminContext, loadbalancer['loadbalancer']['id'])
self.assertIsNotNone(lbaas_agent)
with mock.patch(is_agent_down_str) as mock_is_agent_down:
mock_is_agent_down.return_value = True
subnet = self.core_plugin.get_subnets(self.adminContext)[0]
lb = {
'loadbalancer': {
'vip_subnet_id': subnet['id'],
'provider': 'lbaas',
'flavor_id': attributes.ATTR_NOT_SPECIFIED,
'vip_address': attributes.ATTR_NOT_SPECIFIED,
'admin_state_up': True,
'tenant_id': self._tenant_id
}
}
self.assertRaises(lbaas_agentschedulerv2.NoEligibleLbaasAgent,
self.lbaas_plugin.create_loadbalancer,
self.adminContext, lb)
def _register_avs_agent(self, host=None, mappings=None):
agent = helpers._get_l2_agent_dict(
host, constants.AGENT_TYPE_WRS_VSWITCH,
'neutron-avs-agent')
agent['configurations']['mappings'] = mappings
return helpers._register_agent(agent, self._plugin)
