← Back to branch summary

~ubuntu-cloud-archive/ubuntu/precise/nova/trunk

« back to all changes in this revision

Viewing changes to nova/tests/test_xenapi.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Chuck Short, Adam Gandelman
  • Date: 2012-06-22 12:39:57 UTC
  • mfrom: (1.1.57)
  • Revision ID: package-import@ubuntu.com-20120622123957-hbzwg84nt9rqwg8r
Tags: 2012.2~f2~20120621.14517-0ubuntu1
[ Chuck Short ]
* New upstream version.

[ Adam Gandelman ]
* debian/rules: Temporarily disable test suite while blocking
  tests are investigated. 
* debian/patches/kombu_tests_timeout.patch: Dropped.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_xenapi.py
22
22
import os
23
23
import re
24
24
 
25
 
import mox
26
 
 
27
25
from nova.compute import aggregate_states
28
26
from nova.compute import instance_types
29
27
from nova.compute import power_state
30
 
from nova.compute import task_states
31
 
from nova.compute import vm_states
32
28
from nova import context
33
29
from nova import db
34
30
from nova import exception
35
31
from nova import flags
36
32
from nova import log as logging
37
33
from nova.openstack.common import importutils
 
34
from nova.openstack.common import timeutils
38
35
from nova import test
39
36
from nova.tests.db import fakes as db_fakes
40
37
from nova.tests import fake_network
41
38
from nova.tests import fake_utils
42
39
from nova.tests.glance import stubs as glance_stubs
43
40
from nova.tests.xenapi import stubs
44
 
from nova import utils
45
41
from nova.virt.xenapi import connection as xenapi_conn
46
42
from nova.virt.xenapi import fake as xenapi_fake
47
43
from nova.virt.xenapi import vm_utils
113
109
                  'os_type': 'linux',
114
110
                  'architecture': 'x86-64'}
115
111
 
116
 
    def _create_volume(self, size='0'):
 
112
    def _create_volume(self, size=0):
117
113
        """Create a volume object."""
118
114
        vol = {}
119
115
        vol['size'] = size
157
153
        }
158
154
 
159
155
        for (input, expected) in cases.iteritems():
160
 
            func = volume_utils.VolumeHelper.mountpoint_to_number
161
 
            actual = func(input)
 
156
            actual = volume_utils.mountpoint_to_number(input)
162
157
            self.assertEqual(actual, expected,
163
158
                    '%s yielded %s, not %s' % (input, actual, expected))
164
159
 
166
161
        """This shows how to test helper classes' methods."""
167
162
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVolumeTests)
168
163
        session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
169
 
        helper = volume_utils.VolumeHelper
170
 
        helper.XenAPI = session.get_imported_xenapi()
171
164
        vol = self._create_volume()
172
165
        # oops, wrong mount point!
173
166
        self.assertRaises(volume_utils.StorageError,
174
 
                          helper.parse_volume_info,
 
167
                          volume_utils.parse_volume_info,
175
168
                          self._make_info(),
176
169
                          'dev/sd'
177
170
                          )
180
173
    def test_attach_volume(self):
181
174
        """This shows how to test Ops classes' methods."""
182
175
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVolumeTests)
183
 
        conn = xenapi_conn.get_connection(False)
 
176
        conn = xenapi_conn.XenAPIDriver(False)
184
177
        volume = self._create_volume()
185
178
        instance = db.instance_create(self.context, self.instance_values)
186
179
        vm = xenapi_fake.create_vm(instance.name, 'Running')
198
191
        """This shows how to test when exceptions are raised."""
199
192
        stubs.stubout_session(self.stubs,
200
193
                              stubs.FakeSessionForVolumeFailedTests)
201
 
        conn = xenapi_conn.get_connection(False)
 
194
        conn = xenapi_conn.XenAPIDriver(False)
202
195
        volume = self._create_volume()
203
196
        instance = db.instance_create(self.context, self.instance_values)
204
197
        xenapi_fake.create_vm(instance.name, 'Running')
234
227
        self.user_id = 'fake'
235
228
        self.project_id = 'fake'
236
229
        self.context = context.RequestContext(self.user_id, self.project_id)
237
 
        self.conn = xenapi_conn.get_connection(False)
 
230
        self.conn = xenapi_conn.XenAPIDriver(False)
238
231
 
239
232
    def test_init_host(self):
240
233
        session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
705
698
    def test_rescue(self):
706
699
        instance = self._create_instance()
707
700
        session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
708
 
        vm_ref = vm_utils.VMHelper.lookup(session, instance.name)
 
701
        vm_ref = vm_utils.lookup(session, instance.name)
709
702
 
710
703
        xenapi_fake.create_vbd(vm_ref, "swap", userdevice=1)
711
704
        xenapi_fake.create_vbd(vm_ref, "rootfs", userdevice=0)
712
705
 
713
 
        conn = xenapi_conn.get_connection(False)
 
706
        conn = xenapi_conn.XenAPIDriver(False)
714
707
        image_meta = {'id': glance_stubs.FakeGlance.IMAGE_VHD,
715
708
                      'disk_format': 'vhd'}
716
709
        conn.rescue(self.context, instance, [], image_meta)
717
710
 
718
711
        vm = xenapi_fake.get_record('VM', vm_ref)
719
712
        rescue_name = "%s-rescue" % vm["name_label"]
720
 
        rescue_ref = vm_utils.VMHelper.lookup(session, rescue_name)
 
713
        rescue_ref = vm_utils.lookup(session, rescue_name)
721
714
        rescue_vm = xenapi_fake.get_record('VM', rescue_ref)
722
715
 
723
716
        vdi_uuids = []
727
720
 
728
721
    def test_unrescue(self):
729
722
        instance = self._create_instance()
730
 
        conn = xenapi_conn.get_connection(False)
 
723
        conn = xenapi_conn.XenAPIDriver(False)
731
724
        # Unrescue expects the original instance to be powered off
732
725
        conn.power_off(instance)
733
726
        rescue_vm = xenapi_fake.create_vm(instance.name + '-rescue', 'Running')
735
728
 
736
729
    def test_unrescue_not_in_rescue(self):
737
730
        instance = self._create_instance()
738
 
        conn = xenapi_conn.get_connection(False)
 
731
        conn = xenapi_conn.XenAPIDriver(False)
739
732
        # Ensure that it will not unrescue a non-rescued instance.
740
733
        self.assertRaises(exception.InstanceNotInRescueMode, conn.unrescue,
741
734
                          instance, None)
751
744
            def finish_revert_migration(self, instance):
752
745
                self.finish_revert_migration_called = True
753
746
 
754
 
        conn = xenapi_conn.get_connection(False)
 
747
        conn = xenapi_conn.XenAPIDriver(False)
755
748
        conn._vmops = VMOpsMock()
756
749
        conn.finish_revert_migration(instance, None)
757
750
        self.assertTrue(conn._vmops.finish_revert_migration_called)
875
868
                       "VDI_resize", fake_vdi_resize)
876
869
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests,
877
870
                              product_version=(6, 0, 0))
878
 
        conn = xenapi_conn.get_connection(False)
 
871
        conn = xenapi_conn.XenAPIDriver(False)
879
872
        vdi_ref = xenapi_fake.create_vdi('hurr', 'fake')
880
873
        vdi_uuid = xenapi_fake.get_record('VDI', vdi_ref)['uuid']
881
 
        conn._vmops._resize_instance(instance, vdi_uuid)
 
874
        conn._vmops._resize_instance(instance,
 
875
                                     {'uuid': vdi_uuid, 'ref': vdi_ref})
882
876
        self.assertEqual(called['resize'], True)
883
877
 
884
878
    def test_migrate_disk_and_power_off(self):
885
879
        instance = db.instance_create(self.context, self.instance_values)
886
880
        xenapi_fake.create_vm(instance.name, 'Running')
887
881
        instance_type = db.instance_type_get_by_name(self.context, 'm1.large')
888
 
        conn = xenapi_conn.get_connection(False)
 
882
        conn = xenapi_conn.XenAPIDriver(False)
889
883
        conn.migrate_disk_and_power_off(self.context, instance,
890
884
                                        '127.0.0.1', instance_type, None)
891
885
 
898
892
            raise exception.MigrationError(reason='test failure')
899
893
        self.stubs.Set(vmops.VMOps, "_migrate_vhd", fake_raise)
900
894
 
901
 
        conn = xenapi_conn.get_connection(False)
 
895
        conn = xenapi_conn.XenAPIDriver(False)
902
896
        self.assertRaises(exception.MigrationError,
903
897
                          conn.migrate_disk_and_power_off,
904
898
                          self.context, instance,
925
919
        self.stubs.Set(vmops.VMOps, 'finish_revert_migration',
926
920
                       fake_finish_revert_migration)
927
921
 
928
 
        conn = xenapi_conn.get_connection(False)
 
922
        conn = xenapi_conn.XenAPIDriver(False)
929
923
        network_info = fake_network.fake_get_instance_nw_info(self.stubs,
930
924
                                                              spectacular=True)
931
925
        image_meta = {'id': instance.image_ref, 'disk_format': 'vhd'}
957
951
        self.stubs.Set(stubs.FakeSessionForVMTests,
958
952
                       "VDI_resize_online", fake_vdi_resize)
959
953
 
960
 
        conn = xenapi_conn.get_connection(False)
 
954
        conn = xenapi_conn.XenAPIDriver(False)
961
955
        network_info = fake_network.fake_get_instance_nw_info(self.stubs,
962
956
                                                              spectacular=True)
963
957
        image_meta = {'id': instance.image_ref, 'disk_format': 'vhd'}
979
973
 
980
974
        self.stubs.Set(stubs.FakeSessionForVMTests,
981
975
                       "VDI_resize_online", fake_vdi_resize)
982
 
        conn = xenapi_conn.get_connection(False)
 
976
        conn = xenapi_conn.XenAPIDriver(False)
983
977
        network_info = fake_network.fake_get_instance_nw_info(self.stubs,
984
978
                                                              spectacular=True)
985
979
        image_meta = {'id': instance.image_ref, 'disk_format': 'vhd'}
995
989
 
996
990
        self.stubs.Set(stubs.FakeSessionForVMTests,
997
991
                       "VDI_resize_online", fake_vdi_resize)
998
 
        conn = xenapi_conn.get_connection(False)
 
992
        conn = xenapi_conn.XenAPIDriver(False)
999
993
        network_info = fake_network.fake_get_instance_nw_info(self.stubs,
1000
994
                                                              spectacular=True)
1001
995
        # Resize instance would be determined by the compute call
1036
1030
        self.fake_instance.architecture = 'x86-64'
1037
1031
 
1038
1032
    def assert_disk_type(self, image_meta, expected_disk_type):
1039
 
        actual = vm_utils.VMHelper.determine_disk_image_type(image_meta)
 
1033
        actual = vm_utils.determine_disk_image_type(image_meta)
1040
1034
        self.assertEqual(expected_disk_type, actual)
1041
1035
 
1042
1036
    def test_machine(self):
1085
1079
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
1086
1080
        xenapi_fake.reset()
1087
1081
        xenapi_fake.create_local_srs()
1088
 
        self.conn = xenapi_conn.get_connection(False)
 
1082
        self.conn = xenapi_conn.XenAPIDriver(False)
1089
1083
 
1090
1084
    def test_host_state(self):
1091
1085
        stats = self.conn.get_host_stats()
1137
1131
                                   'Dom0IptablesFirewallDriver')
1138
1132
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
1139
1133
        xenapi_fake.reset()
1140
 
        self.conn = xenapi_conn.get_connection(False)
 
1134
        self.conn = xenapi_conn.XenAPIDriver(False)
1141
1135
 
1142
1136
        self.user_id = 'fake'
1143
1137
        self.project_id = 'fake'
1155
1149
 
1156
1150
        self.context = context.RequestContext(self.user_id, self.project_id)
1157
1151
 
1158
 
        @classmethod
1159
 
        def fake_create_vbd(cls, session, vm_ref, vdi_ref, userdevice,
 
1152
        def fake_create_vbd(session, vm_ref, vdi_ref, userdevice,
1160
1153
                            vbd_type='disk', read_only=False, bootable=True):
1161
1154
            pass
1162
1155
 
1163
 
        self.stubs.Set(vm_utils.VMHelper,
1164
 
                       "create_vbd",
1165
 
                       fake_create_vbd)
 
1156
        self.stubs.Set(vm_utils, 'create_vbd', fake_create_vbd)
1166
1157
 
1167
1158
    def assertIsPartitionCalled(self, called):
1168
1159
        marker = {"partition_called": False}
1172
1163
        self.stubs.Set(vm_utils, "_resize_part_and_fs",
1173
1164
                       fake_resize_part_and_fs)
1174
1165
 
 
1166
        ctx = context.RequestContext(self.user_id, self.project_id)
 
1167
        session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
 
1168
 
 
1169
        disk_image_type = vm_utils.ImageType.DISK_VHD
1175
1170
        instance = db.instance_create(self.context, self.instance_values)
1176
 
        disk_image_type = vm_utils.ImageType.DISK_VHD
1177
 
        vm_ref = "blah"
1178
 
        first_vdi_ref = "blah"
1179
 
        vdis = ["blah"]
1180
 
 
1181
 
        self.conn._vmops._attach_disks(
1182
 
            instance, disk_image_type, vm_ref, first_vdi_ref, vdis)
 
1171
        vm_ref = xenapi_fake.create_vm(instance['name'], 'Halted')
 
1172
        vdi_ref = xenapi_fake.create_vdi(instance['name'], 'fake')
 
1173
 
 
1174
        vdi_uuid = session.call_xenapi('VDI.get_record', vdi_ref)['uuid']
 
1175
        vdis = {'root': {'uuid': vdi_uuid, 'ref': vdi_ref}}
 
1176
 
 
1177
        self.conn._vmops._attach_disks(instance, disk_image_type, vm_ref, vdis)
1183
1178
 
1184
1179
        self.assertEqual(marker["partition_called"], called)
1185
1180
 
1230
1225
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
1231
1226
        db_fakes.stub_out_db_instance_api(self.stubs)
1232
1227
        xenapi_fake.reset()
1233
 
        self.conn = xenapi_conn.get_connection(False)
 
1228
        self.conn = xenapi_conn.XenAPIDriver(False)
1234
1229
 
1235
1230
        self.user_id = 'fake'
1236
1231
        self.project_id = 'fake'
1248
1243
 
1249
1244
        self.context = context.RequestContext(self.user_id, self.project_id)
1250
1245
 
1251
 
        @classmethod
1252
 
        def fake_create_vbd(cls, session, vm_ref, vdi_ref, userdevice,
 
1246
        def fake_create_vbd(session, vm_ref, vdi_ref, userdevice,
1253
1247
                            vbd_type='disk', read_only=False, bootable=True):
1254
1248
            pass
1255
1249
 
1256
 
        self.stubs.Set(vm_utils.VMHelper,
1257
 
                       "create_vbd",
1258
 
                       fake_create_vbd)
 
1250
        self.stubs.Set(vm_utils, 'create_vbd', fake_create_vbd)
1259
1251
 
1260
1252
    def assertCalled(self, instance):
 
1253
        ctx = context.RequestContext(self.user_id, self.project_id)
 
1254
        session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
 
1255
 
1261
1256
        disk_image_type = vm_utils.ImageType.DISK_VHD
1262
 
        vm_ref = "blah"
1263
 
        first_vdi_ref = "blah"
1264
 
        vdis = ["blah"]
 
1257
        vm_ref = xenapi_fake.create_vm(instance['name'], 'Halted')
 
1258
        vdi_ref = xenapi_fake.create_vdi(instance['name'], 'fake')
 
1259
 
 
1260
        vdi_uuid = session.call_xenapi('VDI.get_record', vdi_ref)['uuid']
 
1261
        vdis = {'root': {'uuid': vdi_uuid, 'ref': vdi_ref}}
1265
1262
 
1266
1263
        self.called = False
1267
 
        self.conn._vmops._attach_disks(instance, disk_image_type,
1268
 
                                       vm_ref, first_vdi_ref, vdis)
 
1264
        self.conn._vmops._attach_disks(instance, disk_image_type, vm_ref, vdis)
1269
1265
        self.assertTrue(self.called)
1270
1266
 
1271
1267
    def test_generate_swap(self):
1272
1268
        """Test swap disk generation."""
1273
1269
        instance = db.instance_create(self.context, self.instance_values)
1274
 
        instance = db.instance_update(self.context, instance['id'],
 
1270
        instance = db.instance_update(self.context, instance['uuid'],
1275
1271
                                      {'instance_type_id': 5})
1276
1272
 
1277
 
        @classmethod
1278
 
        def fake_generate_swap(cls, *args, **kwargs):
 
1273
        def fake_generate_swap(*args, **kwargs):
1279
1274
            self.called = True
1280
 
        self.stubs.Set(vm_utils.VMHelper, 'generate_swap',
1281
 
                       fake_generate_swap)
 
1275
        self.stubs.Set(vm_utils, 'generate_swap', fake_generate_swap)
1282
1276
 
1283
1277
        self.assertCalled(instance)
1284
1278
 
1285
1279
    def test_generate_ephemeral(self):
1286
1280
        """Test ephemeral disk generation."""
1287
1281
        instance = db.instance_create(self.context, self.instance_values)
1288
 
        instance = db.instance_update(self.context, instance['id'],
 
1282
        instance = db.instance_update(self.context, instance['uuid'],
1289
1283
                                      {'instance_type_id': 4})
1290
1284
 
1291
 
        @classmethod
1292
 
        def fake_generate_ephemeral(cls, *args):
 
1285
        def fake_generate_ephemeral(*args):
1293
1286
            self.called = True
1294
 
        self.stubs.Set(vm_utils.VMHelper, 'generate_ephemeral',
1295
 
                       fake_generate_ephemeral)
 
1287
        self.stubs.Set(vm_utils, 'generate_ephemeral', fake_generate_ephemeral)
1296
1288
 
1297
1289
        self.assertCalled(instance)
1298
1290
 
1300
1292
class XenAPIBWUsageTestCase(test.TestCase):
1301
1293
    def setUp(self):
1302
1294
        super(XenAPIBWUsageTestCase, self).setUp()
1303
 
        self.stubs.Set(vm_utils.VMHelper, "compile_metrics",
 
1295
        self.stubs.Set(vm_utils, 'compile_metrics',
1304
1296
                       XenAPIBWUsageTestCase._fake_compile_metrics)
1305
1297
        self.flags(target_host='127.0.0.1',
1306
1298
                   xenapi_connection_url='test_url',
1309
1301
                                   'Dom0IptablesFirewallDriver')
1310
1302
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
1311
1303
        xenapi_fake.reset()
1312
 
        self.conn = xenapi_conn.get_connection(False)
 
1304
        self.conn = xenapi_conn.XenAPIDriver(False)
1313
1305
 
1314
1306
    @classmethod
1315
1307
    def _fake_compile_metrics(cls, start_time, stop_time=None):
1324
1316
                self.name = "instance-0001"
1325
1317
                self.uuid = "1-2-3-4-5"
1326
1318
 
1327
 
        result = self.conn.get_all_bw_usage([testinstance()], utils.utcnow())
 
1319
        result = self.conn.get_all_bw_usage([testinstance()],
 
1320
                                            timeutils.utcnow())
1328
1321
        self.assertEqual(result, [])
1329
1322
 
1330
1323
 
1386
1379
                              test_case=self)
1387
1380
        self.context = context.RequestContext(self.user_id, self.project_id)
1388
1381
        self.network = importutils.import_object(FLAGS.network_manager)
1389
 
        self.conn = xenapi_conn.get_connection(False)
 
1382
        self.conn = xenapi_conn.XenAPIDriver(False)
1390
1383
        self.fw = self.conn._vmops.firewall_driver
1391
1384
 
1392
1385
    def _create_instance_ref(self):
1508
1501
            self.assertTrue(len(filter(regex.match, self._out_rules)) > 0,
1509
1502
                            "TCP port 80/81 acceptance rule wasn't added")
1510
1503
 
1511
 
        db.instance_destroy(admin_ctxt, instance_ref['id'])
 
1504
        db.instance_destroy(admin_ctxt, instance_ref['uuid'])
1512
1505
 
1513
1506
    def test_filters_for_instance_with_ip_v6(self):
1514
1507
        self.flags(use_ipv6=True)
1643
1636
        self.flags(sr_matching_filter='yadayadayada')
1644
1637
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
1645
1638
        session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
1646
 
        helper = vm_utils.VMHelper
1647
 
        helper.XenAPI = session.get_imported_xenapi()
1648
1639
        self.assertRaises(exception.StorageRepositoryNotFound,
1649
 
                          helper.safe_find_sr, session)
 
1640
                          vm_utils.safe_find_sr, session)
1650
1641
 
1651
1642
    def test_safe_find_sr_local_storage(self):
1652
1643
        """Ensure the default local-storage is found."""
1653
1644
        self.flags(sr_matching_filter='other-config:i18n-key=local-storage')
1654
1645
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
1655
1646
        session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
1656
 
        helper = vm_utils.VMHelper
1657
 
        helper.XenAPI = session.get_imported_xenapi()
1658
1647
        host_ref = xenapi_fake.get_all('host')[0]
1659
1648
        local_sr = xenapi_fake.create_sr(
1660
1649
                              name_label='Fake Storage',
1663
1652
                                            'Local storage',
1664
1653
                                            'i18n-key': 'local-storage'},
1665
1654
                              host_ref=host_ref)
1666
 
        expected = helper.safe_find_sr(session)
 
1655
        expected = vm_utils.safe_find_sr(session)
1667
1656
        self.assertEqual(local_sr, expected)
1668
1657
 
1669
1658
    def test_safe_find_sr_by_other_criteria(self):
1671
1660
        self.flags(sr_matching_filter='other-config:my_fake_sr=true')
1672
1661
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
1673
1662
        session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
1674
 
        helper = vm_utils.VMHelper
1675
 
        helper.XenAPI = session.get_imported_xenapi()
1676
1663
        host_ref = xenapi_fake.get_all('host')[0]
1677
1664
        local_sr = xenapi_fake.create_sr(name_label='Fake Storage',
1678
1665
                                         type='lvm',
1679
1666
                                         other_config={'my_fake_sr': 'true'},
1680
1667
                                         host_ref=host_ref)
1681
 
        expected = helper.safe_find_sr(session)
 
1668
        expected = vm_utils.safe_find_sr(session)
1682
1669
        self.assertEqual(local_sr, expected)
1683
1670
 
1684
1671
    def test_safe_find_sr_default(self):
1686
1673
        self.flags(sr_matching_filter='default-sr:true')
1687
1674
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
1688
1675
        session = xenapi_conn.XenAPISession('test_url', 'root', 'test_pass')
1689
 
        helper = vm_utils.VMHelper
1690
1676
        pool_ref = xenapi_fake.create_pool('')
1691
 
        helper.XenAPI = session.get_imported_xenapi()
1692
 
        expected = helper.safe_find_sr(session)
 
1677
        expected = vm_utils.safe_find_sr(session)
1693
1678
        self.assertEqual(session.call_xenapi('pool.get_default_SR', pool_ref),
1694
1679
                         expected)
1695
1680
 
1709
1694
        host_ref = xenapi_fake.get_all('host')[0]
1710
1695
        stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
1711
1696
        self.context = context.get_admin_context()
1712
 
        self.conn = xenapi_conn.get_connection(False)
 
1697
        self.conn = xenapi_conn.XenAPIDriver(False)
1713
1698
        self.fake_metadata = {'master_compute': 'host',
1714
1699
                              'host': xenapi_fake.get_record('host',
1715
1700
                                                             host_ref)['uuid']}