def test_delete_load_balancer(self):
self.mox.StubOutWithMock(db, 'load_balancer_get_by_uuid')
self.mox.StubOutWithMock(db, 'load_balancer_update_state')
db.load_balancer_get_by_uuid(
self.context, self.lb_uuid).AndReturn(self.lb_ref)
db.load_balancer_update_state(
self.context, self.lb_uuid, state.DELETING)
self.mox.ReplayAll()
r = api.delete_load_balancer(self.context, **self.kwargs)
self.mox.VerifyAll()
self.assertEqual(r, None)
def test_create_load_balancer(self):
fake_module = FakeModule(self.lb_uuid)
self.mox.StubOutWithMock(protocol, 'get_protocol_module')
self.mox.StubOutWithMock(db, 'load_balancer_get_by_uuid')
self.lb_ref.config = self.config_ref
protocol.get_protocol_module(self.protocol).AndReturn(fake_module)
db.load_balancer_get_by_uuid(
self.context, self.lb_uuid).AndReturn(self.lb_ref)
self.mox.ReplayAll()
r = api.create_load_balancer(self.context, **self.kwargs)
self.mox.VerifyAll()
self.assertEqual(r['data']['uuid'], self.lb_uuid)
def test_update_load_balancer_http_servers(self):
kwargs = copy.deepcopy(self.delete_kwargs)
new_http_servers = ['www.abc.com', 'www.123.com']
kwargs['http_server_names'] = new_http_servers
self.mox.StubOutWithMock(utils, 'get_all_domain_names')
self.mox.StubOutWithMock(db, 'load_balancer_get_by_uuid')
self.mox.StubOutWithMock(db, 'load_balancer_domain_create')
self.mox.StubOutWithMock(db, 'load_balancer_domain_destroy')
self.mox.StubOutWithMock(db, 'load_balancer_update_state')
load_balancer_ref = self.lb_ref
for index, domain in enumerate(self.http_server_names):
domain_values = {
'id': index + 1,
'load_balancer_id': load_balancer_ref.id,
'name': domain,
}
domain_ref = models.LoadBalancerDomain()
domain_ref.update(domain_values)
load_balancer_ref.domains.append(domain_ref)
db.load_balancer_get_by_uuid(
self.ctxt, self.uuid).AndReturn(load_balancer_ref)
utils.get_all_domain_names().AndReturn(list())
old_http_servers = map(lambda x: x['name'], load_balancer_ref.domains)
need_deleted_domains = filter(lambda x: x not in new_http_servers,
old_http_servers)
need_created_domains = filter(lambda x: x not in old_http_servers,
new_http_servers)
for domain in load_balancer_ref.domains:
if domain.name in need_deleted_domains:
db.load_balancer_domain_destroy(
self.ctxt, domain.id).AndReturn(None)
for domain in need_created_domains:
domain_values = {
'load_balancer_id': load_balancer_ref.id,
'name': domain,
}
db.load_balancer_domain_create(
self.ctxt, domain_values).AndReturn(None)
db.load_balancer_update_state(
self.ctxt, self.uuid, state.UPDATING).AndReturn(None)
self.mox.ReplayAll()
r = http.update_load_balancer_http_servers(self.ctxt, **kwargs)
self.mox.VerifyAll()
self.assertRaises(r, None)
def test_get_load_balancer(self):
self.mox.StubOutWithMock(db, 'load_balancer_get_by_uuid')
load_balancer_ref = copy.deepcopy(self.lb_ref)
load_balancer_ref.config = self.config_ref
expect = dict()
expect['created_at'] = None
expect['updated_at'] = None
expect['user_id'] = load_balancer_ref.user_id
expect['project_id'] = load_balancer_ref.project_id
expect['free'] = load_balancer_ref.free
expect['uuid'] = load_balancer_ref.uuid
expect['name'] = load_balancer_ref.name
expect['state'] = load_balancer_ref.state
expect['protocol'] = load_balancer_ref.protocol
expect['listen_port'] = load_balancer_ref.listen_port
expect['instance_port'] = load_balancer_ref.instance_port
expect_configs = copy.deepcopy(self.config)
del expect_configs['load_balancer_id']
expect['config'] = expect_configs
expect['dns_names'] = []
expect['instance_uuids'] = []
expect['http_server_names'] = []
for index, domain in enumerate(self.http_server_names):
domain_values = {
'id': index + 1,
'load_balancer_id': load_balancer_ref.id,
'name': domain,
}
expect['http_server_names'].append(domain)
domain_ref = models.LoadBalancerDomain()
domain_ref.update(domain_values)
load_balancer_ref.domains.append(domain_ref)
for uuid in self.instance_uuids:
association_values = {
'load_balancer_id': load_balancer_ref.id,
'instance_uuid': uuid,
}
expect['instance_uuids'].append(uuid)
association_ref = models.LoadBalancerInstanceAssociation()
association_ref.update(association_values)
load_balancer_ref.instances.append(association_ref)
db.load_balancer_get_by_uuid(
self.context, self.lb_uuid).AndReturn(load_balancer_ref)
self.mox.ReplayAll()
r = api.get_load_balancer(self.context, **self.kwargs)
self.mox.VerifyAll()
self.assertEqual(r, {'data': expect})
def update_load_balancer_config(context, **kwargs):
expect_keys = [
'user_id', 'tenant_id', 'protocol',
'uuid', 'config',
]
utils.check_input_parameters(expect_keys, **kwargs)
config = kwargs['config']
expect_configs = [
'balancing_method',
'health_check_timeout_ms',
'health_check_interval_ms',
'health_check_target_path',
]
config = kwargs['config']
utils.check_input_parameters(expect_configs, **config)
if config['balancing_method'] not in ['round_robin', 'source_binding']:
raise exception.InvalidParameter(
msg='invalid balancing method, round_robin or source_binding')
if not 100 <= config['health_check_timeout_ms']:
raise exception.InvalidParameter(
msg='healthy check timeout out of range, 100ms~120s')
if not 100 <= config['health_check_interval_ms']:
raise exception.InvalidParameter(
msg='Healthy check interval out of rage, 100ms~10m')
if not config['health_check_target_path']:
raise exception.InvalidParameter(
msg='health check path could not be null')
uuid = kwargs['uuid']
try:
load_balancer_ref = db.load_balancer_get_by_uuid(context, uuid)
except Exception, exp:
raise exception.UpdateLoadBalancerFailed(msg=str(exp))
def update_load_balancer_state(context, **kwargs):
code = kwargs['code']
uuid = kwargs['uuid']
try:
load_balancer_ref = db.load_balancer_get_by_uuid(context, uuid)
except Exception, exp:
raise exception.UpdateLoadBalancerFailed(msg=str(exp))
def test_update_load_balancer_instances(self):
update_kwargs = copy.deepcopy(self.delete_kwargs)
new_instance_uuids = ['a-uuid', 'd-uuid', 'e-uuid']
update_kwargs['instance_uuids'] = new_instance_uuids
self.mox.StubOutWithMock(db, 'load_balancer_get_by_uuid')
self.mox.StubOutWithMock(
db, 'load_balancer_instance_association_create')
self.mox.StubOutWithMock(
db, 'load_balancer_instance_association_destroy')
self.mox.StubOutWithMock(db, 'load_balancer_update_state')
load_balancer_ref = self.lb_ref
for uuid in self.instance_uuids:
association_values = {
'load_balancer_id': load_balancer_ref.id,
'instance_uuid': uuid,
}
association_ref = models.LoadBalancerInstanceAssociation()
association_ref.update(association_values)
load_balancer_ref.instances.append(association_ref)
db.load_balancer_get_by_uuid(
self.ctxt, self.uuid).AndReturn(load_balancer_ref)
old_instance_uuids = map(lambda x: x['instance_uuid'],
load_balancer_ref.instances)
need_deleted_instances = filter(lambda x: x not in new_instance_uuids,
old_instance_uuids)
need_created_instances = filter(lambda x: x not in old_instance_uuids,
new_instance_uuids)
for instance_uuid in need_deleted_instances:
db.load_balancer_instance_association_destroy(
self.ctxt, load_balancer_ref.id, instance_uuid).AndReturn(None)
for instance_uuid in need_created_instances:
association_values = {
'load_balancer_id': load_balancer_ref.id,
'instance_uuid': instance_uuid,
}
db.load_balancer_instance_association_create(
self.ctxt, association_values).AndReturn(None)
db.load_balancer_update_state(
self.ctxt, self.uuid, state.UPDATING).AndReturn(None)
self.mox.ReplayAll()
r = tcp.update_load_balancer_instances(self.ctxt, **update_kwargs)
self.mox.VerifyAll()
self.assertEqual(r, None)
def test_update_load_balancer_config_with_invalid_uuid(self):
def _raise_exception(*args):
raise exception.LoadBalancerNotFoundByUUID(
uuid=self.delete_kwargs['uuid'])
update_kwargs = copy.deepcopy(self.delete_kwargs)
update_kwargs['config'] = self.config
self.mox.StubOutWithMock(db, 'load_balancer_get_by_uuid')
db.load_balancer_get_by_uuid(
self.ctxt, self.uuid).WithSideEffects(
_raise_exception).AndReturn(None)
self.mox.ReplayAll()
self.assertRaises(exception.UpdateLoadBalancerFailed,
http.update_load_balancer_config,
self.ctxt, **update_kwargs)
self.mox.VerifyAll()
def update_load_balancer(context, **kwargs):
expect_keys = [
'tenant_id', 'uuid',
]
utils.check_input_parameters(expect_keys, **kwargs)
uuid = kwargs['uuid']
try:
load_balancer_ref = db.load_balancer_get_by_uuid(context, uuid)
except Exception, exp:
raise exception.UpdateLoadBalancerFailed(msg=str(exp))
def create_load_balancer(context, **kwargs):
try:
module = protocol.get_protocol_module(kwargs['protocol'])
module_func = getattr(module, 'create_load_balancer')
result = module_func(context, **kwargs)
uuid = result['data']['uuid']
load_balancer_ref = db.load_balancer_get_by_uuid(context, uuid)
notify(context, load_balancer_ref, 'loadbalancer.create.start')
result = format_msg_to_client(load_balancer_ref)
except Exception, exp:
raise exception.CreateLoadBalancerFailed(msg=str(exp))
def get_load_balancer(context, **kwargs):
expect_keys = [
'tenant_id', 'uuid',
]
utils.check_input_parameters(expect_keys, **kwargs)
result = None
uuid = kwargs['uuid']
try:
load_balancer_ref = db.load_balancer_get_by_uuid(context, uuid)
result = format_msg_to_client(load_balancer_ref)
except Exception, exp:
raise exception.GetLoadBalancerFailed(msg=str(exp))
def delete_load_balancer(context, **kwargs):
expect_keys = [
'tenant_id', 'uuid',
]
utils.check_input_parameters(expect_keys, **kwargs)
uuid = kwargs['uuid']
try:
load_balancer_ref = db.load_balancer_get_by_uuid(context, uuid)
db.load_balancer_update_state(context, uuid, state.DELETING)
notify(context, load_balancer_ref, 'loadbalancer.delete.start')
except Exception, exp:
raise exception.DeleteLoadBalancerFailed(msg=str(exp))
def test_update_load_balancer_config(self):
update_kwargs = copy.deepcopy(self.delete_kwargs)
update_kwargs['config'] = self.config
self.mox.StubOutWithMock(db, 'load_balancer_get_by_uuid')
self.mox.StubOutWithMock(db, 'load_balancer_config_create')
self.mox.StubOutWithMock(db, 'load_balancer_config_destroy')
self.mox.StubOutWithMock(db, 'load_balancer_update_state')
load_balancer_ref = self.lb_ref
load_balancer_ref.config = self.config_ref
db.load_balancer_get_by_uuid(
self.ctxt, self.uuid).AndReturn(load_balancer_ref)
db.load_balancer_config_destroy(
self.ctxt, load_balancer_ref.config.id).AndReturn(None)
db.load_balancer_config_create(
self.ctxt, self.config).AndReturn(self.config_ref)
db.load_balancer_update_state(
self.ctxt, self.uuid, state.UPDATING).AndReturn(None)
self.mox.ReplayAll()
r = http.update_load_balancer_config(self.ctxt, **update_kwargs)
self.mox.VerifyAll()
self.assertEqual(r, None)
def update_load_balancer_instances(context, **kwargs):
expect_keys = [
'user_id', 'tenant_id', 'protocol',
'uuid', 'instance_uuids',
]
utils.check_input_parameters(expect_keys, **kwargs)
new_instance_uuids = kwargs['instance_uuids']
if not new_instance_uuids:
raise exception.InvalidParameter(
msg='instance_uuids can not be null')
uuid = kwargs['uuid']
try:
load_balancer_ref = db.load_balancer_get_by_uuid(context, uuid)
except Exception, exp:
raise exception.UpdateLoadBalancerFailed(msg=str(exp))
def get_msg_to_worker(context, method, **kwargs):
result = dict()
message = dict()
load_balancer_ref = None
if method == 'delete_load_balancer':
result['cmd'] = 'delete_lb'
message['user_id'] = kwargs['user_id']
message['tenant_id'] = kwargs['tenant_id']
message['uuid'] = kwargs['uuid']
message['protocol'] = kwargs['protocol']
elif method == 'create_load_balancer':
result['cmd'] = 'create_lb'
load_balancer_ref = db.load_balancer_get_by_name(context,
kwargs['name'])
message = format_msg_to_worker(load_balancer_ref)
elif method.startswith('update_load_balancer'):
result['cmd'] = 'update_lb'
load_balancer_ref = db.load_balancer_get_by_uuid(context,
kwargs['uuid'])
message = format_msg_to_worker(load_balancer_ref)
else:
return None
result['args'] = message
return result
