def test_loadbalancer_get_all_by_vm_id(self):
lb_fake1 = get_fake_lb('1', 'tenant1')
lb_fake2 = get_fake_lb('2', 'tenant2')
lb_ref1 = db_api.loadbalancer_create(self.conf, lb_fake1)
lb_ref2 = db_api.loadbalancer_create(self.conf, lb_fake2)
sf_fake1 = get_fake_sf(lb_ref1['id'])
sf_fake2 = get_fake_sf(lb_ref2['id'])
sf_ref1 = db_api.serverfarm_create(self.conf, sf_fake1)
sf_ref2 = db_api.serverfarm_create(self.conf, sf_fake2)
node_fake1 = get_fake_server(sf_ref1['id'], 1, '10.0.0.1')
node_fake2 = get_fake_server(sf_ref1['id'], 20, '10.0.0.2')
node_fake3 = get_fake_server(sf_ref2['id'], 1, '10.0.0.3')
node_fake4 = get_fake_server(sf_ref2['id'], 30, '10.0.0.4')
node_ref1 = db_api.server_create(self.conf, node_fake1)
node_ref2 = db_api.server_create(self.conf, node_fake2)
node_ref3 = db_api.server_create(self.conf, node_fake3)
node_ref4 = db_api.server_create(self.conf, node_fake4)
lbs1 = db_api.loadbalancer_get_all_by_vm_id(self.conf, 'tenant1', 1)
lbs2 = db_api.loadbalancer_get_all_by_vm_id(self.conf, 'tenant2', 30)
lbs3 = db_api.loadbalancer_get_all_by_vm_id(self.conf, 'tenant2', 20)
self.assertEqual([dict(lb_ref1.iteritems())],
[dict(lb.iteritems()) for lb in lbs1])
self.assertEqual([dict(lb_ref2.iteritems())],
[dict(lb.iteritems()) for lb in lbs2])
self.assertFalse(lbs3)
def test_loadbalancer_get_all_by_vm_id(self):
lb_fake1 = get_fake_lb('1', 'tenant1')
lb_fake2 = get_fake_lb('2', 'tenant2')
lb_ref1 = db_api.loadbalancer_create(self.conf, lb_fake1)
lb_ref2 = db_api.loadbalancer_create(self.conf, lb_fake2)
sf_fake1 = get_fake_sf(lb_ref1['id'])
sf_fake2 = get_fake_sf(lb_ref2['id'])
sf_ref1 = db_api.serverfarm_create(self.conf, sf_fake1)
sf_ref2 = db_api.serverfarm_create(self.conf, sf_fake2)
node_fake1 = get_fake_server(sf_ref1['id'], 1, '10.0.0.1')
node_fake2 = get_fake_server(sf_ref1['id'], 20, '10.0.0.2')
node_fake3 = get_fake_server(sf_ref2['id'], 1, '10.0.0.3')
node_fake4 = get_fake_server(sf_ref2['id'], 30, '10.0.0.4')
node_ref1 = db_api.server_create(self.conf, node_fake1)
node_ref2 = db_api.server_create(self.conf, node_fake2)
node_ref3 = db_api.server_create(self.conf, node_fake3)
node_ref4 = db_api.server_create(self.conf, node_fake4)
lbs1 = db_api.loadbalancer_get_all_by_vm_id(self.conf, 1, 'tenant1')
lbs2 = db_api.loadbalancer_get_all_by_vm_id(self.conf, 30, 'tenant2')
lbs3 = db_api.loadbalancer_get_all_by_vm_id(self.conf, 20, 'tenant2')
self.assertEqual(len(lbs1), 1)
self.assertEqual(lbs1[0]['id'], lb_ref1['id'])
self.assertEqual(len(lbs2), 1)
self.assertEqual(lbs2[0]['id'], lb_ref2['id'])
self.assertEqual(len(lbs3), 0)
def test_lb_count_active_by_device(self):
lb_fake1 = get_fake_lb("1", "tenant1")
lb_fake2 = get_fake_lb("1", "tenant2")
lb_fake2["status"] = lb_status.ACTIVE
lb_ref1 = db_api.loadbalancer_create(self.conf, lb_fake1)
lb_ref2 = db_api.loadbalancer_create(self.conf, lb_fake2)
result = db_api.lb_count_active_by_device(self.conf, "1")
self.assertEqual(result, 1)
def test_lb_count_active_by_device(self):
lb_fake1 = get_fake_lb('1', 'tenant1')
lb_fake2 = get_fake_lb('1', 'tenant2')
lb_fake2['status'] = lb_status.ACTIVE
lb_ref1 = db_api.loadbalancer_create(self.conf, lb_fake1)
lb_ref2 = db_api.loadbalancer_create(self.conf, lb_fake2)
result = db_api.lb_count_active_by_device(self.conf, '1')
self.assertEqual(result, 1)
def test_loadbalancer_get_with_tenant(self):
db_api.loadbalancer_create(self.conf, get_fake_lb('1', 'tenant1'))
values = get_fake_lb('2', 'tenant2')
lb_ref1 = db_api.loadbalancer_create(self.conf, values)
lb_ref2 = db_api.loadbalancer_get(self.conf,
lb_ref1['id'], tenant_id='tenant2')
self.assertEqual(dict(lb_ref1.iteritems()),
dict(lb_ref2.iteritems()))
def test_loadbalancer_get_all_by_project(self):
values = get_fake_lb('1', 'tenant1')
lb_ref1 = db_api.loadbalancer_create(self.conf, values)
values = get_fake_lb('2', 'tenant2')
lb_ref2 = db_api.loadbalancer_create(self.conf, values)
lbs1 = db_api.loadbalancer_get_all_by_project(self.conf, 'tenant1')
lbs2 = db_api.loadbalancer_get_all_by_project(self.conf, 'tenant2')
self.assertEqual(len(lbs1), 1)
self.assertEqual(len(lbs2), 1)
self.assertNotEqual(lbs1[0]['id'], lbs2[0]['id'])
def test_loadbalancer_get_all_by_project(self):
values = get_fake_lb("1", "tenant1")
lb_ref1 = db_api.loadbalancer_create(self.conf, values)
values = get_fake_lb("2", "tenant2")
lb_ref2 = db_api.loadbalancer_create(self.conf, values)
lbs1 = db_api.loadbalancer_get_all_by_project(self.conf, "tenant1")
lbs2 = db_api.loadbalancer_get_all_by_project(self.conf, "tenant2")
self.assertEqual([dict(lb_ref1.iteritems())], [dict(lb.iteritems()) for lb in lbs1])
self.assertEqual([dict(lb_ref2.iteritems())], [dict(lb.iteritems()) for lb in lbs2])
self.assertNotEqual(lbs1[0]["id"], lbs2[0]["id"])
def test_loadbalancer_get_all_by_project(self):
values = get_fake_lb('1', 'tenant1')
lb_ref1 = db_api.loadbalancer_create(self.conf, values)
values = get_fake_lb('2', 'tenant2')
lb_ref2 = db_api.loadbalancer_create(self.conf, values)
lbs1 = db_api.loadbalancer_get_all_by_project(self.conf, 'tenant1')
lbs2 = db_api.loadbalancer_get_all_by_project(self.conf, 'tenant2')
self.assertEqual([dict(lb_ref1.iteritems())],
[dict(lb.iteritems()) for lb in lbs1])
self.assertEqual([dict(lb_ref2.iteritems())],
[dict(lb.iteritems()) for lb in lbs2])
self.assertNotEqual(lbs1[0]['id'], lbs2[0]['id'])
def test_loadbalancer_create(self):
values = get_fake_lb("1", "tenant1")
lb_ref = db_api.loadbalancer_create(self.conf, values)
lb = dict(lb_ref.iteritems())
self.assertIsNotNone(lb["id"])
values["id"] = lb["id"]
self.assertEqual(lb, values)
def test_loadbalancer_create(self):
values = get_fake_lb('1', 'tenant1')
lb_ref = db_api.loadbalancer_create(self.conf, values)
lb = dict(lb_ref.iteritems())
self.assertIsNotNone(lb['id'])
values['id'] = lb['id']
self.assertEqual(lb, values)
def test_loadbalancer_destroy(self):
values = get_fake_lb('1', 'tenant1')
lb = db_api.loadbalancer_create(self.conf, values)
db_api.loadbalancer_destroy(self.conf, lb['id'])
with self.assertRaises(exception.LoadBalancerNotFound) as cm:
db_api.loadbalancer_get(self.conf, lb['id'])
err = cm.exception
self.assertEqual(err.kwargs, {'loadbalancer_id': lb['id']})
def test_loadbalancer_get_all_by_device_id(self):
lb_fake1 = get_fake_lb('1', 'tenant1')
lb_ref1 = db_api.loadbalancer_create(self.conf, lb_fake1)
lbs1 = db_api.loadbalancer_get_all_by_device_id(self.conf, '1')
with self.assertRaises(exception.LoadBalancerNotFound):
db_api.loadbalancer_get_all_by_device_id(self.conf, '2')
self.assertEqual([dict(lb_ref1.iteritems())],
[dict(lb.iteritems()) for lb in lbs1])
def test_server_get1(self):
lb_values = get_fake_lb("1", "tenant1")
lb = db_api.loadbalancer_create(self.conf, lb_values)
sf_values = get_fake_sf(lb["id"])
sf = db_api.serverfarm_create(self.conf, sf_values)
server_values = get_fake_server(sf["id"], 1)
server_ref1 = db_api.server_create(self.conf, server_values)
server_ref2 = db_api.server_get(self.conf, server_ref1["id"], lb["id"])
self.assertEqual(dict(server_ref1.iteritems()), dict(server_ref2.iteritems()))
def test_loadbalancer_update(self):
values = get_fake_lb("1", "tenant1")
lb_ref = db_api.loadbalancer_create(self.conf, values)
update = {"protocol": "FTP", "extra": {"extrafield": "extravalue"}}
lb_ref = db_api.loadbalancer_update(self.conf, lb_ref["id"], update)
lb = dict(lb_ref.iteritems())
values.update(update)
self.assertIsNotNone(lb["id"])
values["id"] = lb["id"]
values["updated_at"] = lb["updated_at"]
self.assertEqual(lb, values)
def create(self, req, **args):
logger.debug("Got create request. Request: %s", req)
#here we need to decide which device should be used
params = args['body']
# We need to create LB object and return its id
tenant_id = req.headers.get('X-Tenant-Id', "")
lb_ref = db_api.loadbalancer_create(self.conf, {
'tenant_id': tenant_id})
params['lb'] = lb_ref
core_api.create_lb(self.conf, **params)
return {'loadbalancers': {'id': lb_ref['id']}}
def test_loadbalancer_update(self):
values = get_fake_lb('1', 'tenant1')
lb_ref = db_api.loadbalancer_create(self.conf, values)
update = {'protocol': 'FTP',
'extra': {'extrafield': 'extravalue'}}
lb_ref = db_api.loadbalancer_update(self.conf, lb_ref['id'],
update)
lb = dict(lb_ref.iteritems())
values.update(update)
self.assertIsNotNone(lb['id'])
values['id'] = lb['id']
values['updated_at'] = lb['updated_at']
self.assertEqual(lb, values)
def create_lb(conf, params):
node_values = params.pop('nodes', [])
probe_values = params.pop('healthMonitor', [])
vip_values = params.pop('virtualIps', [])
lb_values = db_api.loadbalancer_pack_extra(params)
lb_ref = db_api.loadbalancer_create(conf, lb_values)
sf_ref = db_api.serverfarm_create(conf, {'lb_id': lb_ref['id']})
db_api.predictor_create(conf, {'sf_id': sf_ref['id'],
'type': lb_ref['algorithm']})
vip_update_values = {'protocol': lb_ref['protocol']}
vips = []
for vip in vip_values:
vip = db_api.virtualserver_pack_extra(vip)
db_api.pack_update(vip, vip_update_values)
vip['lb_id'] = lb_ref['id']
vip['sf_id'] = sf_ref['id']
vips.append(db_api.virtualserver_create(conf, vip))
servers = []
for server in node_values:
server = db_api.server_pack_extra(server)
server['sf_id'] = sf_ref['id']
servers.append(db_api.server_create(conf, server))
probes = []
for probe in probe_values:
probe = db_api.probe_pack_extra(probe)
probe['lb_id'] = lb_ref['id']
probe['sf_id'] = sf_ref['id']
probes.append(db_api.probe_create(conf, probe))
device_ref = scheduler.schedule(conf, lb_ref)
db_api.loadbalancer_update(conf, lb_ref['id'],
{'device_id': device_ref['id']})
device_driver = drivers.get_device_driver(conf, device_ref['id'])
with device_driver.request_context() as ctx:
try:
commands.create_loadbalancer(ctx, sf_ref, vips, servers, probes,
[])
except Exception:
with utils.save_and_reraise_exception():
db_api.loadbalancer_update(conf, lb_ref['id'],
{'status': lb_status.ERROR,
'deployed': False})
db_api.loadbalancer_update(conf, lb_ref['id'],
{'status': lb_status.ACTIVE,
'deployed': True})
return lb_ref['id']
def test_loadbalancer_get_all_by_vm_id(self):
lb_fake1 = get_fake_lb("1", "tenant1")
lb_fake2 = get_fake_lb("2", "tenant2")
lb_ref1 = db_api.loadbalancer_create(self.conf, lb_fake1)
lb_ref2 = db_api.loadbalancer_create(self.conf, lb_fake2)
sf_fake1 = get_fake_sf(lb_ref1["id"])
sf_fake2 = get_fake_sf(lb_ref2["id"])
sf_ref1 = db_api.serverfarm_create(self.conf, sf_fake1)
sf_ref2 = db_api.serverfarm_create(self.conf, sf_fake2)
node_fake1 = get_fake_server(sf_ref1["id"], 1, "10.0.0.1")
node_fake2 = get_fake_server(sf_ref1["id"], 20, "10.0.0.2")
node_fake3 = get_fake_server(sf_ref2["id"], 1, "10.0.0.3")
node_fake4 = get_fake_server(sf_ref2["id"], 30, "10.0.0.4")
node_ref1 = db_api.server_create(self.conf, node_fake1)
node_ref2 = db_api.server_create(self.conf, node_fake2)
node_ref3 = db_api.server_create(self.conf, node_fake3)
node_ref4 = db_api.server_create(self.conf, node_fake4)
lbs1 = db_api.loadbalancer_get_all_by_vm_id(self.conf, 1, "tenant1")
lbs2 = db_api.loadbalancer_get_all_by_vm_id(self.conf, 30, "tenant2")
lbs3 = db_api.loadbalancer_get_all_by_vm_id(self.conf, 20, "tenant2")
self.assertEqual([dict(lb_ref1.iteritems())], [dict(lb.iteritems()) for lb in lbs1])
self.assertEqual([dict(lb_ref2.iteritems())], [dict(lb.iteritems()) for lb in lbs2])
self.assertFalse(lbs3)
def test_server_get_by_address_on_device(self):
lb_fake = get_fake_lb("1", "tenant1")
lb_ref = db_api.loadbalancer_create(self.conf, lb_fake)
sf_fake = get_fake_sf(lb_ref["id"])
sf_ref = db_api.serverfarm_create(self.conf, sf_fake)
server_fake = get_fake_server(sf_ref["id"], 1, "10.0.0.1")
server_ref = db_api.server_create(self.conf, server_fake)
server = db_api.server_get_by_address_on_device(self.conf, "10.0.0.1", "1")
with self.assertRaises(exception.ServerNotFound) as cm:
server = db_api.server_get_by_address_on_device(self.conf, "10.0.0.2", "1")
expected = {"server_address": "10.0.0.2", "device_id": "1"}
err = cm.exception
self.assertEqual(err.kwargs, expected)
with self.assertRaises(exception.ServerNotFound) as cm:
server = db_api.server_get_by_address_on_device(self.conf, "10.0.0.1", "2")
err = cm.exception
expected = {"server_address": "10.0.0.1", "device_id": "2"}
self.assertEqual(err.kwargs, expected)
def create_lb(conf, params):
nodes = params.pop('nodes', [])
probes = params.pop('healthMonitor', [])
vips = params.pop('virtualIps', [])
values = db_api.loadbalancer_pack_extra(params)
lb_ref = db_api.loadbalancer_create(conf, values)
device = scheduler.schedule_loadbalancer(conf, lb_ref)
device_driver = drivers.get_device_driver(conf, device['id'])
lb = db_api.unpack_extra(lb_ref)
lb['device_id'] = device['id']
lb_ref = db_api.loadbalancer_pack_extra(lb)
try:
with device_driver.request_context() as ctx:
commands.create_loadbalancer(ctx, lb_ref, nodes, probes, vips)
except (exception.Error, exception.Invalid):
lb_ref.status = lb_status.ERROR
lb_ref.deployed = 'False'
else:
lb_ref.status = lb_status.ACTIVE
lb_ref.deployed = 'True'
db_api.loadbalancer_update(conf, lb['id'], lb_ref)
return lb_ref['id']
def test_server_get_by_address_on_device(self):
lb_fake = get_fake_lb('1', 'tenant1')
lb_ref = db_api.loadbalancer_create(self.conf, lb_fake)
sf_fake = get_fake_sf(lb_ref['id'])
sf_ref = db_api.serverfarm_create(self.conf, sf_fake)
server_fake = get_fake_server(sf_ref['id'], 1, '10.0.0.1')
server_ref = db_api.server_create(self.conf, server_fake)
server = db_api.server_get_by_address_on_device(self.conf, '10.0.0.1',
'1')
with self.assertRaises(exception.ServerNotFound) as cm:
server = db_api.server_get_by_address_on_device(self.conf,
'10.0.0.2', '1')
expected = {'server_address': '10.0.0.2',
'device_id': '1'}
err = cm.exception
self.assertEqual(err.kwargs, expected)
with self.assertRaises(exception.ServerNotFound) as cm:
server = db_api.server_get_by_address_on_device(self.conf,
'10.0.0.1', '2')
err = cm.exception
expected = {'server_address': '10.0.0.1',
'device_id': '2'}
self.assertEqual(err.kwargs, expected)
def savetoDB(self):
try:
lb_ref = db_api.loadbalancer_update(self.conf, self.lb['id'],
self.lb)
except exception.LoadBalancerNotFound:
lb_ref = db_api.loadbalancer_create(self.conf, self.lb)
self.sf['lb_id'] = lb_ref['id']
try:
sf_ref = db_api.serverfarm_update(self.conf, self.sf['id'],
self.sf)
except exception.ServerFarmNotFound:
sf_ref = db_api.serverfarm_create(self.conf, self.sf)
self.sf._predictor['sf_id'] = sf_ref['id']
try:
db_api.predictor_update(self.conf, self.sf._predictor['id'],
self.sf._predictor)
except exception.PredictorNotFound:
db_api.predictor_create(self.conf, self.sf._predictor)
stickies = self.sf._sticky
vips = []
self.sf = sf_ref
self.sf._rservers = []
self.sf._probes = []
self.sf._sticky = []
for rs in self.rs:
rs['sf_id'] = sf_ref['id']
try:
rs_ref = db_api.server_update(self.conf, rs['id'], rs)
except exception.ServerNotFound:
rs_ref = db_api.server_create(self.conf, rs)
self.sf._rservers.append(rs_ref)
for pr in self.probes:
pr['sf_id'] = sf_ref['id']
try:
pr_ref = db_api.probe_update(self.conf, pr['id'], pr)
except exception.ProbeNotFound:
pr_ref = db_api.probe_create(self.conf, pr)
self.sf._probes.append(pr_ref)
for vip in self.vips:
vip['sf_id'] = sf_ref['id']
vip['lb_id'] = lb_ref['id']
try:
vip_ref = db_api.virtualserver_update(self.conf, vip['id'],
vip)
except exception.VirtualServerNotFound:
vip_ref = db_api.virtualserver_create(self.conf, vip)
vips.append(vip_ref)
for st in stickies:
st['sf_id'] = sf_ref['id']
try:
st_ref = db_api.sticky_update(self.conf, st['id'], st)
except exception.StickyNotFound:
st_ref = db_api.sticky_create(self.conf, st)
self.sf._sticky.append(st_ref)
self.rs = self.sf._rservers
self.probes = self.sf._probes
self.vips = vips
def test_loadbalancer_get(self):
values = get_fake_lb("1", "tenant1")
lb_ref1 = db_api.loadbalancer_create(self.conf, values)
lb_ref2 = db_api.loadbalancer_get(self.conf, lb_ref1["id"])
self.assertEqual(dict(lb_ref1.iteritems()), dict(lb_ref2.iteritems()))
def _create_lb_and_sf(self, device_id, tenant_id):
lb_values = get_fake_lb(device_id, tenant_id)
lb_ref = db_api.loadbalancer_create(self.conf, lb_values)
sf_values = get_fake_sf(lb_ref['id'])
sf_ref = db_api.serverfarm_create(self.conf, sf_values)
return lb_ref['id'], sf_ref['id']
def test_loadbalancer_get_with_tenant_fails(self):
values = get_fake_lb('1', 'tenant1')
lb_ref1 = db_api.loadbalancer_create(self.conf, values)
with self.assertRaises(exception.LoadBalancerNotFound):
db_api.loadbalancer_get(self.conf,
lb_ref1['id'], tenant_id='tenant2')
