bb8cbb4817
Commit https://review.openstack.org/#/c/162999/ changed where the Hyper-V VM configuration files are stored. The files are being stored in the same folder as the instance. Performing a cold resize / migration will cause a os.rename call on the instance's folder, which fails as long as there are configuration files used by Hyper-V in that folder, thus resulting in a failed migration and the instance ending up in ERROR state. Hyper-V configuration files are stored in a subfolder of the instance's folder (e.g.: C:\OpenStack\Instances\instance-000000b6\Virtual Machines). This commit makes sure that Hyper-V configuration files are not being moved during migration by skipping subfolders in the instance's folder. Change-Id: I4874eed7d284fab241e4371e550a88270ca156f1 Closes-Bug: #1453835
194 lines
7.8 KiB
Python
194 lines
7.8 KiB
Python
# Copyright 2014 IBM Corp.
|
|
#
|
|
# 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.
|
|
|
|
import contextlib
|
|
import os
|
|
|
|
import mock
|
|
from nova import utils
|
|
|
|
from hyperv.nova import constants
|
|
from hyperv.nova import pathutils
|
|
from hyperv.nova import vmutils
|
|
from hyperv.tests.unit import test_base
|
|
|
|
|
|
class PathUtilsTestCase(test_base.HyperVBaseTestCase):
|
|
"""Unit tests for the Hyper-V PathUtils class."""
|
|
|
|
def setUp(self):
|
|
super(PathUtilsTestCase, self).setUp()
|
|
self.fake_instance_dir = os.path.join('C:', 'fake_instance_dir')
|
|
self.fake_instance_name = 'fake_instance_name'
|
|
|
|
self._pathutils = pathutils.PathUtils()
|
|
|
|
@mock.patch.object(pathutils.PathUtils, 'rename')
|
|
def check_move_folder_contents(self, mock_rename):
|
|
with contextlib.nested(utils.tempdir(),
|
|
utils.tempdir()) as (src_dir, dest_dir):
|
|
src_fname = os.path.join(src_dir, 'tmp_file.txt')
|
|
dest_fname = os.path.join(dest_dir, 'tmp_file.txt')
|
|
test_file = open(src_fname, 'w')
|
|
test_file.close()
|
|
|
|
# making sure tmp_folder and its contents is not moved.
|
|
fdir = os.path.join(src_dir, 'tmp_folder')
|
|
os.makedirs(fdir)
|
|
unmoved_fname = os.path.join(fdir, 'unmoved_file.txt')
|
|
unmoved_file = open(unmoved_fname, 'w')
|
|
unmoved_file.close()
|
|
|
|
self._pathutils.move_folder_contents(src_dir, dest_dir)
|
|
|
|
mock_rename.assert_called_once_with(src_fname, dest_fname)
|
|
|
|
def _mock_lookup_configdrive_path(self, ext, rescue=False):
|
|
self._pathutils.get_instance_dir = mock.MagicMock(
|
|
return_value=self.fake_instance_dir)
|
|
|
|
def mock_exists(*args, **kwargs):
|
|
path = args[0]
|
|
return True if path[(path.rfind('.') + 1):] == ext else False
|
|
self._pathutils.exists = mock_exists
|
|
configdrive_path = self._pathutils.lookup_configdrive_path(
|
|
self.fake_instance_name, rescue)
|
|
return configdrive_path
|
|
|
|
def _test_lookup_configdrive_path(self, rescue=False):
|
|
configdrive_name = 'configdrive'
|
|
if rescue:
|
|
configdrive_name += '-rescue'
|
|
|
|
for format_ext in constants.DISK_FORMAT_MAP:
|
|
configdrive_path = self._mock_lookup_configdrive_path(format_ext,
|
|
rescue)
|
|
expected_path = os.path.join(self.fake_instance_dir,
|
|
configdrive_name + '.' + format_ext)
|
|
self.assertEqual(expected_path, configdrive_path)
|
|
|
|
def test_lookup_configdrive_path(self):
|
|
self._test_lookup_configdrive_path()
|
|
|
|
def test_lookup_rescue_configdrive_path(self):
|
|
self._test_lookup_configdrive_path(rescue=True)
|
|
|
|
def test_lookup_configdrive_path_non_exist(self):
|
|
self._pathutils.get_instance_dir = mock.MagicMock(
|
|
return_value=self.fake_instance_dir)
|
|
self._pathutils.exists = mock.MagicMock(return_value=False)
|
|
configdrive_path = self._pathutils.lookup_configdrive_path(
|
|
self.fake_instance_name)
|
|
self.assertIsNone(configdrive_path)
|
|
|
|
@mock.patch.object(pathutils.PathUtils, 'unmount_smb_share')
|
|
@mock.patch('os.path.exists')
|
|
def _test_check_smb_mapping(self, mock_exists, mock_unmount_smb_share,
|
|
existing_mappings=True, share_available=False):
|
|
mock_exists.return_value = share_available
|
|
|
|
fake_mappings = (
|
|
[mock.sentinel.smb_mapping] if existing_mappings else [])
|
|
|
|
self._pathutils._smb_conn.Msft_SmbMapping.return_value = (
|
|
fake_mappings)
|
|
|
|
ret_val = self._pathutils.check_smb_mapping(
|
|
mock.sentinel.share_path)
|
|
|
|
self.assertEqual(existing_mappings and share_available, ret_val)
|
|
if existing_mappings and not share_available:
|
|
mock_unmount_smb_share.assert_called_once_with(
|
|
mock.sentinel.share_path, force=True)
|
|
|
|
def test_check_mapping(self):
|
|
self._test_check_smb_mapping()
|
|
|
|
def test_remake_unavailable_mapping(self):
|
|
self._test_check_smb_mapping(existing_mappings=True,
|
|
share_available=False)
|
|
|
|
def test_available_mapping(self):
|
|
self._test_check_smb_mapping(existing_mappings=True,
|
|
share_available=True)
|
|
|
|
def test_mount_smb_share(self):
|
|
fake_create = self._pathutils._smb_conn.Msft_SmbMapping.Create
|
|
self._pathutils.mount_smb_share(mock.sentinel.share_path,
|
|
mock.sentinel.username,
|
|
mock.sentinel.password)
|
|
fake_create.assert_called_once_with(
|
|
RemotePath=mock.sentinel.share_path,
|
|
UserName=mock.sentinel.username,
|
|
Password=mock.sentinel.password)
|
|
|
|
def _test_unmount_smb_share(self, force=False):
|
|
fake_mapping = mock.Mock()
|
|
smb_mapping_class = self._pathutils._smb_conn.Msft_SmbMapping
|
|
smb_mapping_class.return_value = [fake_mapping]
|
|
|
|
self._pathutils.unmount_smb_share(mock.sentinel.share_path,
|
|
force)
|
|
|
|
smb_mapping_class.assert_called_once_with(
|
|
RemotePath=mock.sentinel.share_path)
|
|
fake_mapping.Remove.assert_called_once_with(Force=force)
|
|
|
|
def test_soft_unmount_smb_share(self):
|
|
self._test_unmount_smb_share()
|
|
|
|
def test_force_unmount_smb_share(self):
|
|
self._test_unmount_smb_share(force=True)
|
|
|
|
@mock.patch('os.path.join')
|
|
def test_get_instances_sub_dir(self, fake_path_join):
|
|
|
|
class WindowsError(Exception):
|
|
def __init__(self, winerror=None):
|
|
self.winerror = winerror
|
|
|
|
fake_dir_name = "fake_dir_name"
|
|
fake_windows_error = WindowsError
|
|
self._pathutils._check_create_dir = mock.MagicMock(
|
|
side_effect=WindowsError(pathutils.ERROR_INVALID_NAME))
|
|
with mock.patch('__builtin__.WindowsError',
|
|
fake_windows_error, create=True):
|
|
self.assertRaises(vmutils.HyperVException,
|
|
self._pathutils._get_instances_sub_dir,
|
|
fake_dir_name)
|
|
|
|
def test_copy_vm_console_logs(self):
|
|
fake_local_logs = [mock.sentinel.log_path,
|
|
mock.sentinel.archived_log_path]
|
|
fake_remote_logs = [mock.sentinel.remote_log_path,
|
|
mock.sentinel.remote_archived_log_path]
|
|
|
|
self._pathutils.exists = mock.Mock(return_value=True)
|
|
self._pathutils.copy = mock.Mock()
|
|
self._pathutils.get_vm_console_log_paths = mock.Mock(
|
|
side_effect=[fake_local_logs, fake_remote_logs])
|
|
|
|
self._pathutils.copy_vm_console_logs(mock.sentinel.instance_name,
|
|
mock.sentinel.dest_host)
|
|
|
|
self._pathutils.get_vm_console_log_paths.assert_has_calls(
|
|
[mock.call(mock.sentinel.instance_name),
|
|
mock.call(mock.sentinel.instance_name,
|
|
remote_server=mock.sentinel.dest_host)])
|
|
self._pathutils.copy.assert_has_calls([
|
|
mock.call(mock.sentinel.log_path,
|
|
mock.sentinel.remote_log_path),
|
|
mock.call(mock.sentinel.archived_log_path,
|
|
mock.sentinel.remote_archived_log_path)])
|