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