1147 lines
48 KiB
Python
1147 lines
48 KiB
Python
# Copyright 2012 Cloudbase Solutions Srl
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
Test suite for the Hyper-V driver and related APIs.
|
|
"""
|
|
|
|
import os
|
|
import shutil
|
|
import time
|
|
import uuid
|
|
|
|
import mock
|
|
from mox3 import mox
|
|
from nova.api.metadata import base as instance_metadata
|
|
from nova import context
|
|
from nova import db
|
|
from nova import exception
|
|
from nova.image import glance
|
|
from nova import objects
|
|
from nova.objects import flavor as flavor_obj
|
|
from nova.tests.unit import fake_instance
|
|
from nova.tests.unit import fake_network
|
|
from nova.tests.unit.image import fake as fake_image
|
|
from nova.tests.unit.objects import test_flavor
|
|
from nova import utils
|
|
from nova.virt import configdrive
|
|
from nova.virt import driver
|
|
from nova.virt import images
|
|
from oslo_config import cfg
|
|
from oslo_utils import fileutils
|
|
|
|
from hyperv.nova import basevolumeutils
|
|
from hyperv.nova import constants
|
|
from hyperv.nova import driver as driver_hyperv
|
|
from hyperv.nova import hostutils
|
|
from hyperv.nova import imagecache
|
|
from hyperv.nova import networkutils
|
|
from hyperv.nova import pathutils
|
|
from hyperv.nova import rdpconsoleutils
|
|
from hyperv.nova import serialconsoleops
|
|
from hyperv.nova import vhdutils
|
|
from hyperv.nova import vmops
|
|
from hyperv.nova import vmutils
|
|
from hyperv.nova import volumeops
|
|
from hyperv.nova import volumeutils
|
|
from hyperv.nova import volumeutilsv2
|
|
from hyperv.tests import test
|
|
from hyperv.tests.unit import db_fakes
|
|
from hyperv.tests.unit import fake
|
|
|
|
CONF = cfg.CONF
|
|
CONF.import_opt('vswitch_name', 'hyperv.nova.vif', 'hyperv')
|
|
|
|
|
|
class HyperVAPIBaseTestCase(test.NoDBTestCase):
|
|
"""Base unit tests class for Hyper-V driver calls."""
|
|
|
|
def __init__(self, test_case_name):
|
|
self._mox = mox.Mox()
|
|
super(HyperVAPIBaseTestCase, self).__init__(test_case_name)
|
|
|
|
def setUp(self):
|
|
super(HyperVAPIBaseTestCase, self).setUp()
|
|
|
|
self._user_id = 'fake'
|
|
self._project_id = 'fake'
|
|
self._instance = None
|
|
self._image_metadata = None
|
|
self._fetched_image = None
|
|
self._update_image_raise_exception = False
|
|
self._volume_target_portal = 'testtargetportal:3260'
|
|
self._volume_id = '0ef5d708-45ab-4129-8c59-d774d2837eb7'
|
|
self._context = context.RequestContext(self._user_id, self._project_id)
|
|
self._instance_disks = []
|
|
self._instance_dvds = []
|
|
self._instance_volume_disks = []
|
|
self._test_vm_name = None
|
|
self._test_instance_dir = 'C:\\FakeInstancesPath\\instance-0000001'
|
|
self._check_min_windows_version_satisfied = True
|
|
|
|
self._setup_stubs()
|
|
|
|
self.flags(instances_path=r'C:\Hyper-V\test\instances',
|
|
network_api_class='nova.network.neutronv2.api.API')
|
|
self.flags(force_volumeutils_v1=True, group='hyperv')
|
|
self.flags(force_hyperv_utils_v1=True, group='hyperv')
|
|
|
|
self._conn = driver_hyperv.HyperVDriver(None)
|
|
|
|
def _setup_stubs(self):
|
|
db_fakes.stub_out_db_instance_api(self.stubs)
|
|
fake_image.stub_out_image_service(self.stubs)
|
|
fake_network.stub_out_nw_api_get_instance_nw_info(self.stubs)
|
|
|
|
def fake_fetch(context, image_id, target, user, project):
|
|
self._fetched_image = target
|
|
self.stubs.Set(images, 'fetch', fake_fetch)
|
|
|
|
def fake_get_remote_image_service(context, name):
|
|
class FakeGlanceImageService(object):
|
|
def update(self_fake, context, image_id, image_metadata, f):
|
|
if self._update_image_raise_exception:
|
|
raise vmutils.HyperVException(
|
|
"Simulated update failure")
|
|
self._image_metadata = image_metadata
|
|
return (FakeGlanceImageService(), 1)
|
|
self.stubs.Set(glance, 'get_remote_image_service',
|
|
fake_get_remote_image_service)
|
|
|
|
def fake_check_min_windows_version(fake_self, major, minor):
|
|
if [major, minor] >= [6, 3]:
|
|
return False
|
|
return self._check_min_windows_version_satisfied
|
|
self.stubs.Set(hostutils.HostUtils, 'check_min_windows_version',
|
|
fake_check_min_windows_version)
|
|
|
|
def fake_sleep(ms):
|
|
pass
|
|
self.stubs.Set(time, 'sleep', fake_sleep)
|
|
|
|
self.stubs.Set(pathutils, 'PathUtils', fake.PathUtils)
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'open')
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'copyfile')
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'rmtree')
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'copy')
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'move_folder_files')
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'remove')
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'rename')
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'makedirs')
|
|
self._mox.StubOutWithMock(fake.PathUtils,
|
|
'get_instance_migr_revert_dir')
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'get_instance_dir')
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'get_vm_console_log_paths')
|
|
|
|
self._mox.StubOutWithMock(vmops.VMOps, '_set_instance_disk_qos_specs')
|
|
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'vm_exists')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'create_vm')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'destroy_vm')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'attach_ide_drive')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'attach_scsi_drive')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'create_scsi_controller')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'create_nic')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'set_vm_state')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'get_vm_scsi_controller')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'get_vm_ide_controller')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'get_attached_disks')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils,
|
|
'attach_volume_to_controller')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils,
|
|
'get_mounted_disk_by_drive_number')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'detach_vm_disk')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'get_vm_storage_paths')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'get_free_controller_slot')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils,
|
|
'enable_vm_metrics_collection')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils, 'get_vm_id')
|
|
self._mox.StubOutWithMock(vmutils.VMUtils,
|
|
'set_vm_serial_port_connection')
|
|
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils, 'create_differencing_vhd')
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils, 'reconnect_parent_vhd')
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils, 'merge_vhd')
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils, 'get_vhd_parent_path')
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils, 'get_vhd_info')
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils, 'resize_vhd')
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils,
|
|
'get_internal_vhd_size_by_file_size')
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils, 'validate_vhd')
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils, 'get_vhd_format')
|
|
self._mox.StubOutWithMock(vhdutils.VHDUtils, 'create_dynamic_vhd')
|
|
|
|
self._mox.StubOutWithMock(hostutils.HostUtils, 'get_local_ips')
|
|
|
|
self._mox.StubOutWithMock(imagecache.ImageCache, 'get_image_details')
|
|
|
|
self._mox.StubOutWithMock(networkutils.NetworkUtils,
|
|
'get_external_vswitch')
|
|
self._mox.StubOutWithMock(networkutils.NetworkUtils,
|
|
'create_vswitch_port')
|
|
self._mox.StubOutWithMock(networkutils.NetworkUtils,
|
|
'vswitch_port_needed')
|
|
|
|
self._mox.StubOutWithMock(basevolumeutils.BaseVolumeUtils,
|
|
'volume_in_mapping')
|
|
self._mox.StubOutWithMock(basevolumeutils.BaseVolumeUtils,
|
|
'get_session_id_from_mounted_disk')
|
|
self._mox.StubOutWithMock(basevolumeutils.BaseVolumeUtils,
|
|
'get_device_number_for_target')
|
|
self._mox.StubOutWithMock(basevolumeutils.BaseVolumeUtils,
|
|
'get_target_from_disk_path')
|
|
self._mox.StubOutWithMock(basevolumeutils.BaseVolumeUtils,
|
|
'get_target_lun_count')
|
|
|
|
self._mox.StubOutWithMock(volumeutils.VolumeUtils,
|
|
'login_storage_target')
|
|
self._mox.StubOutWithMock(volumeutils.VolumeUtils,
|
|
'logout_storage_target')
|
|
self._mox.StubOutWithMock(volumeutils.VolumeUtils,
|
|
'execute_log_out')
|
|
self._mox.StubOutWithMock(volumeutils.VolumeUtils,
|
|
'get_iscsi_initiator')
|
|
|
|
self._mox.StubOutWithMock(volumeutilsv2.VolumeUtilsV2,
|
|
'login_storage_target')
|
|
self._mox.StubOutWithMock(volumeutilsv2.VolumeUtilsV2,
|
|
'logout_storage_target')
|
|
self._mox.StubOutWithMock(volumeutilsv2.VolumeUtilsV2,
|
|
'execute_log_out')
|
|
|
|
self._mox.StubOutWithMock(rdpconsoleutils.RDPConsoleUtils,
|
|
'get_rdp_console_port')
|
|
|
|
self._mox.StubOutWithMock(serialconsoleops.SerialConsoleOps,
|
|
'stop_console_handler')
|
|
|
|
self._mox.StubOutClassWithMocks(instance_metadata, 'InstanceMetadata')
|
|
self._mox.StubOutWithMock(instance_metadata.InstanceMetadata,
|
|
'metadata_for_config_drive')
|
|
|
|
# Can't use StubOutClassWithMocks due to __exit__ and __enter__
|
|
self._mox.StubOutWithMock(configdrive, 'ConfigDriveBuilder')
|
|
self._mox.StubOutWithMock(configdrive.ConfigDriveBuilder, 'make_drive')
|
|
|
|
self._mox.StubOutWithMock(fileutils, 'delete_if_exists')
|
|
self._mox.StubOutWithMock(utils, 'execute')
|
|
|
|
def tearDown(self):
|
|
self._mox.UnsetStubs()
|
|
super(HyperVAPIBaseTestCase, self).tearDown()
|
|
|
|
|
|
class HyperVAPITestCase(HyperVAPIBaseTestCase):
|
|
"""Unit tests for Hyper-V driver calls."""
|
|
|
|
def test_public_api_signatures(self):
|
|
self.assertPublicAPISignatures(driver.ComputeDriver(None), self._conn)
|
|
|
|
def _setup_spawn_config_drive_mocks(self, use_cdrom):
|
|
instance_metadata.InstanceMetadata(mox.IgnoreArg(),
|
|
content=mox.IsA(list),
|
|
extra_md=mox.IsA(dict))
|
|
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
|
|
m.AndReturn(self._test_instance_dir)
|
|
|
|
cdb = self._mox.CreateMockAnything()
|
|
m = configdrive.ConfigDriveBuilder(instance_md=mox.IgnoreArg())
|
|
m.AndReturn(cdb)
|
|
# __enter__ and __exit__ are required by "with"
|
|
cdb.__enter__().AndReturn(cdb)
|
|
cdb.make_drive(mox.IsA(str))
|
|
cdb.__exit__(None, None, None).AndReturn(None)
|
|
|
|
if not use_cdrom:
|
|
utils.execute(CONF.hyperv.qemu_img_cmd,
|
|
'convert',
|
|
'-f',
|
|
'raw',
|
|
'-O',
|
|
'vpc',
|
|
mox.IsA(str),
|
|
mox.IsA(str),
|
|
attempts=1)
|
|
fake.PathUtils.remove(mox.IsA(str))
|
|
|
|
m = vmutils.VMUtils.attach_ide_drive(mox.IsA(str),
|
|
mox.IsA(str),
|
|
mox.IsA(int),
|
|
mox.IsA(int),
|
|
mox.IsA(str))
|
|
m.WithSideEffects(self._add_disk)
|
|
|
|
def _check_instance_name(self, vm_name):
|
|
return vm_name == self._instance.name
|
|
|
|
def _setup_destroy_mocks(self, destroy_disks=True):
|
|
m = vmutils.VMUtils.vm_exists(mox.Func(self._check_instance_name))
|
|
m.AndReturn(True)
|
|
|
|
serialconsoleops.SerialConsoleOps.stop_console_handler(mox.IsA(str))
|
|
|
|
func = mox.Func(self._check_instance_name)
|
|
vmutils.VMUtils.set_vm_state(func, constants.HYPERV_VM_STATE_DISABLED)
|
|
|
|
vmutils.VMUtils.destroy_vm(func)
|
|
|
|
if destroy_disks:
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
|
|
create_dir=False,
|
|
remove_dir=True)
|
|
m.AndReturn(self._test_instance_dir)
|
|
|
|
def test_get_instance_disk_info_is_implemented(self):
|
|
instance = objects.Instance()
|
|
# Ensure that the method has been implemented in the driver
|
|
try:
|
|
disk_info = self._conn.get_instance_disk_info(instance)
|
|
self.assertIsNone(disk_info)
|
|
except NotImplementedError:
|
|
self.fail("test_get_instance_disk_info() should not raise "
|
|
"NotImplementedError")
|
|
|
|
def _get_instance_data(self):
|
|
instance_name = 'openstack_unit_test_vm_' + str(uuid.uuid4())
|
|
return db_fakes.get_fake_instance_data(instance_name,
|
|
self._project_id,
|
|
self._user_id)
|
|
|
|
def _get_instance(self):
|
|
updates = self._get_instance_data()
|
|
expected_attrs = updates.pop('expected_attrs', None)
|
|
return objects.Instance._from_db_object(
|
|
context, objects.Instance(),
|
|
fake_instance.fake_db_instance(**updates),
|
|
expected_attrs=expected_attrs)
|
|
|
|
def _spawn_instance(self, cow, block_device_info=None,
|
|
ephemeral_storage=False):
|
|
self.flags(use_cow_images=cow)
|
|
|
|
self._instance_data = self._get_instance_data()
|
|
instance = db.instance_create(self._context, self._instance_data)
|
|
instance['system_metadata'] = {}
|
|
instance.flavor = mock.MagicMock()
|
|
instance.flavor.extra_specs.get.return_value = None
|
|
|
|
if ephemeral_storage:
|
|
instance['ephemeral_gb'] = 1
|
|
|
|
image = db_fakes.get_fake_image_data(self._project_id, self._user_id)
|
|
|
|
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
|
|
|
|
self._conn.spawn(self._context, instance, image,
|
|
injected_files=[], admin_password=None,
|
|
network_info=network_info,
|
|
block_device_info=block_device_info)
|
|
|
|
def _add_disk(self, vm_name, path, ctrller_addr,
|
|
drive_addr, drive_type):
|
|
if drive_type == constants.DISK:
|
|
self._instance_disks.append(path)
|
|
elif drive_type == constants.DVD:
|
|
self._instance_dvds.append(path)
|
|
|
|
def _add_volume_disk(self, vm_name, controller_path, address,
|
|
mounted_disk_path):
|
|
self._instance_volume_disks.append(mounted_disk_path)
|
|
|
|
def _check_img_path(self, image_path):
|
|
return image_path == self._fetched_image
|
|
|
|
def _setup_create_instance_mocks(self, setup_vif_mocks_func=None,
|
|
boot_from_volume=False,
|
|
block_device_info=None,
|
|
admin_permissions=True,
|
|
ephemeral_storage=False):
|
|
vmutils.VMUtils.create_vm(mox.IsA(str), mox.IsA(int),
|
|
mox.IsA(int), mox.IsA(bool),
|
|
CONF.hyperv.dynamic_memory_ratio,
|
|
mox.IsA(int),
|
|
mox.IsA(str),
|
|
mox.IsA(list))
|
|
|
|
if not boot_from_volume:
|
|
m = vmutils.VMUtils.attach_ide_drive(mox.Func(self._check_vm_name),
|
|
mox.IsA(str),
|
|
mox.IsA(int),
|
|
mox.IsA(int),
|
|
mox.IsA(str))
|
|
m.WithSideEffects(self._add_disk).InAnyOrder()
|
|
|
|
if ephemeral_storage:
|
|
m = vmutils.VMUtils.attach_ide_drive(mox.Func(self._check_vm_name),
|
|
mox.IsA(str),
|
|
mox.IsA(int),
|
|
mox.IsA(int),
|
|
mox.IsA(str))
|
|
m.WithSideEffects(self._add_disk).InAnyOrder()
|
|
|
|
func = mox.Func(self._check_vm_name)
|
|
m = vmutils.VMUtils.create_scsi_controller(func)
|
|
m.InAnyOrder()
|
|
|
|
if boot_from_volume:
|
|
mapping = driver.block_device_info_get_mapping(block_device_info)
|
|
data = mapping[0]['connection_info']['data']
|
|
target_lun = data['target_lun']
|
|
target_iqn = data['target_iqn']
|
|
target_portal = data['target_portal']
|
|
|
|
self._mock_attach_volume(mox.Func(self._check_vm_name), target_iqn,
|
|
target_lun, target_portal, True)
|
|
|
|
vmutils.VMUtils.create_nic(mox.Func(self._check_vm_name),
|
|
mox.IsA(str), mox.IsA(unicode)).InAnyOrder()
|
|
|
|
if setup_vif_mocks_func:
|
|
setup_vif_mocks_func()
|
|
|
|
if CONF.hyperv.enable_instance_metrics_collection:
|
|
vmutils.VMUtils.enable_vm_metrics_collection(
|
|
mox.Func(self._check_vm_name))
|
|
|
|
vmutils.VMUtils.set_vm_serial_port_connection(
|
|
mox.IsA(str), mox.IsA(int), mox.IsA(str))
|
|
|
|
vmops.VMOps._set_instance_disk_qos_specs(mox.IgnoreArg())
|
|
|
|
def _set_vm_name(self, vm_name):
|
|
self._test_vm_name = vm_name
|
|
|
|
def _check_vm_name(self, vm_name):
|
|
return vm_name == self._test_vm_name
|
|
|
|
def _setup_check_admin_permissions_mocks(self, admin_permissions=True):
|
|
self._mox.StubOutWithMock(vmutils.VMUtils,
|
|
'check_admin_permissions')
|
|
m = vmutils.VMUtils.check_admin_permissions()
|
|
if admin_permissions:
|
|
m.AndReturn(None)
|
|
else:
|
|
m.AndRaise(vmutils.HyperVAuthorizationException(
|
|
'Simulated failure'))
|
|
|
|
def _setup_get_cached_image_mocks(self, cow=True,
|
|
vhd_format=constants.DISK_FORMAT_VHD):
|
|
m = vhdutils.VHDUtils.get_vhd_format(
|
|
mox.Func(self._check_img_path))
|
|
m.AndReturn(vhd_format)
|
|
|
|
def check_img_path_with_ext(image_path):
|
|
return image_path == self._fetched_image + '.' + vhd_format.lower()
|
|
|
|
fake.PathUtils.rename(mox.Func(self._check_img_path),
|
|
mox.Func(check_img_path_with_ext))
|
|
|
|
if cow and vhd_format == constants.DISK_FORMAT_VHD:
|
|
m = vhdutils.VHDUtils.get_vhd_info(
|
|
mox.Func(check_img_path_with_ext))
|
|
m.AndReturn({'MaxInternalSize': 1024})
|
|
|
|
fake.PathUtils.copyfile(mox.IsA(str), mox.IsA(str))
|
|
|
|
m = vhdutils.VHDUtils.get_internal_vhd_size_by_file_size(
|
|
mox.IsA(unicode), mox.IsA(object))
|
|
m.AndReturn(1025)
|
|
|
|
vhdutils.VHDUtils.resize_vhd(mox.IsA(str), mox.IsA(object),
|
|
is_file_max_size=False)
|
|
|
|
def _setup_spawn_instance_mocks(self, cow, setup_vif_mocks_func=None,
|
|
with_exception=False,
|
|
block_device_info=None,
|
|
boot_from_volume=False,
|
|
config_drive=False,
|
|
use_cdrom=False,
|
|
admin_permissions=True,
|
|
vhd_format=constants.DISK_FORMAT_VHD,
|
|
ephemeral_storage=False):
|
|
m = vmutils.VMUtils.vm_exists(mox.IsA(str))
|
|
m.WithSideEffects(self._set_vm_name).AndReturn(False)
|
|
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
|
|
create_dir=False,
|
|
remove_dir=True)
|
|
m.AndReturn(self._test_instance_dir)
|
|
|
|
if block_device_info:
|
|
m = basevolumeutils.BaseVolumeUtils.volume_in_mapping(
|
|
'fake_root_device_name', block_device_info)
|
|
m.AndReturn(boot_from_volume)
|
|
|
|
if not boot_from_volume:
|
|
m = fake.PathUtils.get_instance_dir(mox.Func(self._check_vm_name))
|
|
m.AndReturn(self._test_instance_dir)
|
|
|
|
self._setup_get_cached_image_mocks(cow, vhd_format)
|
|
m = vhdutils.VHDUtils.get_vhd_info(mox.IsA(str))
|
|
m.AndReturn({'MaxInternalSize': 1024, 'FileSize': 1024,
|
|
'Type': 2})
|
|
|
|
if cow:
|
|
vhdutils.VHDUtils.create_differencing_vhd(mox.IsA(str),
|
|
mox.IsA(str))
|
|
m = vhdutils.VHDUtils.get_vhd_format(mox.IsA(str))
|
|
m.AndReturn(vhd_format)
|
|
else:
|
|
fake.PathUtils.copyfile(mox.IsA(str), mox.IsA(str))
|
|
|
|
if not (cow and vhd_format == constants.DISK_FORMAT_VHD):
|
|
m = vhdutils.VHDUtils.get_internal_vhd_size_by_file_size(
|
|
mox.IsA(unicode), mox.IsA(object))
|
|
m.AndReturn(1025)
|
|
vhdutils.VHDUtils.resize_vhd(mox.IsA(str), mox.IsA(object),
|
|
is_file_max_size=False)
|
|
|
|
self._setup_check_admin_permissions_mocks(
|
|
admin_permissions=admin_permissions)
|
|
if ephemeral_storage:
|
|
m = fake.PathUtils.get_instance_dir(mox.Func(self._check_vm_name))
|
|
m.AndReturn(self._test_instance_dir)
|
|
vhdutils.VHDUtils.create_dynamic_vhd(mox.IsA(str), mox.IsA(int),
|
|
mox.IsA(str))
|
|
|
|
self._setup_create_instance_mocks(setup_vif_mocks_func,
|
|
boot_from_volume,
|
|
block_device_info,
|
|
ephemeral_storage=ephemeral_storage)
|
|
|
|
if config_drive and not with_exception:
|
|
self._setup_spawn_config_drive_mocks(use_cdrom)
|
|
|
|
# TODO(alexpilotti) Based on where the exception is thrown
|
|
# some of the above mock calls need to be skipped
|
|
if with_exception:
|
|
self._setup_destroy_mocks()
|
|
else:
|
|
vmutils.VMUtils.set_vm_state(mox.Func(self._check_vm_name),
|
|
constants.HYPERV_VM_STATE_ENABLED)
|
|
|
|
def _mock_get_mounted_disk_from_lun(self, target_iqn, target_lun,
|
|
fake_mounted_disk,
|
|
fake_device_number):
|
|
m = volumeutils.VolumeUtils.get_device_number_for_target(target_iqn,
|
|
target_lun)
|
|
m.AndReturn(fake_device_number)
|
|
|
|
m = vmutils.VMUtils.get_mounted_disk_by_drive_number(
|
|
fake_device_number)
|
|
m.AndReturn(fake_mounted_disk)
|
|
|
|
def _mock_login_storage_target(self, target_iqn, target_lun, target_portal,
|
|
fake_mounted_disk, fake_device_number):
|
|
m = volumeutils.VolumeUtils.get_device_number_for_target(target_iqn,
|
|
target_lun)
|
|
m.AndReturn(fake_device_number)
|
|
|
|
volumeutils.VolumeUtils.login_storage_target(target_lun,
|
|
target_iqn,
|
|
target_portal,
|
|
'fake_username',
|
|
'fake_password')
|
|
|
|
self._mock_get_mounted_disk_from_lun(target_iqn, target_lun,
|
|
fake_mounted_disk,
|
|
fake_device_number)
|
|
|
|
def _mock_attach_volume(self, instance_name, target_iqn, target_lun,
|
|
target_portal=None, boot_from_volume=False):
|
|
fake_mounted_disk = "fake_mounted_disk"
|
|
fake_device_number = 0
|
|
fake_controller_path = 'fake_scsi_controller_path'
|
|
|
|
self._mock_login_storage_target(target_iqn, target_lun,
|
|
target_portal,
|
|
fake_mounted_disk,
|
|
fake_device_number)
|
|
|
|
self._mock_get_mounted_disk_from_lun(target_iqn, target_lun,
|
|
fake_mounted_disk,
|
|
fake_device_number)
|
|
|
|
if boot_from_volume:
|
|
m = vmutils.VMUtils.get_vm_ide_controller(instance_name, 0)
|
|
m.AndReturn(fake_controller_path)
|
|
fake_free_slot = 0
|
|
else:
|
|
m = vmutils.VMUtils.get_vm_scsi_controller(instance_name)
|
|
m.AndReturn(fake_controller_path)
|
|
|
|
fake_free_slot = 1
|
|
m = vmutils.VMUtils.get_free_controller_slot(
|
|
fake_controller_path)
|
|
m.AndReturn(fake_free_slot)
|
|
|
|
m = vmutils.VMUtils.attach_volume_to_controller(instance_name,
|
|
fake_controller_path,
|
|
fake_free_slot,
|
|
fake_mounted_disk)
|
|
m.WithSideEffects(self._add_volume_disk)
|
|
|
|
def test_attach_volume(self):
|
|
instance = self._get_instance()
|
|
|
|
connection_info = db_fakes.get_fake_volume_info_data(
|
|
self._volume_target_portal, self._volume_id)
|
|
data = connection_info['data']
|
|
target_lun = data['target_lun']
|
|
target_iqn = data['target_iqn']
|
|
target_portal = data['target_portal']
|
|
mount_point = '/dev/sdc'
|
|
|
|
self._mock_attach_volume(instance['name'], target_iqn, target_lun,
|
|
target_portal)
|
|
|
|
self._mox.ReplayAll()
|
|
self._conn.attach_volume(None, connection_info, instance,
|
|
mount_point)
|
|
self._mox.VerifyAll()
|
|
|
|
self.assertEqual(len(self._instance_volume_disks), 1)
|
|
|
|
def _mock_get_mounted_disk_from_lun_error(self, target_iqn, target_lun,
|
|
fake_mounted_disk,
|
|
fake_device_number):
|
|
m = volumeutils.VolumeUtils.get_device_number_for_target(target_iqn,
|
|
target_lun)
|
|
m.AndRaise(vmutils.HyperVException('Simulated failure'))
|
|
|
|
def _mock_attach_volume_target_logout(self, instance_name, target_iqn,
|
|
target_lun, target_portal=None,
|
|
boot_from_volume=False):
|
|
fake_mounted_disk = "fake_mounted disk"
|
|
fake_device_number = 0
|
|
|
|
self._mock_login_storage_target(target_iqn, target_lun,
|
|
target_portal,
|
|
fake_mounted_disk,
|
|
fake_device_number)
|
|
|
|
self._mock_get_mounted_disk_from_lun_error(target_iqn, target_lun,
|
|
fake_mounted_disk,
|
|
fake_device_number)
|
|
|
|
self._mock_logout_storage_target(target_iqn)
|
|
|
|
def test_attach_volume_logout(self):
|
|
instance = self._get_instance()
|
|
|
|
connection_info = db_fakes.get_fake_volume_info_data(
|
|
self._volume_target_portal, self._volume_id)
|
|
data = connection_info['data']
|
|
target_lun = data['target_lun']
|
|
target_iqn = data['target_iqn']
|
|
target_portal = data['target_portal']
|
|
mount_point = '/dev/sdc'
|
|
|
|
self._mock_attach_volume_target_logout(instance.name,
|
|
target_iqn, target_lun,
|
|
target_portal)
|
|
|
|
self._mox.ReplayAll()
|
|
self.assertRaises(vmutils.HyperVException, self._conn.attach_volume,
|
|
None, connection_info, instance, mount_point)
|
|
self._mox.VerifyAll()
|
|
|
|
def test_attach_volume_connection_error(self):
|
|
instance = self._get_instance()
|
|
|
|
connection_info = db_fakes.get_fake_volume_info_data(
|
|
self._volume_target_portal, self._volume_id)
|
|
mount_point = '/dev/sdc'
|
|
|
|
def fake_login_storage_target(self, connection_info):
|
|
raise vmutils.HyperVException('Fake connection exception')
|
|
|
|
self.stubs.Set(volumeops.ISCSIVolumeDriver, 'login_storage_target',
|
|
fake_login_storage_target)
|
|
self.assertRaises(vmutils.HyperVException, self._conn.attach_volume,
|
|
None, connection_info, instance, mount_point)
|
|
|
|
def _mock_detach_volume(self, target_iqn, target_lun,
|
|
other_luns_available=False):
|
|
fake_mounted_disk = "fake_mounted_disk"
|
|
fake_device_number = 0
|
|
m = volumeutils.VolumeUtils.get_device_number_for_target(target_iqn,
|
|
target_lun)
|
|
m.AndReturn(fake_device_number)
|
|
|
|
m = vmutils.VMUtils.get_mounted_disk_by_drive_number(
|
|
fake_device_number)
|
|
m.AndReturn(fake_mounted_disk)
|
|
|
|
vmutils.VMUtils.detach_vm_disk(mox.IsA(str), fake_mounted_disk)
|
|
|
|
self._mock_logout_storage_target(target_iqn, other_luns_available)
|
|
|
|
def _mock_logout_storage_target(self, target_iqn,
|
|
other_luns_available=False):
|
|
|
|
m = volumeutils.VolumeUtils.get_target_lun_count(target_iqn)
|
|
m.AndReturn(1 + int(other_luns_available))
|
|
|
|
if not other_luns_available:
|
|
volumeutils.VolumeUtils.logout_storage_target(target_iqn)
|
|
|
|
def _test_detach_volume(self, other_luns_available=False):
|
|
instance = self._get_instance()
|
|
|
|
connection_info = db_fakes.get_fake_volume_info_data(
|
|
self._volume_target_portal, self._volume_id)
|
|
data = connection_info['data']
|
|
target_lun = data['target_lun']
|
|
target_iqn = data['target_iqn']
|
|
self.assertIn('target_portal', data)
|
|
|
|
mount_point = '/dev/sdc'
|
|
|
|
self._mock_detach_volume(target_iqn, target_lun, other_luns_available)
|
|
self._mox.ReplayAll()
|
|
self._conn.detach_volume(connection_info, instance, mount_point)
|
|
self._mox.VerifyAll()
|
|
|
|
def test_detach_volume(self):
|
|
self._test_detach_volume()
|
|
|
|
def test_detach_volume_multiple_luns_per_target(self):
|
|
# The iSCSI target should not be disconnected in this case.
|
|
self._test_detach_volume(other_luns_available=True)
|
|
|
|
def test_boot_from_volume(self):
|
|
block_device_info = db_fakes.get_fake_block_device_info(
|
|
self._volume_target_portal, self._volume_id)
|
|
|
|
self._setup_spawn_instance_mocks(cow=False,
|
|
block_device_info=block_device_info,
|
|
boot_from_volume=True)
|
|
|
|
self._mox.ReplayAll()
|
|
self._spawn_instance(False, block_device_info)
|
|
self._mox.VerifyAll()
|
|
|
|
self.assertEqual(len(self._instance_volume_disks), 1)
|
|
|
|
def test_get_volume_connector(self):
|
|
self._instance_data = self._get_instance_data()
|
|
instance = db.instance_create(self._context, self._instance_data)
|
|
|
|
fake_my_ip = "fake_ip"
|
|
fake_host = "fake_host"
|
|
fake_initiator = "fake_initiator"
|
|
|
|
self.flags(my_ip=fake_my_ip)
|
|
self.flags(host=fake_host)
|
|
|
|
m = volumeutils.VolumeUtils.get_iscsi_initiator()
|
|
m.AndReturn(fake_initiator)
|
|
|
|
self._mox.ReplayAll()
|
|
data = self._conn.get_volume_connector(instance)
|
|
self._mox.VerifyAll()
|
|
|
|
self.assertEqual(fake_my_ip, data.get('ip'))
|
|
self.assertEqual(fake_host, data.get('host'))
|
|
self.assertEqual(fake_initiator, data.get('initiator'))
|
|
|
|
def test_get_volume_connector_storage_ip(self):
|
|
self._instance_data = self._get_instance_data()
|
|
instance = db.instance_create(self._context, self._instance_data)
|
|
|
|
fake_my_ip = "fake_ip"
|
|
fake_my_block_ip = "fake_block_ip"
|
|
fake_host = "fake_host"
|
|
fake_initiator = "fake_initiator"
|
|
|
|
self.flags(my_ip=fake_my_ip)
|
|
self.flags(my_block_storage_ip=fake_my_block_ip)
|
|
self.flags(host=fake_host)
|
|
|
|
with mock.patch.object(volumeutils.VolumeUtils,
|
|
"get_iscsi_initiator") as mock_initiator:
|
|
mock_initiator.return_value = fake_initiator
|
|
data = self._conn.get_volume_connector(instance)
|
|
|
|
self.assertEqual(fake_my_block_ip, data.get('ip'))
|
|
self.assertEqual(fake_host, data.get('host'))
|
|
self.assertEqual(fake_initiator, data.get('initiator'))
|
|
|
|
def _setup_test_migrate_disk_and_power_off_mocks(self, same_host=False,
|
|
copy_exception=False,
|
|
size_exception=False):
|
|
self._instance = self._get_instance()
|
|
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
|
|
|
|
self._instance['root_gb'] = 10
|
|
|
|
fake_local_ip = '10.0.0.1'
|
|
if same_host:
|
|
fake_dest_ip = fake_local_ip
|
|
else:
|
|
fake_dest_ip = '10.0.0.2'
|
|
|
|
if size_exception:
|
|
flavor = 'm1.tiny'
|
|
else:
|
|
flavor = 'm1.small'
|
|
|
|
flavor = db.flavor_get_by_name(self._context, flavor)
|
|
|
|
if not size_exception:
|
|
fake_root_vhd_path = 'C:\\FakePath\\root.vhd'
|
|
fake_revert_path = os.path.join(self._test_instance_dir, '_revert')
|
|
|
|
serialconsoleops.SerialConsoleOps.stop_console_handler(
|
|
mox.IsA(str))
|
|
func = mox.Func(self._check_instance_name)
|
|
vmutils.VMUtils.set_vm_state(func,
|
|
constants.HYPERV_VM_STATE_DISABLED)
|
|
|
|
m = vmutils.VMUtils.get_vm_storage_paths(func)
|
|
m.AndReturn(([fake_root_vhd_path], []))
|
|
|
|
m = hostutils.HostUtils.get_local_ips()
|
|
m.AndReturn([fake_local_ip])
|
|
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
|
|
m.AndReturn(self._test_instance_dir)
|
|
|
|
m = pathutils.PathUtils.get_instance_migr_revert_dir(
|
|
self._instance.name, remove_dir=True, create_dir=True)
|
|
m.AndReturn(fake_revert_path)
|
|
|
|
if same_host:
|
|
fake.PathUtils.makedirs(mox.IsA(str))
|
|
|
|
m = fake.PathUtils.copy(fake_root_vhd_path, mox.IsA(str))
|
|
if copy_exception:
|
|
m.AndRaise(shutil.Error('Simulated copy error'))
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
|
|
mox.IsA(str),
|
|
remove_dir=True)
|
|
m.AndReturn(self._test_instance_dir)
|
|
else:
|
|
fake.PathUtils.move_folder_files(mox.IsA(str),
|
|
mox.IsA(str))
|
|
destroy_disks = True
|
|
if same_host:
|
|
fake.PathUtils.move_folder_files(mox.IsA(str),
|
|
mox.IsA(str))
|
|
destroy_disks = False
|
|
|
|
self._setup_destroy_mocks(False)
|
|
|
|
if destroy_disks:
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
|
|
mox.IsA(str),
|
|
remove_dir=True)
|
|
m.AndReturn(self._test_instance_dir)
|
|
|
|
return (self._instance, fake_dest_ip, network_info, flavor)
|
|
|
|
def test_migrate_disk_and_power_off(self):
|
|
(instance,
|
|
fake_dest_ip,
|
|
network_info,
|
|
flavor) = self._setup_test_migrate_disk_and_power_off_mocks()
|
|
|
|
self._mox.ReplayAll()
|
|
self._conn.migrate_disk_and_power_off(self._context, instance,
|
|
fake_dest_ip, flavor,
|
|
network_info)
|
|
self._mox.VerifyAll()
|
|
|
|
def test_migrate_disk_and_power_off_same_host(self):
|
|
args = self._setup_test_migrate_disk_and_power_off_mocks(
|
|
same_host=True)
|
|
(instance, fake_dest_ip, network_info, flavor) = args
|
|
|
|
self._mox.ReplayAll()
|
|
self._conn.migrate_disk_and_power_off(self._context, instance,
|
|
fake_dest_ip, flavor,
|
|
network_info)
|
|
self._mox.VerifyAll()
|
|
|
|
def test_migrate_disk_and_power_off_copy_exception(self):
|
|
args = self._setup_test_migrate_disk_and_power_off_mocks(
|
|
copy_exception=True)
|
|
(instance, fake_dest_ip, network_info, flavor) = args
|
|
|
|
self._mox.ReplayAll()
|
|
self.assertRaises(shutil.Error, self._conn.migrate_disk_and_power_off,
|
|
self._context, instance, fake_dest_ip,
|
|
flavor, network_info)
|
|
self._mox.VerifyAll()
|
|
|
|
def test_migrate_disk_and_power_off_smaller_root_vhd_size_exception(self):
|
|
args = self._setup_test_migrate_disk_and_power_off_mocks(
|
|
size_exception=True)
|
|
(instance, fake_dest_ip, network_info, flavor) = args
|
|
|
|
self._mox.ReplayAll()
|
|
self.assertRaises(exception.InstanceFaultRollback,
|
|
self._conn.migrate_disk_and_power_off,
|
|
self._context, instance, fake_dest_ip,
|
|
flavor, network_info)
|
|
self._mox.VerifyAll()
|
|
|
|
def _mock_attach_config_drive(self, instance, config_drive_format):
|
|
instance['config_drive'] = True
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'lookup_configdrive_path')
|
|
m = fake.PathUtils.lookup_configdrive_path(
|
|
mox.Func(self._check_instance_name))
|
|
|
|
if config_drive_format in constants.DISK_FORMAT_MAP:
|
|
m.AndReturn(self._test_instance_dir + '/configdrive.' +
|
|
config_drive_format)
|
|
else:
|
|
m.AndReturn(None)
|
|
|
|
m = vmutils.VMUtils.attach_ide_drive(
|
|
mox.Func(self._check_instance_name),
|
|
mox.IsA(str),
|
|
mox.IsA(int),
|
|
mox.IsA(int),
|
|
mox.IsA(str))
|
|
m.WithSideEffects(self._add_disk).InAnyOrder()
|
|
|
|
def _verify_attach_config_drive(self, config_drive_format):
|
|
if config_drive_format == constants.DISK_FORMAT.lower():
|
|
self.assertEqual(self._instance_disks[1],
|
|
self._test_instance_dir + '/configdrive.' +
|
|
config_drive_format)
|
|
elif config_drive_format == constants.DVD_FORMAT.lower():
|
|
self.assertEqual(self._instance_dvds[0],
|
|
self._test_instance_dir + '/configdrive.' +
|
|
config_drive_format)
|
|
|
|
def _test_finish_migration(self, power_on, ephemeral_storage=False,
|
|
config_drive=False,
|
|
config_drive_format='iso'):
|
|
self._instance = self._get_instance()
|
|
self._instance.memory_mb = 100
|
|
self._instance.vcpus = 2
|
|
self._instance['system_metadata'] = {}
|
|
self._instance['old_flavor'] = objects.Flavor(root_gb=5)
|
|
flavor = flavor_obj.Flavor(**test_flavor.fake_flavor)
|
|
self._instance.flavor = flavor
|
|
self._instance_data = self._get_instance_data()
|
|
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
|
|
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
|
|
m.AndReturn(self._test_instance_dir)
|
|
|
|
self._mox.StubOutWithMock(fake.PathUtils, 'exists')
|
|
m = fake.PathUtils.exists(mox.IsA(unicode))
|
|
m.AndReturn(True)
|
|
|
|
fake_parent_vhd_path = (os.path.join('FakeParentPath', '%s.vhd' %
|
|
self._instance["image_ref"]))
|
|
|
|
m = vhdutils.VHDUtils.get_vhd_info(mox.IsA(str))
|
|
m.AndReturn({'ParentPath': fake_parent_vhd_path,
|
|
'MaxInternalSize': 1})
|
|
m = vhdutils.VHDUtils.get_internal_vhd_size_by_file_size(
|
|
mox.IsA(unicode), mox.IsA(object))
|
|
m.AndReturn(1025)
|
|
|
|
vhdutils.VHDUtils.reconnect_parent_vhd(mox.IsA(str), mox.IsA(unicode))
|
|
|
|
m = vhdutils.VHDUtils.get_vhd_info(mox.IsA(unicode))
|
|
m.AndReturn({'MaxInternalSize': 1024})
|
|
|
|
m = fake.PathUtils.exists(mox.IsA(unicode))
|
|
m.AndReturn(True)
|
|
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
|
|
if ephemeral_storage:
|
|
return m.AndReturn(self._test_instance_dir)
|
|
else:
|
|
m.AndReturn(None)
|
|
|
|
self._set_vm_name(self._instance.name)
|
|
self._setup_create_instance_mocks(None, False,
|
|
ephemeral_storage=ephemeral_storage)
|
|
|
|
if power_on:
|
|
vmutils.VMUtils.set_vm_state(mox.Func(self._check_instance_name),
|
|
constants.HYPERV_VM_STATE_ENABLED)
|
|
|
|
if config_drive:
|
|
self._mock_attach_config_drive(self._instance,
|
|
config_drive_format)
|
|
|
|
self._mox.ReplayAll()
|
|
|
|
image_meta = {'properties': {constants.IMAGE_PROP_VM_GEN:
|
|
constants.IMAGE_PROP_VM_GEN_1}}
|
|
self._conn.finish_migration(self._context, None,
|
|
self._instance, "",
|
|
network_info, image_meta, False, None,
|
|
power_on)
|
|
self._mox.VerifyAll()
|
|
|
|
if config_drive:
|
|
self._verify_attach_config_drive(config_drive_format)
|
|
|
|
def test_finish_migration_power_on(self):
|
|
self._test_finish_migration(True)
|
|
|
|
def test_finish_migration_power_off(self):
|
|
self._test_finish_migration(False)
|
|
|
|
def test_finish_migration_with_ephemeral_storage(self):
|
|
self._test_finish_migration(False, ephemeral_storage=True)
|
|
|
|
def test_finish_migration_attach_config_drive_iso(self):
|
|
self._test_finish_migration(False, config_drive=True,
|
|
config_drive_format=constants.DVD_FORMAT.lower())
|
|
|
|
def test_finish_migration_attach_config_drive_vhd(self):
|
|
self._test_finish_migration(False, config_drive=True,
|
|
config_drive_format=constants.DISK_FORMAT.lower())
|
|
|
|
def test_confirm_migration(self):
|
|
self._instance = self._get_instance()
|
|
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
|
|
|
|
pathutils.PathUtils.get_instance_migr_revert_dir(
|
|
self._instance.name,
|
|
remove_dir=True)
|
|
self._mox.ReplayAll()
|
|
self._conn.confirm_migration(None, self._instance, network_info)
|
|
self._mox.VerifyAll()
|
|
|
|
def _test_finish_revert_migration(self, power_on, ephemeral_storage=False,
|
|
config_drive=False,
|
|
config_drive_format='iso'):
|
|
self._instance = self._get_instance()
|
|
self._instance.memory_mb = 100
|
|
self._instance.vcpus = 2
|
|
self._instance['system_metadata'] = {}
|
|
flavor = flavor_obj.Flavor(**test_flavor.fake_flavor)
|
|
self._instance.flavor = flavor
|
|
self._instance_data = self._get_instance_data()
|
|
|
|
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
|
|
|
|
fake_revert_path = ('C:\\FakeInstancesPath\\%s\\_revert' %
|
|
self._instance.name)
|
|
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
|
|
create_dir=False,
|
|
remove_dir=True)
|
|
m.AndReturn(self._test_instance_dir)
|
|
|
|
m = pathutils.PathUtils.get_instance_migr_revert_dir(
|
|
self._instance.name)
|
|
m.AndReturn(fake_revert_path)
|
|
fake.PathUtils.rename(fake_revert_path, mox.IsA(str))
|
|
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
|
|
m.AndReturn(self._test_instance_dir)
|
|
|
|
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
|
|
if ephemeral_storage:
|
|
m.AndReturn(self._test_instance_dir)
|
|
else:
|
|
m.AndReturn(None)
|
|
|
|
m = imagecache.ImageCache.get_image_details(mox.IsA(object),
|
|
mox.IsA(object))
|
|
m.AndReturn({'properties': {constants.IMAGE_PROP_VM_GEN:
|
|
constants.IMAGE_PROP_VM_GEN_1}})
|
|
|
|
self._set_vm_name(self._instance.name)
|
|
self._setup_create_instance_mocks(None, False,
|
|
ephemeral_storage=ephemeral_storage)
|
|
|
|
if power_on:
|
|
vmutils.VMUtils.set_vm_state(mox.Func(self._check_instance_name),
|
|
constants.HYPERV_VM_STATE_ENABLED)
|
|
|
|
if config_drive:
|
|
self._mock_attach_config_drive(self._instance, config_drive_format)
|
|
|
|
self._mox.ReplayAll()
|
|
self._conn.finish_revert_migration(self._context, self._instance,
|
|
network_info, None,
|
|
power_on)
|
|
self._mox.VerifyAll()
|
|
|
|
if config_drive:
|
|
self._verify_attach_config_drive(config_drive_format)
|
|
|
|
def test_finish_revert_migration_power_on(self):
|
|
self._test_finish_revert_migration(True)
|
|
|
|
def test_finish_revert_migration_power_off(self):
|
|
self._test_finish_revert_migration(False)
|
|
|
|
def test_finish_revert_migration_with_ephemeral_storage(self):
|
|
self._test_finish_revert_migration(False, ephemeral_storage=True)
|
|
|
|
def test_finish_revert_migration_attach_config_drive_iso(self):
|
|
self._test_finish_revert_migration(False, config_drive=True,
|
|
config_drive_format=constants.DVD_FORMAT.lower())
|
|
|
|
def test_finish_revert_migration_attach_config_drive_vhd(self):
|
|
self._test_finish_revert_migration(False, config_drive=True,
|
|
config_drive_format=constants.DISK_FORMAT.lower())
|
|
|
|
def test_plug_vifs(self):
|
|
# Check to make sure the method raises NotImplementedError.
|
|
self.assertRaises(NotImplementedError,
|
|
self._conn.plug_vifs,
|
|
instance=mock.sentinel.instance,
|
|
network_info=None)
|
|
|
|
def test_unplug_vifs(self):
|
|
# Check to make sure the method raises NotImplementedError.
|
|
self.assertRaises(NotImplementedError,
|
|
self._conn.unplug_vifs,
|
|
instance=mock.sentinel.instance,
|
|
network_info=None)
|
|
|
|
def test_refresh_instance_security_rules(self):
|
|
self.assertRaises(NotImplementedError,
|
|
self._conn.refresh_instance_security_rules,
|
|
instance=None)
|
|
|
|
def test_get_rdp_console(self):
|
|
self.flags(my_ip="192.168.1.1")
|
|
|
|
self._instance = self._get_instance()
|
|
|
|
fake_port = 9999
|
|
fake_vm_id = "fake_vm_id"
|
|
|
|
m = rdpconsoleutils.RDPConsoleUtils.get_rdp_console_port()
|
|
m.AndReturn(fake_port)
|
|
|
|
m = vmutils.VMUtils.get_vm_id(mox.IsA(str))
|
|
m.AndReturn(fake_vm_id)
|
|
|
|
self._mox.ReplayAll()
|
|
connect_info = self._conn.get_rdp_console(self._context,
|
|
self._instance)
|
|
self._mox.VerifyAll()
|
|
|
|
self.assertEqual(CONF.my_ip, connect_info.host)
|
|
self.assertEqual(fake_port, connect_info.port)
|
|
self.assertEqual(fake_vm_id, connect_info.internal_access_path)
|