← Back to branch summary

~ubuntu-branches/ubuntu/saucy/nova/saucy-proposed

« back to all changes in this revision

Viewing changes to nova/tests/xenapi/stubs.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-05-24 13:12:53 UTC
  • mfrom: (1.1.55)
  • Revision ID: package-import@ubuntu.com-20120524131253-ommql08fg1en06ut
Tags: 2012.2~f1-0ubuntu1
https://launchpad.net/bugs/907197
* New upstream release.
* Prepare for quantal:
  - Dropped debian/patches/upstream/0006-Use-project_id-in-ec2.cloud._format_image.patch
  - Dropped debian/patches/upstream/0005-Populate-image-properties-with-project_id-again.patch
  - Dropped debian/patches/upstream/0004-Fixed-bug-962840-added-a-test-case.patch
  - Dropped debian/patches/upstream/0003-Allow-unprivileged-RADOS-users-to-access-rbd-volumes.patch
  - Dropped debian/patches/upstream/0002-Stop-libvirt-test-from-deleting-instances-dir.patch
  - Dropped debian/patches/upstream/0001-fix-bug-where-nova-ignores-glance-host-in-imageref.patch 
  - Dropped debian/patches/0001-fix-useexisting-deprecation-warnings.patch
* debian/control: Add python-keystone as a dependency. (LP: #907197)
* debian/patches/kombu_tests_timeout.patch: Refreshed.
* debian/nova.conf, debian/nova-common.postinst: Convert to new ini
  file configuration
* debian/patches/nova-manage_flagfile_location.patch: Refreshed

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/xenapi/stubs.py
20
20
 
21
21
from eventlet import tpool
22
22
 
23
 
from nova.virt import xenapi_conn
 
23
from nova.virt.xenapi import connection as xenapi_conn
24
24
from nova.virt.xenapi import fake
25
 
from nova.virt.xenapi import volume_utils
26
25
from nova.virt.xenapi import vm_utils
27
26
from nova.virt.xenapi import vmops
28
 
from nova import utils
29
27
 
30
28
 
31
29
def stubout_firewall_driver(stubs, conn):
40
38
 
41
39
def stubout_instance_snapshot(stubs):
42
40
    @classmethod
43
 
    def fake_fetch_image(cls, context, session, instance, image, user,
44
 
                         project, type):
45
 
        return [dict(vdi_type='os', vdi_uuid=_make_fake_vdi())]
 
41
    def fake_fetch_image(cls, context, session, instance, image, type):
 
42
        return [dict(vdi_type='root', vdi_uuid=_make_fake_vdi())]
46
43
 
47
44
    stubs.Set(vm_utils.VMHelper, 'fetch_image', fake_fetch_image)
48
45
 
53
50
    stubs.Set(vm_utils, '_wait_for_vhd_coalesce', fake_wait_for_vhd_coalesce)
54
51
 
55
52
 
56
 
def stubout_session(stubs, cls, product_version=None, **opt_args):
 
53
def stubout_session(stubs, cls, product_version=(5, 6, 2), **opt_args):
57
54
    """Stubs out three methods from XenAPISession"""
58
55
    def fake_import(self):
59
56
        """Stubs out get_imported_xenapi of XenAPISession"""
64
61
    stubs.Set(xenapi_conn.XenAPISession, '_create_session',
65
62
              lambda s, url: cls(url, **opt_args))
66
63
    stubs.Set(xenapi_conn.XenAPISession, 'get_imported_xenapi',
67
 
                       fake_import)
68
 
    if product_version is None:
69
 
        product_version = (5, 6, 2)
70
 
    stubs.Set(xenapi_conn.XenAPISession, 'get_product_version',
71
 
            lambda s: product_version)
 
64
              fake_import)
 
65
    stubs.Set(xenapi_conn.XenAPISession, '_get_product_version',
 
66
              lambda s: product_version)
72
67
    # NOTE(johannes): logging can't be used reliably from a thread
73
68
    # since it can deadlock with eventlet. It's safe for our faked
74
69
    # sessions to be called synchronously in the unit tests. (see
76
71
    stubs.Set(tpool, 'execute', lambda m, *a, **kw: m(*a, **kw))
77
72
 
78
73
 
79
 
def stub_out_get_target(stubs):
80
 
    """Stubs out _get_target in volume_utils"""
81
 
    def fake_get_target(volume_id):
82
 
        return (None, None)
83
 
 
84
 
    stubs.Set(volume_utils, '_get_target', fake_get_target)
85
 
 
86
 
 
87
74
def stubout_get_this_vm_uuid(stubs):
88
75
    def f():
89
76
        vms = [rec['uuid'] for ref, rec
165
152
    stubs.Set(vm_utils.VMHelper, 'create_vm', f)
166
153
 
167
154
 
168
 
def stubout_loopingcall_start(stubs):
169
 
    def fake_start(self, interval, now=True):
170
 
        self.f(*self.args, **self.kw)
171
 
    stubs.Set(utils.LoopingCall, 'start', fake_start)
172
 
 
173
 
 
174
155
def _make_fake_vdi():
175
156
    sr_ref = fake.get_all('SR')[0]
176
 
    vdi_ref = fake.create_vdi('', False, sr_ref, False)
 
157
    vdi_ref = fake.create_vdi('', sr_ref)
177
158
    vdi_rec = fake.get_record('VDI', vdi_ref)
178
159
    return vdi_rec['uuid']
179
160
 
195
176
 
196
177
    def host_call_plugin(self, _1, _2, plugin, method, _5):
197
178
        if (plugin, method) == ('glance', 'download_vhd'):
198
 
            return fake.as_json(dict(vdi_type='os',
 
179
            return fake.as_json(dict(vdi_type='root',
199
180
                                     vdi_uuid=_make_fake_vdi()))
200
181
        elif (plugin, method) == ("xenhost", "iptables_config"):
201
182
            return fake.as_json(out=self._fake_iptables_save_output,
206
187
 
207
188
    def host_call_plugin_swap(self, _1, _2, plugin, method, _5):
208
189
        if (plugin, method) == ('glance', 'download_vhd'):
209
 
            return fake.as_json(dict(vdi_type='os',
 
190
            return fake.as_json(dict(vdi_type='root',
210
191
                                     vdi_uuid=_make_fake_vdi()),
211
192
                                dict(vdi_type='swap',
212
193
                                     vdi_uuid=_make_fake_vdi()))
218
199
        vm = fake.get_record('VM', ref)
219
200
        if vm['power_state'] != 'Halted':
220
201
            raise fake.Failure(['VM_BAD_POWER_STATE', ref, 'Halted',
221
 
                                  vm['power_state']])
 
202
                                vm['power_state']])
222
203
        vm['power_state'] = 'Running'
223
204
        vm['is_a_template'] = False
224
205
        vm['is_control_domain'] = False
235
216
            is_control_domain=False)
236
217
 
237
218
        sr_ref = "fakesr"
238
 
        template_vdi_ref = fake.create_vdi(label, read_only=True,
239
 
            sr_ref=sr_ref, sharable=False)
 
219
        template_vdi_ref = fake.create_vdi(label, sr_ref, read_only=True)
240
220
 
241
221
        template_vbd_ref = fake.create_vbd(template_vm_ref, template_vdi_ref)
242
222
        return template_vm_ref
250
230
    def SR_scan(self, session_ref, sr_ref):
251
231
        pass
252
232
 
253
 
    def VDI_set_name_label(self, session_ref, vdi_ref, name_label):
254
 
        pass
255
 
 
256
233
 
257
234
class FakeSessionForFirewallTests(FakeSessionForVMTests):
258
235
    """ Stubs out a XenApi Session for doing IPTable Firewall tests """
302
279
 
303
280
 
304
281
def stub_out_vm_methods(stubs):
305
 
    def fake_shutdown(self, inst, vm, method="clean"):
306
 
        pass
307
 
 
308
282
    def fake_acquire_bootlock(self, vm):
309
283
        pass
310
284
 
311
285
    def fake_release_bootlock(self, vm):
312
286
        pass
313
287
 
314
 
    def fake_spawn_rescue(self, context, inst, network_info, image_meta):
315
 
        inst._rescue = False
316
 
 
317
288
    @classmethod
318
289
    def fake_generate_ephemeral(cls, *args):
319
290
        pass
320
291
 
321
 
    stubs.Set(vmops.VMOps, "_shutdown", fake_shutdown)
 
292
    def fake_wait_for_device(dev):
 
293
        pass
 
294
 
322
295
    stubs.Set(vmops.VMOps, "_acquire_bootlock", fake_acquire_bootlock)
323
296
    stubs.Set(vmops.VMOps, "_release_bootlock", fake_release_bootlock)
324
 
    stubs.Set(vmops.VMOps, "spawn_rescue", fake_spawn_rescue)
325
297
    stubs.Set(vm_utils.VMHelper, 'generate_ephemeral', fake_generate_ephemeral)
 
298
    stubs.Set(vm_utils, '_wait_for_device', fake_wait_for_device)
326
299
 
327
300
 
328
301
class FakeSessionForVolumeTests(fake.SessionBase):
360
333
        pass
361
334
 
362
335
 
363
 
class FakeSessionForMigrationTests(FakeSessionForVMTests):
364
 
    """Stubs out a XenAPISession for Migration tests"""
365
 
    def __init__(self, uri):
366
 
        super(FakeSessionForMigrationTests, self).__init__(uri)
367
 
 
368
 
    def VDI_get_by_uuid(self, *args):
369
 
        return 'hurr'
370
 
 
371
 
    def VM_set_name_label(self, *args):
372
 
        pass
373
 
 
374
 
    def VDI_set_name_label(self, session_ref, vdi_ref, name_label):
375
 
        pass
376
 
 
377
 
 
378
336
def stub_out_migration_methods(stubs):
379
337
    def fake_create_snapshot(self, instance):
380
338
        return 'vm_ref', dict(image='foo', snap='bar')
381
339
 
 
340
    def fake_move_disks(self, instance, disk_info):
 
341
        vdi_ref = fake.create_vdi('new', 'fake')
 
342
        return fake.get_record('VDI', vdi_ref)['uuid']
 
343
 
382
344
    @classmethod
383
345
    def fake_get_vdi(cls, session, vm_ref):
384
 
        vdi_ref = fake.create_vdi(name_label='derp', read_only=False,
385
 
                             sr_ref='herp', sharable=False)
 
346
        vdi_ref = fake.create_vdi('derp', 'herp')
386
347
        vdi_rec = session.call_xenapi("VDI.get_record", vdi_ref)
387
348
        return vdi_ref, {'uuid': vdi_rec['uuid'], }
388
349
 
389
 
    def fake_shutdown(self, inst, vm, hard=True):
390
 
        pass
391
 
 
392
350
    @classmethod
393
351
    def fake_sr(cls, session, *args):
394
352
        pass
400
358
    def fake_destroy(*args, **kwargs):
401
359
        pass
402
360
 
403
 
    def fake_reset_network(*args, **kwargs):
404
 
        pass
405
 
 
406
361
    @classmethod
407
362
    def fake_generate_ephemeral(cls, *args):
408
363
        pass
409
364
 
410
365
    stubs.Set(vmops.VMOps, '_destroy', fake_destroy)
 
366
    stubs.Set(vmops.VMOps, '_move_disks', fake_move_disks)
411
367
    stubs.Set(vm_utils.VMHelper, 'scan_default_sr', fake_sr)
412
368
    stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_sr)
413
369
    stubs.Set(vmops.VMOps, '_create_snapshot', fake_create_snapshot)
414
370
    stubs.Set(vm_utils.VMHelper, 'get_vdi_for_vm_safely', fake_get_vdi)
415
371
    stubs.Set(vm_utils.VMHelper, 'get_sr_path', fake_get_sr_path)
416
 
    stubs.Set(vmops.VMOps, 'reset_network', fake_reset_network)
417
 
    stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)
418
372
    stubs.Set(vm_utils.VMHelper, 'generate_ephemeral', fake_generate_ephemeral)