예제 #1
0
 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)
예제 #2
0
 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)
예제 #3
0
 def test_server_destroy_by_sf_id(self):
     values = get_fake_server('1', 1)
     server_ref1 = db_api.server_create(self.conf, values)
     values = get_fake_server('2', 1)
     server_ref2 = db_api.server_create(self.conf, values)
     db_api.server_destroy_by_sf_id(self.conf, '1')
     servers = db_api.server_get_all(self.conf)
     self.assertEqual(len(servers), 1)
 def test_server_destroy_by_sf_id(self):
     values = get_fake_server("1", 1)
     server_ref1 = db_api.server_create(self.conf, values)
     values = get_fake_server("2", 1)
     server_ref2 = db_api.server_create(self.conf, values)
     db_api.server_destroy_by_sf_id(self.conf, "1")
     servers = db_api.server_get_all(self.conf)
     self.assertEqual([dict(server_ref2.iteritems())], [dict(server.iteritems()) for server in servers])
예제 #5
0
 def test_server_get_all(self):
     values = get_fake_server('1', 1)
     server1 = db_api.server_create(self.conf, values)
     server2 = db_api.server_create(self.conf, values)
     servers = db_api.server_get_all(self.conf)
     self.assertEqual([dict(server.iteritems()) for server in servers],
                      [dict(server.iteritems()) for server in [server1,
                                                               server2]])
 def test_server_get_all_by_parent_id(self):
     values1 = get_fake_server("1", 1, "10.0.0.1", 1)
     values2 = get_fake_server("1", 1, "10.0.0.2", 2)
     values3 = get_fake_server("1", 1, "10.0.0.3")
     server_ref1 = db_api.server_create(self.conf, values1)
     server_ref2 = db_api.server_create(self.conf, values2)
     server_ref3 = db_api.server_create(self.conf, values3)
     servers = db_api.server_get_all_by_parent_id(self.conf, 1)
     self.assertEqual([dict(server_ref1.iteritems())], [dict(server.iteritems()) for server in servers])
예제 #7
0
 def test_server_get_all_by_parent_id(self):
     values1 = get_fake_server('1', 1, '10.0.0.1', '1')
     values2 = get_fake_server('1', 1, '10.0.0.2', '2')
     values3 = get_fake_server('1', 1, '10.0.0.3')
     server_ref1 = db_api.server_create(self.conf, values1)
     server_ref2 = db_api.server_create(self.conf, values2)
     server_ref3 = db_api.server_create(self.conf, values3)
     servers = db_api.server_get_all_by_parent_id(self.conf, '1')
     self.assertEqual(len(servers), 1)
     self.assertEqual(servers[0]['id'], server_ref1['id'])
 def test_server_get_by_address(self):
     values1 = get_fake_server("1", 1, "10.0.0.1")
     values2 = get_fake_server("1", 1, "10.0.0.2")
     server1 = db_api.server_create(self.conf, values1)
     server2 = db_api.server_create(self.conf, values2)
     server = db_api.server_get_by_address(self.conf, "10.0.0.1")
     self.assertEqual(dict(server.iteritems()), dict(server1.iteritems()))
     with self.assertRaises(exception.ServerNotFound) as cm:
         db_api.server_get_by_address(self.conf, "192.168.0.1")
     err = cm.exception
     self.assertEqual(err.kwargs, {"server_address": "192.168.0.1"})
예제 #9
0
 def test_server_get_by_address(self):
     values1 = get_fake_server('1', 1, '10.0.0.1')
     values2 = get_fake_server('1', 1, '10.0.0.2')
     server1 = db_api.server_create(self.conf, values1)
     server2 = db_api.server_create(self.conf, values2)
     server = db_api.server_get_by_address(self.conf, '10.0.0.1')
     self.assertEqual(server['id'], server1['id'])
     with self.assertRaises(exception.ServerNotFound) as cm:
         db_api.server_get_by_address(self.conf, '192.168.0.1')
     err = cm.exception
     self.assertEqual(err.kwargs, {'server_address': '192.168.0.1'})
예제 #10
0
 def test_server_get_all_by_sf_id(self):
     values = get_fake_server('1', 1)
     st1 = db_api.server_create(self.conf, values)
     values = get_fake_server('2', 1)
     st2 = db_api.server_create(self.conf, values)
     servers1 = db_api.server_get_all_by_sf_id(self.conf, '1')
     servers2 = db_api.server_get_all_by_sf_id(self.conf, '2')
     self.assertEqual(len(servers1), 1)
     self.assertEqual(servers1[0]['id'], st1['id'])
     self.assertEqual(len(servers2), 1)
     self.assertEqual(servers2[0]['id'], st2['id'])
예제 #11
0
    def test_server_get_all_by_sf_id(self):
        values = get_fake_server('1', 1)
        sr1 = db_api.server_create(self.conf, values)
        sr2 = db_api.server_create(self.conf, values)
        values = get_fake_server('2', 1)
        sr3 = db_api.server_create(self.conf, values)
        sr4 = db_api.server_create(self.conf, values)
        servers1 = db_api.server_get_all_by_sf_id(self.conf, '1')
        servers2 = db_api.server_get_all_by_sf_id(self.conf, '2')

        self.assertEqual([dict(server.iteritems()) for server in servers1],
                         [dict(server.iteritems()) for server in [sr1, sr2]])
        self.assertEqual([dict(server.iteritems()) for server in servers2],
                         [dict(server.iteritems()) for server in [sr3, sr4]])
예제 #12
0
 def test_server_get3_fails(self):
     lb_id, sf_id = self._create_lb_and_sf('1', 'tenant1')
     server_values = get_fake_server(sf_id, 1)
     server_ref1 = db_api.server_create(self.conf, server_values)
     with self.assertRaises(exception.ServerNotFound):
         db_api.server_get(self.conf,
             server_ref1['id'], tenant_id='tenant2')
예제 #13
0
 def test_server_get1(self):
     lb_id, sf_id = self._create_lb_and_sf('1', 'tenant1')
     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()))
예제 #14
0
def create_loadbalancer(ctx, balancer, nodes, probes, vips):
    lb = db_api.unpack_extra(balancer)
    sf = db_api.serverfarm_create(ctx.conf, {'lb_id': lb['id']})
    if 'algorithm' in lb:
        predictor_params = {'sf_id': sf['id'], 'type': lb['algorithm']}
    else:
        predictor_params = {'sf_id': sf['id']}
    db_api.predictor_create(ctx.conf, predictor_params)
    create_server_farm(ctx, sf)
    for node in nodes:
        node_values = db_api.server_pack_extra(node)
        node_values['sf_id'] = sf['id']
        rs_ref = db_api.server_create(ctx.conf, node_values)
        create_rserver(ctx, rs_ref)
        add_rserver_to_server_farm(ctx, sf, rs_ref)

    for probe in probes:
        probe_values = db_api.probe_pack_extra(probe)
        probe_values['lb_id'] = lb['id']
        probe_values['sf_id'] = sf['id']
        probe_ref = db_api.probe_create(ctx.conf, probe_values)
        create_probe(ctx,  probe_ref)
        add_probe_to_server_farm(ctx, sf, probe_ref)

    for vip in vips:
        vip_values = db_api.virtualserver_pack_extra(vip)
        vip_values['lb_id'] = lb['id']
        vip_values['sf_id'] = sf['id']
        vip_ref = db_api.virtualserver_create(ctx.conf, vip_values)
        create_vip(ctx, vip_ref, sf)
예제 #15
0
 def test_server_create(self):
     values = get_fake_server('1', 1)
     server_ref = db_api.server_create(self.conf, values)
     server = dict(server_ref.iteritems())
     self.assertIsNotNone(server['id'])
     values['id'] = server['id']
     self.assertEqual(server, values)
예제 #16
0
 def test_server_destroy(self):
     values = get_fake_server('1', 1)
     server = db_api.server_create(self.conf, values)
     db_api.server_destroy(self.conf, server['id'])
     with self.assertRaises(exception.ServerNotFound) as cm:
         db_api.server_get(self.conf, server['id'])
     err = cm.exception
     self.assertEqual(err.kwargs, {'server_id': server['id']})
    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()))
예제 #18
0
def lb_add_nodes(conf, lb_id, nodes):
    nodes_list = []
    lb = db_api.loadbalancer_get(conf, lb_id)
    sf = db_api.serverfarm_get_all_by_lb_id(conf, lb_id)[0]
    for node in nodes:
        values = db_api.server_pack_extra(node)
        values['sf_id'] = sf['id']
        rs_ref = db_api.server_create(conf, values)
        device_driver = drivers.get_device_driver(conf, lb['device_id'])
        with device_driver.request_context() as ctx:
            commands.add_node_to_loadbalancer(ctx, sf, rs_ref)
        nodes_list.append(db_api.unpack_extra(rs_ref))
    return nodes_list
 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)
예제 #20
0
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']
예제 #21
0
 def test_server_update(self):
     values = get_fake_server('1', 1)
     server_ref = db_api.server_create(self.conf, values)
     update = {'name': 'test',
               'extra': {'cookieName': 'testHTTPCookie',
                         'enableInsert': True,
                         'browserExpire': False,
                         'offset': False,
                         'length': 1000,
                         'secondaryName': 'cookie'}}
     server_ref = db_api.server_update(self.conf, server_ref['id'], update)
     server = dict(server_ref.iteritems())
     values.update(update)
     self.assertIsNotNone(server['id'])
     values['id'] = server['id']
     self.assertEqual(server, values)
 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 test_server_update(self):
     values = get_fake_server("1", 1)
     server_ref = db_api.server_create(self.conf, values)
     update = {
         "name": "test",
         "extra": {
             "cookieName": "testHTTPCookie",
             "enableInsert": True,
             "browserExpire": False,
             "offset": False,
             "length": 1000,
             "secondaryName": "cookie",
         },
     }
     server_ref = db_api.server_update(self.conf, server_ref["id"], update)
     server = dict(server_ref.iteritems())
     values.update(update)
     self.assertIsNotNone(server["id"])
     values["id"] = server["id"]
     self.assertEqual(server, values)
예제 #24
0
 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)
예제 #25
0
    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
예제 #26
0
 def test_server_get_all(self):
     values = get_fake_server('1', 1)
     db_api.server_create(self.conf, values)
     db_api.server_create(self.conf, values)
     servers = db_api.server_get_all(self.conf)
     self.assertEqual(len(servers), 2)
예제 #27
0
 def test_server_get0(self):
     values = get_fake_server('1', 1)
     server_ref1 = db_api.server_create(self.conf, values)
     server_ref2 = db_api.server_get(self.conf, server_ref1['id'])
     self.assertEqual(dict(server_ref1.iteritems()),
                      dict(server_ref2.iteritems()))