← Back to branch summary

~ubuntu-branches/ubuntu/quantal/nova/quantal-proposed

« back to all changes in this revision

Viewing changes to nova/tests/network/test_manager.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-08-16 14:04:11 UTC
  • mto: This revision was merged to the branch mainline in revision 84.
  • Revision ID: package-import@ubuntu.com-20120816140411-0mr4n241wmk30t9l
Tags: upstream-2012.2~f3
Import upstream version 2012.2~f3

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/network/test_manager.py
38
38
 
39
39
 
40
40
HOST = "testhost"
 
41
FAKEUUID = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
41
42
 
42
43
 
43
44
networks = [{'id': 0,
44
 
             'uuid': "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
 
45
             'uuid': FAKEUUID,
45
46
             'label': 'test0',
46
47
             'injected': False,
47
48
             'multi_host': False,
84
85
fixed_ips = [{'id': 0,
85
86
              'network_id': 0,
86
87
              'address': '192.168.0.100',
87
 
              'instance_id': 0,
 
88
              'instance_uuid': 0,
88
89
              'allocated': False,
89
90
              'virtual_interface_id': 0,
90
91
              'floating_ips': []},
91
92
             {'id': 0,
92
93
              'network_id': 1,
93
94
              'address': '192.168.1.100',
94
 
              'instance_id': 0,
 
95
              'instance_uuid': 0,
95
96
              'allocated': False,
96
97
              'virtual_interface_id': 0,
97
98
              'floating_ips': []}]
113
114
         'address': 'DE:AD:BE:EF:00:00',
114
115
         'uuid': '00000000-0000-0000-0000-0000000000000000',
115
116
         'network_id': 0,
116
 
         'instance_id': 0},
 
117
         'instance_uuid': 0},
117
118
        {'id': 1,
118
119
         'address': 'DE:AD:BE:EF:00:01',
119
120
         'uuid': '00000000-0000-0000-0000-0000000000000001',
120
121
         'network_id': 1,
121
 
         'instance_id': 0},
 
122
         'instance_uuid': 0},
122
123
        {'id': 2,
123
124
         'address': 'DE:AD:BE:EF:00:02',
124
125
         'uuid': '00000000-0000-0000-0000-0000000000000002',
125
126
         'network_id': 2,
126
 
         'instance_id': 0}]
 
127
         'instance_uuid': 0}]
127
128
 
128
129
 
129
130
class FlatNetworkTestCase(test.TestCase):
197
198
    def test_validate_networks(self):
198
199
        self.mox.StubOutWithMock(db, 'network_get')
199
200
        self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
200
 
        self.mox.StubOutWithMock(db, "fixed_ip_get_by_address")
 
201
        self.mox.StubOutWithMock(db, 'fixed_ip_get_by_address')
201
202
 
202
 
        requested_networks = [("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
203
 
                               "192.168.1.100")]
 
203
        requested_networks = [('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb',
 
204
                               '192.168.1.100')]
204
205
        db.network_get_all_by_uuids(mox.IgnoreArg(),
205
 
                                mox.IgnoreArg()).AndReturn(networks)
 
206
                                    mox.IgnoreArg()).AndReturn(networks)
206
207
        db.network_get(mox.IgnoreArg(),
207
208
                       mox.IgnoreArg()).AndReturn(networks[1])
208
209
 
209
210
        ip = fixed_ips[1].copy()
210
 
        ip['instance_id'] = None
 
211
        ip['instance_uuid'] = None
211
212
        db.fixed_ip_get_by_address(mox.IgnoreArg(),
212
 
                                    mox.IgnoreArg()).AndReturn(ip)
 
213
                                   mox.IgnoreArg()).AndReturn(ip)
213
214
 
214
215
        self.mox.ReplayAll()
215
216
        self.network.validate_networks(self.context, requested_networks)
282
283
        db.virtual_interface_get_by_instance_and_network(mox.IgnoreArg(),
283
284
                mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'id': 0})
284
285
 
285
 
        db.instance_get(mox.IgnoreArg(),
286
 
                        mox.IgnoreArg()).AndReturn({'security_groups':
287
 
                                                             [{'id': 0}]})
288
286
        db.instance_get(self.context,
289
287
                        1).AndReturn({'display_name': HOST,
290
288
                                      'uuid': 'test-00001'})
291
289
        db.instance_get(mox.IgnoreArg(),
292
 
                        mox.IgnoreArg()).AndReturn({'availability_zone': ''})
 
290
                        mox.IgnoreArg()).AndReturn({'security_groups':
 
291
                                                             [{'id': 0}]})
293
292
        db.fixed_ip_associate_pool(mox.IgnoreArg(),
294
293
                                   mox.IgnoreArg(),
295
294
                                   mox.IgnoreArg()).AndReturn('192.168.0.101')
315
314
        db.virtual_interface_get_by_instance_and_network(mox.IgnoreArg(),
316
315
                mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'id': 0})
317
316
 
318
 
        db.instance_get(mox.IgnoreArg(),
319
 
                        mox.IgnoreArg()).AndReturn({'security_groups':
320
 
                                                             [{'id': 0}]})
321
317
        db.instance_get(self.context,
322
318
                        1).AndReturn({'display_name': HOST,
323
319
                                      'uuid': 'test-00001'})
324
320
        db.instance_get(mox.IgnoreArg(),
325
 
                        mox.IgnoreArg()).AndReturn({'availability_zone': ''})
 
321
                        mox.IgnoreArg()).AndReturn({'security_groups':
 
322
                                                             [{'id': 0}]})
326
323
        db.fixed_ip_associate_pool(mox.IgnoreArg(),
327
324
                                   mox.IgnoreArg(),
328
325
                                   mox.IgnoreArg()).AndReturn('192.168.0.101')
372
369
        self.mox.StubOutWithMock(db, 'network_update')
373
370
        self.mox.StubOutWithMock(db, 'fixed_ip_associate_pool')
374
371
        self.mox.StubOutWithMock(db, 'instance_get')
 
372
        self.mox.StubOutWithMock(db, 'instance_get_by_uuid')
375
373
        self.mox.StubOutWithMock(db,
376
374
                              'virtual_interface_get_by_instance_and_network')
377
375
        self.mox.StubOutWithMock(db, 'fixed_ip_update')
382
380
        db.virtual_interface_get_by_instance_and_network(mox.IgnoreArg(),
383
381
                mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'id': 0})
384
382
 
385
 
        db.instance_get(mox.IgnoreArg(),
386
 
                        mox.IgnoreArg()).AndReturn({'security_groups':
387
 
                                                             [{'id': 0}]})
388
 
 
389
383
        db.instance_get(self.context,
390
384
                        1).AndReturn({'display_name': HOST,
391
385
                                      'uuid': 'test-00001'})
392
386
        db.instance_get(mox.IgnoreArg(),
393
 
                        mox.IgnoreArg()).AndReturn({'availability_zone': ''})
 
387
                        mox.IgnoreArg()).AndReturn({'security_groups':
 
388
                                                             [{'id': 0}]})
 
389
 
394
390
        db.fixed_ip_associate_pool(mox.IgnoreArg(),
395
391
                                   mox.IgnoreArg(),
396
392
                                   mox.IgnoreArg()).AndReturn(fixedip)
421
417
                                              is_admin=False)
422
418
 
423
419
    def test_vpn_allocate_fixed_ip(self):
 
420
        self.mox.StubOutWithMock(db, 'instance_get')
424
421
        self.mox.StubOutWithMock(db, 'fixed_ip_associate')
425
422
        self.mox.StubOutWithMock(db, 'fixed_ip_update')
426
423
        self.mox.StubOutWithMock(db,
427
424
                              'virtual_interface_get_by_instance_and_network')
428
425
 
 
426
        db.instance_get(mox.IgnoreArg(),
 
427
                        mox.IgnoreArg()).AndReturn({'uuid': '42'})
429
428
        db.fixed_ip_associate(mox.IgnoreArg(),
430
429
                              mox.IgnoreArg(),
431
430
                              mox.IgnoreArg(),
446
445
        network = dict(networks[0])
447
446
        network['vpn_private_address'] = '192.168.0.2'
448
447
        network['id'] = None
 
448
        instance = db.instance_create(self.context, {})
449
449
        context_admin = context.RequestContext('testuser', 'testproject',
450
450
                is_admin=True)
451
451
        self.assertRaises(exception.FixedIpNotFoundForNetwork,
452
452
                self.network.allocate_fixed_ip,
453
453
                context_admin,
454
 
                0,
 
454
                instance['id'],
455
455
                network,
456
456
                vpn=True)
457
457
 
463
463
        self.mox.StubOutWithMock(db, 'instance_get')
464
464
 
465
465
        db.instance_get(mox.IgnoreArg(),
 
466
                        mox.IgnoreArg()).AndReturn({'uuid': FAKEUUID})
 
467
        db.instance_get(mox.IgnoreArg(),
466
468
                        mox.IgnoreArg()).AndReturn({'security_groups':
467
469
                                                             [{'id': 0}]})
468
470
        db.fixed_ip_associate_pool(mox.IgnoreArg(),
503
505
                                mox.IgnoreArg()).AndReturn(networks)
504
506
 
505
507
        fixed_ips[1]['network_id'] = networks[1]['id']
506
 
        fixed_ips[1]['instance_id'] = None
 
508
        fixed_ips[1]['instance_uuid'] = None
507
509
        db.fixed_ip_get_by_address(mox.IgnoreArg(),
508
510
                                    mox.IgnoreArg()).AndReturn(fixed_ips[1])
509
511
 
670
672
            raise exception.ProcessExecutionError('',
671
673
                    'Cannot find device "em0"\n')
672
674
 
 
675
        def fake9(*args, **kwargs):
 
676
            raise test.TestingException()
 
677
 
673
678
        # raises because interface doesn't exist
674
679
        self.stubs.Set(self.network.db,
675
680
                       'floating_ip_fixed_ip_associate',
687
692
 
688
693
        # raises because floating_ip is already associated to a fixed_ip
689
694
        self.stubs.Set(self.network.db, 'floating_ip_get_by_address', fake2)
690
 
        self.assertRaises(exception.FloatingIpAssociated,
 
695
        self.stubs.Set(self.network, 'disassociate_floating_ip', fake9)
 
696
 
 
697
        def fake_fixed_ip_get(context, fixed_ip_id):
 
698
            return {'instance_uuid': 'fake_uuid'}
 
699
 
 
700
        self.stubs.Set(self.network.db, 'fixed_ip_get', fake_fixed_ip_get)
 
701
 
 
702
        self.assertRaises(test.TestingException,
691
703
                          self.network.associate_floating_ip,
692
704
                          ctxt,
693
705
                          mox.IgnoreArg(),
837
849
                              'virtual_interface_get_by_instance_and_network')
838
850
        self.mox.StubOutWithMock(db, 'fixed_ip_update')
839
851
 
 
852
        db.instance_get(mox.IgnoreArg(),
 
853
                        mox.IgnoreArg()).AndReturn({'uuid': FAKEUUID})
840
854
        db.fixed_ip_update(mox.IgnoreArg(),
841
855
                           mox.IgnoreArg(),
842
856
                           mox.IgnoreArg())
846
860
        db.instance_get(mox.IgnoreArg(),
847
861
                        mox.IgnoreArg()).AndReturn({'security_groups':
848
862
                                                             [{'id': 0}],
849
 
                                                    'availability_zone': ''})
 
863
                                                    'availability_zone': '',
 
864
                                                    'uuid': FAKEUUID})
850
865
        db.fixed_ip_associate_pool(mox.IgnoreArg(),
851
866
                                   mox.IgnoreArg(),
852
867
                                   mox.IgnoreArg()).AndReturn('192.168.0.101')
870
885
 
871
886
        address = '1.2.3.4'
872
887
        float_addr = db.floating_ip_create(context1.elevated(),
873
 
                {'address': address,
874
 
                 'project_id': context1.project_id})
 
888
                                           {'address': address,
 
889
                                            'project_id': context1.project_id})
875
890
 
876
891
        instance = db.instance_create(context1,
877
 
                {'project_id': 'project1'})
 
892
                                      {'project_id': 'project1'})
878
893
 
879
894
        fix_addr = db.fixed_ip_associate_pool(context1.elevated(),
880
 
                1, instance['id'])
 
895
                                              1, instance['uuid'])
881
896
 
882
897
        # Associate the IP with non-admin user context
883
898
        self.assertRaises(exception.NotAuthorized,
928
943
                {'project_id': 'project1'})
929
944
 
930
945
        elevated = context1.elevated()
931
 
        fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['id'])
 
946
        fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid'])
932
947
        values = {'allocated': True,
933
948
                  'virtual_interface_id': 3}
934
949
        db.fixed_ip_update(elevated, fix_addr, values)
963
978
                {'project_id': 'project1'})
964
979
 
965
980
        elevated = context1.elevated()
966
 
        fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['id'])
 
981
        fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid'])
967
982
        db.fixed_ip_update(elevated, fix_addr, {'deleted': 1})
968
983
        elevated.read_deleted = 'yes'
969
984
        delfixed = db.fixed_ip_get_by_address(elevated, fix_addr)
970
985
        values = {'address': fix_addr,
971
986
                  'network_id': 0,
972
 
                  'instance_id': delfixed['instance_id']}
 
987
                  'instance_uuid': delfixed['instance_uuid']}
973
988
        db.fixed_ip_create(elevated, values)
974
989
        elevated.read_deleted = 'no'
975
990
        newfixed = db.fixed_ip_get_by_address(elevated, fix_addr)
996
1011
        context1 = context.RequestContext('user', 'project1')
997
1012
 
998
1013
        instance = db.instance_create(context1,
999
 
                {'project_id': 'project1'})
 
1014
                                      {'project_id': 'project1'})
1000
1015
 
1001
1016
        elevated = context1.elevated()
1002
 
        fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['id'])
 
1017
        fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid'])
1003
1018
        values = {'allocated': True,
1004
1019
                 'virtual_interface_id': 3}
1005
1020
        db.fixed_ip_update(elevated, fix_addr, values)
1007
1022
        self.flags(force_dhcp_release=True)
1008
1023
        self.network.deallocate_fixed_ip(context1, fix_addr, 'fake')
1009
1024
 
 
1025
    def test_fixed_ip_cleanup_fail(self):
 
1026
        """Verify IP is not deallocated if the security group refresh fails."""
 
1027
        def network_get(_context, network_id):
 
1028
            return networks[network_id]
 
1029
 
 
1030
        self.stubs.Set(db, 'network_get', network_get)
 
1031
 
 
1032
        context1 = context.RequestContext('user', 'project1')
 
1033
 
 
1034
        instance = db.instance_create(context1,
 
1035
                {'project_id': 'project1'})
 
1036
 
 
1037
        elevated = context1.elevated()
 
1038
        fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid'])
 
1039
        values = {'allocated': True,
 
1040
                  'virtual_interface_id': 3}
 
1041
        db.fixed_ip_update(elevated, fix_addr, values)
 
1042
        fixed = db.fixed_ip_get_by_address(elevated, fix_addr)
 
1043
        network = db.network_get(elevated, fixed['network_id'])
 
1044
 
 
1045
        db.instance_destroy(self.context.elevated(), instance['uuid'])
 
1046
        self.assertRaises(exception.InstanceNotFound,
 
1047
                                  self.network.deallocate_fixed_ip,
 
1048
                                  context1,
 
1049
                                  fix_addr,
 
1050
                                  'fake')
 
1051
        fixed = db.fixed_ip_get_by_address(elevated, fix_addr)
 
1052
        self.assertTrue(fixed['allocated'])
 
1053
 
1010
1054
 
1011
1055
class CommonNetworkTestCase(test.TestCase):
1012
1056
 
1229
1273
                                                      {'ip': '172.16.0.2'})
1230
1274
        self.assertTrue(res)
1231
1275
        self.assertEqual(len(res), 1)
1232
 
        self.assertEqual(res[0]['instance_id'], _vifs[1]['instance_id'])
 
1276
        self.assertEqual(res[0]['instance_uuid'], _vifs[1]['instance_uuid'])
1233
1277
 
1234
1278
        # Get instance 2
1235
1279
        res = manager.get_instance_uuids_by_ip_filter(fake_context,
1236
1280
                                                      {'ip': '173.16.0.2'})
1237
1281
        self.assertTrue(res)
1238
1282
        self.assertEqual(len(res), 1)
1239
 
        self.assertEqual(res[0]['instance_id'], _vifs[2]['instance_id'])
 
1283
        self.assertEqual(res[0]['instance_uuid'], _vifs[2]['instance_uuid'])
1240
1284
 
1241
1285
        # Get instance 0 and 1
1242
1286
        res = manager.get_instance_uuids_by_ip_filter(fake_context,
1243
1287
                                                      {'ip': '172.16.0.*'})
1244
1288
        self.assertTrue(res)
1245
1289
        self.assertEqual(len(res), 2)
1246
 
        self.assertEqual(res[0]['instance_id'], _vifs[0]['instance_id'])
1247
 
        self.assertEqual(res[1]['instance_id'], _vifs[1]['instance_id'])
 
1290
        self.assertEqual(res[0]['instance_uuid'], _vifs[0]['instance_uuid'])
 
1291
        self.assertEqual(res[1]['instance_uuid'], _vifs[1]['instance_uuid'])
1248
1292
 
1249
1293
        # Get instance 1 and 2
1250
1294
        res = manager.get_instance_uuids_by_ip_filter(fake_context,
1251
1295
                                                      {'ip': '17..16.0.2'})
1252
1296
        self.assertTrue(res)
1253
1297
        self.assertEqual(len(res), 2)
1254
 
        self.assertEqual(res[0]['instance_id'], _vifs[1]['instance_id'])
1255
 
        self.assertEqual(res[1]['instance_id'], _vifs[2]['instance_id'])
 
1298
        self.assertEqual(res[0]['instance_uuid'], _vifs[1]['instance_uuid'])
 
1299
        self.assertEqual(res[1]['instance_uuid'], _vifs[2]['instance_uuid'])
1256
1300
 
1257
1301
    def test_get_instance_uuids_by_ipv6_regex(self):
1258
1302
        manager = fake_network.FakeNetworkManager()
1274
1318
                                                      {'ip6': '2001:.*2'})
1275
1319
        self.assertTrue(res)
1276
1320
        self.assertEqual(len(res), 1)
1277
 
        self.assertEqual(res[0]['instance_id'], _vifs[1]['instance_id'])
 
1321
        self.assertEqual(res[0]['instance_uuid'], _vifs[1]['instance_uuid'])
1278
1322
 
1279
1323
        # Get instance 2
1280
1324
        ip6 = '2001:db8:69:1f:dead:beff:feff:ef03'
1282
1326
                                                      {'ip6': ip6})
1283
1327
        self.assertTrue(res)
1284
1328
        self.assertEqual(len(res), 1)
1285
 
        self.assertEqual(res[0]['instance_id'], _vifs[2]['instance_id'])
 
1329
        self.assertEqual(res[0]['instance_uuid'], _vifs[2]['instance_uuid'])
1286
1330
 
1287
1331
        # Get instance 0 and 1
1288
1332
        res = manager.get_instance_uuids_by_ip_filter(fake_context,
1289
1333
                                                      {'ip6': '.*ef0[1,2]'})
1290
1334
        self.assertTrue(res)
1291
1335
        self.assertEqual(len(res), 2)
1292
 
        self.assertEqual(res[0]['instance_id'], _vifs[0]['instance_id'])
1293
 
        self.assertEqual(res[1]['instance_id'], _vifs[1]['instance_id'])
 
1336
        self.assertEqual(res[0]['instance_uuid'], _vifs[0]['instance_uuid'])
 
1337
        self.assertEqual(res[1]['instance_uuid'], _vifs[1]['instance_uuid'])
1294
1338
 
1295
1339
        # Get instance 1 and 2
1296
1340
        ip6 = '2001:db8:69:1.:dead:beff:feff:ef0.'
1298
1342
                                                      {'ip6': ip6})
1299
1343
        self.assertTrue(res)
1300
1344
        self.assertEqual(len(res), 2)
1301
 
        self.assertEqual(res[0]['instance_id'], _vifs[1]['instance_id'])
1302
 
        self.assertEqual(res[1]['instance_id'], _vifs[2]['instance_id'])
 
1345
        self.assertEqual(res[0]['instance_uuid'], _vifs[1]['instance_uuid'])
 
1346
        self.assertEqual(res[1]['instance_uuid'], _vifs[2]['instance_uuid'])
1303
1347
 
1304
1348
    def test_get_instance_uuids_by_ip(self):
1305
1349
        manager = fake_network.FakeNetworkManager()
1323
1367
                                                      {'fixed_ip': ip})
1324
1368
        self.assertTrue(res)
1325
1369
        self.assertEqual(len(res), 1)
1326
 
        self.assertEqual(res[0]['instance_id'], _vifs[1]['instance_id'])
 
1370
        self.assertEqual(res[0]['instance_uuid'], _vifs[1]['instance_uuid'])
1327
1371
 
1328
1372
        # Get instance 2
1329
1373
        ip = '173.16.0.2'
1331
1375
                                                      {'fixed_ip': ip})
1332
1376
        self.assertTrue(res)
1333
1377
        self.assertEqual(len(res), 1)
1334
 
        self.assertEqual(res[0]['instance_id'], _vifs[2]['instance_id'])
 
1378
        self.assertEqual(res[0]['instance_uuid'], _vifs[2]['instance_uuid'])
1335
1379
 
1336
1380
    def test_get_network(self):
1337
1381
        manager = fake_network.FakeNetworkManager()
1454
1498
                              {'host': self.network.host})
1455
1499
        project_id = self.context.project_id
1456
1500
        nw_info = self.network.allocate_for_instance(self.context,
1457
 
                                                 instance_id=inst['id'],
1458
 
                                                 instance_uuid='',
1459
 
                                                 host=inst['host'],
1460
 
                                                 vpn=None,
1461
 
                                                 rxtx_factor=3,
1462
 
                                                 project_id=project_id)
 
1501
            instance_id=inst['id'], instance_uuid=inst['uuid'],
 
1502
            host=inst['host'], vpn=None, rxtx_factor=3,
 
1503
            project_id=project_id)
1463
1504
        self.assertEquals(1, len(nw_info))
1464
1505
        fixed_ip = nw_info.fixed_ips()[0]['address']
1465
1506
        self.assertTrue(utils.is_valid_ipv4(fixed_ip))