openstack
/
compute-hyperv
Code Issues Proposed changes

Converting compute-hyperv to py3 

Initial conversion with 2to3 tool
Added support for Python3
Replaces / with // for Py3 compatibility
Adds Py2.7 compatibility
Fix IOUtils Py3 compatibility issue. The method retrieving
buffer data was raising a TypeError on Py3.

Co-Authored-By: Alessandro Pilotti <apilotti@cloudbasesolutions.com>
Co-Authored-By: Claudiu Belu <cbelu@cloudbasesolutions.com>
Co-Authored-By: Lucian Petrut <lpetrut@cloudbasesolutions.com>

Change-Id: I99212227105d5fd442a7bd88eb8832586a187e2f
This commit is contained in:
Adelina Tuvenie 2015-09-23 04:45:40 -07:00 committed by Lucian Petrut
parent 61b87f8094
commit cca46626a9
33 changed files with 138 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
doc/source/conf.py
View File

@ -37,8 +37,8 @@ source_suffix = '.rst'
master_doc = 'index'
# General information about the project.
project = u'compute-hyperv'
copyright = u'2013, OpenStack Foundation'
project = 'compute-hyperv'
copyright = '2013, OpenStack Foundation'
# If true, '()' will be appended to :func: etc. cross-reference text.
add_function_parentheses = True
@ -67,8 +67,8 @@ htmlhelp_basename = '%sdoc' % project
latex_documents = [
('index',
'%s.tex' % project,
u'%s Documentation' % project,
u'OpenStack Foundation', 'manual'),
'%s Documentation' % project,
'OpenStack Foundation', 'manual'),
]
# Example configuration for intersphinx: refer to the Python standard library.

10
hyperv/nova/basevolumeutils.py
View File

@ -25,7 +25,7 @@ import re
import sys
if sys.platform == 'win32':
import _winreg
from six.moves import winreg
import wmi
from nova import block_device
@ -66,11 +66,11 @@ class BaseVolumeUtils(object):
keypath = ("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\"
"iSCSI\\Discovery")
try:
key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, keypath, 0,
_winreg.KEY_ALL_ACCESS)
temp = _winreg.QueryValueEx(key, 'DefaultInitiatorName')
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, keypath, 0,
winreg.KEY_ALL_ACCESS)
temp = winreg.QueryValueEx(key, 'DefaultInitiatorName')
initiator_name = str(temp[0])
_winreg.CloseKey(key)
winreg.CloseKey(key)
except Exception:
LOG.info(_LI("The ISCSI initiator name can't be found. "
"Choosing the default one"))

2
hyperv/nova/constants.py
View File

@ -126,7 +126,7 @@ SERIAL_PORT_TYPES = {
DEFAULT_SERIAL_CONSOLE_PORT = 1
SERIAL_CONSOLE_BUFFER_SIZE = 4 * units.Ki
MAX_CONSOLE_LOG_FILE_SIZE = units.Mi / 2
MAX_CONSOLE_LOG_FILE_SIZE = units.Mi // 2
JOB_STATE_COMPLETED = 7
JOB_STATE_TERMINATED = 8

2
hyperv/nova/eventhandler.py
View File

@ -64,7 +64,7 @@ class InstanceEventHandler(object):
self._vmutils = utilsfactory.get_vmutils()
self._listener = self._vmutils.get_vm_power_state_change_listener(
timeframe=CONF.hyperv.power_state_check_timeframe,
filtered_states=self._TRANSITION_MAP.keys())
filtered_states=list(self._TRANSITION_MAP.keys()))
self._serial_console_ops = serialconsoleops.SerialConsoleOps()

15
hyperv/nova/hostops.py
View File

@ -19,6 +19,7 @@ Management class for host operations.
import datetime
import os
import platform
import six
import time
@ -81,12 +82,12 @@ class HostOps(object):
topology = dict()
topology['sockets'] = len(processors)
topology['cores'] = processors[0]['NumberOfCores']
topology['threads'] = (processors[0]['NumberOfLogicalProcessors'] /
topology['threads'] = (processors[0]['NumberOfLogicalProcessors'] //
processors[0]['NumberOfCores'])
cpu_info['topology'] = topology
features = list()
for fkey, fname in constants.PROCESSOR_FEATURE.items():
for fkey, fname in six.iteritems(constants.PROCESSOR_FEATURE):
if self._hostutils.is_cpu_feature_present(fkey):
features.append(fname)
cpu_info['features'] = features
@ -95,16 +96,16 @@ class HostOps(object):
def _get_memory_info(self):
(total_mem_kb, free_mem_kb) = self._hostutils.get_memory_info()
total_mem_mb = total_mem_kb / 1024
free_mem_mb = free_mem_kb / 1024
total_mem_mb = total_mem_kb // 1024
free_mem_mb = free_mem_kb // 1024
return (total_mem_mb, free_mem_mb, total_mem_mb - free_mem_mb)
def _get_local_hdd_info_gb(self):
drive = os.path.splitdrive(self._pathutils.get_instances_dir())[0]
(size, free_space) = self._hostutils.get_volume_info(drive)
total_gb = size / units.Gi
free_gb = free_space / units.Gi
total_gb = size // units.Gi
free_gb = free_space // units.Gi
used_gb = total_gb - free_gb
return (total_gb, free_gb, used_gb)
@ -222,7 +223,7 @@ class HostOps(object):
# value is same as in libvirt
return "%s up %s, 0 users, load average: 0, 0, 0" % (
str(time.strftime("%H:%M:%S")),
str(datetime.timedelta(milliseconds=long(tick_count64))))
str(datetime.timedelta(milliseconds=int(tick_count64))))
def host_maintenance_mode(self, host, mode):
"""Starts/Stops host maintenance. On start, it triggers

8
hyperv/nova/hostutils.py
View File

@ -61,8 +61,8 @@ class HostUtils(object):
mem_info = self._conn_cimv2.query("SELECT TotalVisibleMemorySize, "
"FreePhysicalMemory "
"FROM win32_operatingsystem")[0]
return (long(mem_info.TotalVisibleMemorySize),
long(mem_info.FreePhysicalMemory))
return (int(mem_info.TotalVisibleMemorySize),
int(mem_info.FreePhysicalMemory))
def get_volume_info(self, drive):
"""Returns a tuple with total size and free space
@ -72,11 +72,11 @@ class HostUtils(object):
"FROM win32_logicaldisk "
"WHERE DeviceID='%s'"
% drive)[0]
return (long(logical_disk.Size), long(logical_disk.FreeSpace))
return (int(logical_disk.Size), int(logical_disk.FreeSpace))
def check_min_windows_version(self, major, minor, build=0):
version_str = self.get_windows_version()
return map(int, version_str.split('.')) >= [major, minor, build]
return list(map(int, version_str.split('.'))) >= [major, minor, build]
def get_windows_version(self):
if self._conn_cimv2:

13
hyperv/nova/ioutils.py
View File

@ -14,6 +14,7 @@
# under the License.
import ctypes
import six
import struct
import sys
@ -27,7 +28,11 @@ from hyperv.nova import vmutils
LOG = logging.getLogger(__name__)
Queue = patcher.original('Queue')
# Avoid using six.moves.queue as we need a non monkey patched class
if sys.version_info > (3, 0):
Queue = patcher.original('queue')
else:
Queue = patcher.original('Queue')
if sys.platform == 'win32':
from ctypes import wintypes
@ -230,13 +235,11 @@ class IOUtils(object):
return (ctypes.c_ubyte * buff_size)()
def get_buffer_data(self, buff, num_bytes):
data = "".join([struct.pack('B', b)
for b in buff[:num_bytes]])
return data
return bytes(bytearray(buff[:num_bytes]))
def write_buffer_data(self, buff, data):
for i, c in enumerate(data):
buff[i] = struct.unpack('B', c)[0]
buff[i] = struct.unpack('B', six.b(c))[0]
class IOQueue(Queue.Queue):

5
hyperv/nova/livemigrationutils.py
View File

@ -20,6 +20,7 @@ if sys.platform == 'win32':
from nova import exception
from oslo_log import log as logging
import six
from hyperv.i18n import _, _LE
from hyperv.nova import vmutils
@ -119,13 +120,13 @@ class LiveMigrationUtils(object):
scsi_ctrl_path = self._vmutils.get_vm_scsi_controller(vm_name)
scsi_paths = self._vmutils.get_controller_volume_paths(scsi_ctrl_path)
return dict(ide_paths.items() + scsi_paths.items())
return dict(list(ide_paths.items()) + list(scsi_paths.items()))
def _get_remote_disk_data(self, vmutils_remote, disk_paths, dest_host):
volutils_remote = volumeutilsv2.VolumeUtilsV2(dest_host)
disk_paths_remote = {}
for (rasd_rel_path, disk_path) in disk_paths.items():
for rasd_rel_path, disk_path in six.iteritems(disk_paths):
target = self._volutils.get_target_from_disk_path(disk_path)
if target:
(target_iqn, target_lun) = target

4
hyperv/nova/pathutils.py
View File

@ -72,8 +72,8 @@ class PathUtils(object):
def open(self, path, mode):
"""Wrapper on __builtin__.open used to simplify unit testing."""
import __builtin__
return __builtin__.open(path, mode)
from six.moves import builtins
return builtins.open(path, mode)
def exists(self, path):
return os.path.exists(path)

3
hyperv/nova/serialconsolehandler.py
View File

@ -20,6 +20,7 @@ from nova import exception
from nova.i18n import _, _LI # noqa
from oslo_config import cfg
from oslo_log import log as logging
import six
from hyperv.nova import constants
from hyperv.nova import ioutils
@ -109,7 +110,7 @@ class SerialConsoleHandler(object):
log_rw_pipe_output = not serial_port_mapping.get(
constants.SERIAL_PORT_TYPE_RO)
for pipe_type, pipe_path in serial_port_mapping.iteritems():
for pipe_type, pipe_path in six.iteritems(serial_port_mapping):
enable_logging = (pipe_type == constants.SERIAL_PORT_TYPE_RO or
log_rw_pipe_output)
handler = self._get_named_pipe_handler(

2
hyperv/nova/serialconsoleops.py
View File

@ -93,7 +93,7 @@ class SerialConsoleOps(object):
instance_name)
try:
log = ''
log = b''
# Start with the oldest console log file.
for log_path in console_log_paths[::-1]:
if os.path.exists(log_path):

7
hyperv/nova/utilsfactory.py
View File

@ -16,6 +16,7 @@
from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import importutils
import six
from hyperv.i18n import _
from hyperv.nova import hostutils
@ -33,7 +34,7 @@ class_utils = {
'hostutils': {'HostUtils': {'min_version': 6.0, 'max_version': 6.2},
'HostUtilsV2': {'min_version': 6.2, 'max_version': None}},
'livemigrationutils': {'LiveMigrationUtils': {'min_version': 6.0,
'max_version': 'None'}},
'max_version': None}},
'networkutils': {'NetworkUtils': {'min_version': 6.0,
'max_version': 6.2},
'NetworkUtilsV2': {'min_version': 6.2,
@ -61,11 +62,11 @@ def _get_class(utils_class_type):
% utils_class_type)
windows_version = utils.get_windows_version()
build = map(int, windows_version.split('.'))
build = list(map(int, windows_version.split('.')))
windows_version = float("%i.%i" % (build[0], build[1]))
existing_classes = class_utils.get(utils_class_type)
for class_variant in existing_classes.keys():
for class_variant in six.iterkeys(existing_classes):
version = existing_classes.get(class_variant)
if (version['min_version'] <= windows_version and
(version['max_version'] is None or

8
hyperv/nova/vhdutils.py
View File

@ -43,8 +43,8 @@ VHD_HEADER_SIZE_DYNAMIC = 512
VHD_FOOTER_SIZE_DYNAMIC = 512
VHD_BLK_SIZE_OFFSET = 544
VHD_SIGNATURE = 'conectix'
VHDX_SIGNATURE = 'vhdxfile'
VHD_SIGNATURE = b'conectix'
VHDX_SIGNATURE = b'vhdxfile'
class VHDUtils(object):
@ -145,7 +145,7 @@ class VHDUtils(object):
fs = VHD_FOOTER_SIZE_DYNAMIC
max_internal_size = (new_vhd_file_size -
(hs + ddhs + fs)) * bs / (bes + bs)
(hs + ddhs + fs)) * bs // (bes + bs)
return max_internal_size
else:
vhd_parent = self.get_vhd_parent_path(vhd_path)
@ -184,7 +184,7 @@ class VHDUtils(object):
if name == "ParentPath":
vhd_info_dict[name] = value_text
elif name in ["FileSize", "MaxInternalSize"]:
vhd_info_dict[name] = long(value_text)
vhd_info_dict[name] = int(value_text)
elif name in ["InSavedState", "InUse"]:
vhd_info_dict[name] = bool(value_text)
elif name == "Type":

6
hyperv/nova/vhdutilsv2.py
View File

@ -160,11 +160,11 @@ class VHDUtilsV2(vhdutils.VHDUtils):
ls = self._get_vhdx_log_size(f)
ms = self._get_vhdx_metadata_size_and_offset(f)[0]
chunk_ratio = (1 << 23) * lss / bs
chunk_ratio = (1 << 23) * lss // bs
size = new_vhd_file_size
max_internal_size = (bs * chunk_ratio * (size - hs -
ls - ms - bes - bes / chunk_ratio) / (bs *
ls - ms - bes - bes // chunk_ratio) // (bs *
chunk_ratio + bes * chunk_ratio + bes))
return max_internal_size - (max_internal_size % bs)
@ -237,7 +237,7 @@ class VHDUtilsV2(vhdutils.VHDUtils):
vhd_info_dict[name] = value_text
elif name in ["BlockSize", "LogicalSectorSize",
"PhysicalSectorSize", "MaxInternalSize"]:
vhd_info_dict[name] = long(value_text)
vhd_info_dict[name] = int(value_text)
elif name in ["Type", "Format"]:
vhd_info_dict[name] = int(value_text)

9
hyperv/nova/vmops.py
View File

@ -36,6 +36,7 @@ from oslo_utils import excutils
from oslo_utils import fileutils
from oslo_utils import units
from oslo_utils import uuidutils
import six
from hyperv.i18n import _, _LI, _LE, _LW
from hyperv.nova import constants
@ -717,7 +718,7 @@ class VMOps(object):
self.power_on(instance, block_device_info, network_info)
def _create_vm_com_port_pipes(self, instance, serial_ports):
for port_number, port_type in serial_ports.iteritems():
for port_number, port_type in six.iteritems(serial_ports):
pipe_path = r'\\.\pipe\%s_%s' % (instance.uuid, port_type)
self._vmutils.set_vm_serial_port_connection(
instance.name, port_number, pipe_path)
@ -733,9 +734,9 @@ class VMOps(object):
image_props = image_meta['properties']
serial_ports = {}
for image_prop, port_type in constants.SERIAL_PORT_TYPES.iteritems():
for img_prop, port_type in six.iteritems(constants.SERIAL_PORT_TYPES):
port_number = int(image_props.get(
image_prop,
img_prop,
constants.DEFAULT_SERIAL_CONSOLE_PORT))
if port_number not in [1, 2]:
@ -892,7 +893,7 @@ class VMOps(object):
def _get_storage_qos_specs(self, instance):
extra_specs = instance.flavor.get('extra_specs') or {}
storage_qos_specs = {}
for spec, value in extra_specs.iteritems():
for spec, value in six.iteritems(extra_specs):
if ':' in spec:
scope, key = spec.split(':')
if scope == 'storage_qos':

10
hyperv/nova/vmutils.py
View File

@ -171,10 +171,10 @@ class VMUtils(object):
si = summary_info[0]
memory_usage = None
if si.MemoryUsage is not None:
memory_usage = long(si.MemoryUsage)
memory_usage = int(si.MemoryUsage)
up_time = None
if si.UpTime is not None:
up_time = long(si.UpTime)
up_time = int(si.UpTime)
# Nova requires a valid state to be returned. Hyper-V has more
# states than Nova, typically intermediate ones and since there is
@ -224,14 +224,14 @@ class VMUtils(object):
mem_settings = vmsetting.associators(
wmi_result_class=self._MEMORY_SETTING_DATA_CLASS)[0]
max_mem = long(memory_mb)
max_mem = int(memory_mb)
mem_settings.Limit = max_mem
if dynamic_memory_ratio > 1:
mem_settings.DynamicMemoryEnabled = True
# Must be a multiple of 2
reserved_mem = min(
long(max_mem / dynamic_memory_ratio) >> 1 << 1,
int(max_mem // dynamic_memory_ratio) >> 1 << 1,
max_mem)
else:
mem_settings.DynamicMemoryEnabled = False
@ -246,7 +246,7 @@ class VMUtils(object):
def _set_vm_vcpus(self, vm, vmsetting, vcpus_num, limit_cpu_features):
procsetting = vmsetting.associators(
wmi_result_class=self._PROCESSOR_SETTING_DATA_CLASS)[0]
vcpus = long(vcpus_num)
vcpus = int(vcpus_num)
procsetting.VirtualQuantity = vcpus
procsetting.Reservation = vcpus
procsetting.Limit = 100000 # static assignment to 100%

7
hyperv/nova/volumeops.py
View File

@ -29,6 +29,7 @@ from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import excutils
from oslo_utils import units
import six
from six.moves import range
from hyperv.i18n import _, _LE, _LW
@ -97,7 +98,7 @@ class VolumeOps(object):
mapping = driver.block_device_info_get_mapping(block_device_info)
block_devices = self._group_block_devices_by_type(
mapping)
for driver_type, block_device_mapping in block_devices.items():
for driver_type, block_device_mapping in six.iteritems(block_devices):
volume_driver = self._get_volume_driver(driver_type)
volume_driver.disconnect_volumes(block_device_mapping)
@ -195,7 +196,7 @@ class VolumeOps(object):
def _bytes_per_sec_to_iops(self, no_bytes):
# Hyper-v uses normalized IOPS (8 KB increments)
# as IOPS allocation units.
return (no_bytes + self._IOPS_BASE_SIZE - 1) / self._IOPS_BASE_SIZE
return (no_bytes + self._IOPS_BASE_SIZE - 1) // self._IOPS_BASE_SIZE
def _group_block_devices_by_type(self, block_device_mapping):
block_devices = collections.defaultdict(list)
@ -252,7 +253,7 @@ class ISCSIVolumeDriver(object):
target_iqn = vol['connection_info']['data']['target_iqn']
iscsi_targets[target_iqn] += 1
for target_iqn, disconnected_luns in iscsi_targets.items():
for target_iqn, disconnected_luns in six.iteritems(iscsi_targets):
self.logout_storage_target(target_iqn, disconnected_luns)
def logout_storage_target(self, target_iqn, disconnected_luns_count=1):

3
hyperv/tests/fake_instance.py
View File

@ -17,6 +17,7 @@ import uuid
from nova import objects
from nova.objects import fields
import six
def fake_db_instance(**updates):
@ -43,7 +44,7 @@ def fake_db_instance(**updates):
'tags': []
}
for name, field in objects.Instance.fields.items():
for name, field in six.iteritems(objects.Instance.fields):
if name in db_instance:
continue
if field.nullable:

5
hyperv/tests/test.py
View File

@ -28,6 +28,7 @@ eventlet.monkey_patch(os=False)
import inspect
import mock
import six
import fixtures
from nova.tests import fixtures as nova_fixtures
@ -111,13 +112,13 @@ class NoDBTestCase(testtools.TestCase):
# Delete attributes that don't start with _ so they don't pin
# memory around unnecessarily for the duration of the test
# suite
for key in [k for k in self.__dict__.keys() if k[0] != '_']:
for key in [k for k in six.iterkeys(self.__dict__) if k[0] != '_']:
del self.__dict__[key]
def flags(self, **kw):
"""Override flag variables for a test."""
group = kw.pop('group', None)
for k, v in kw.iteritems():
for k, v in six.iteritems(kw):
CONF.set_override(k, v, group)
def assertPublicAPISignatures(self, baseinst, inst):

5
hyperv/tests/unit/test_base.py
View File

@ -15,6 +15,7 @@
# under the License.
import mock
from six.moves import builtins
from hyperv.nova import utilsfactory
from hyperv.tests import test
@ -25,8 +26,8 @@ class HyperVBaseTestCase(test.NoDBTestCase):
super(HyperVBaseTestCase, self).setUp()
self._mock_wmi = mock.MagicMock()
wmi_patcher = mock.patch('__builtin__.wmi', create=True,
new=self._mock_wmi)
wmi_patcher = mock.patch.object(builtins, 'wmi', create=True,
new=self._mock_wmi)
platform_patcher = mock.patch('sys.platform', 'win32')
hostutils_patcher = mock.patch.object(utilsfactory, 'utils')

2
hyperv/tests/unit/test_basevolumeutils.py
View File

@ -64,7 +64,7 @@ class BaseVolumeUtilsTestCase(test.NoDBTestCase):
mock_computer]
with mock.patch.object(basevolumeutils,
'_winreg', create=True) as mock_winreg:
'winreg', create=True) as mock_winreg:
mock_winreg.OpenKey = winreg_method
mock_winreg.QueryValueEx = mock.MagicMock(return_value=[expected])

9
hyperv/tests/unit/test_hostops.py
View File

@ -22,6 +22,7 @@ from nova import objects
from oslo_config import cfg
from oslo_serialization import jsonutils
from oslo_utils import units
import six
from hyperv.nova import constants
from hyperv.nova import hostops
@ -66,7 +67,7 @@ class HostOpsTestCase(test_base.HyperVBaseTestCase):
self._hostops._hostutils.get_cpus_info.assert_called_once_with()
expected = [mock.call(fkey)
for fkey in constants.PROCESSOR_FEATURE.keys()]
for fkey in six.iterkeys(constants.PROCESSOR_FEATURE)]
self._hostops._hostutils.is_cpu_feature_present.has_calls(expected)
expected_response = self._get_mock_cpu_info()
self.assertEqual(expected_response, response)
@ -76,7 +77,7 @@ class HostOpsTestCase(test_base.HyperVBaseTestCase):
'model': self.FAKE_NAME,
'arch': constants.WMI_WIN32_PROCESSOR_ARCHITECTURE[
self.FAKE_ARCHITECTURE],
'features': constants.PROCESSOR_FEATURE.values(),
'features': list(constants.PROCESSOR_FEATURE.values()),
'topology': {'cores': self.FAKE_NUM_CPUS,
'threads': self.FAKE_NUM_CPUS,
'sockets': self.FAKE_NUM_CPUS}}
@ -94,7 +95,7 @@ class HostOpsTestCase(test_base.HyperVBaseTestCase):
self.assertEqual((2, 1, 1), response)
def test_get_local_hdd_info_gb(self):
self._hostops._pathutils.get_instance_dir.return_value = ''
self._hostops._pathutils.get_instances_dir.return_value = ''
self._hostops._hostutils.get_volume_info.return_value = (2 * units.Gi,
1 * units.Gi)
response = self._hostops._get_local_hdd_info_gb()
@ -195,7 +196,7 @@ class HostOpsTestCase(test_base.HyperVBaseTestCase):
self.FAKE_TICK_COUNT)
response = self._hostops.get_host_uptime()
tdelta = datetime.timedelta(milliseconds=long(self.FAKE_TICK_COUNT))
tdelta = datetime.timedelta(milliseconds=int(self.FAKE_TICK_COUNT))
expected = "%s up %s, 0 users, load average: 0, 0, 0" % (
str(mock_time()), str(tdelta))

8
hyperv/tests/unit/test_hostutils.py
View File

@ -32,10 +32,10 @@ class FakeCPUSpec(object):
class HostUtilsTestCase(test.NoDBTestCase):
"""Unit tests for the Hyper-V hostutils class."""
_FAKE_MEMORY_TOTAL = 1024L
_FAKE_MEMORY_FREE = 512L
_FAKE_DISK_SIZE = 1024L
_FAKE_DISK_FREE = 512L
_FAKE_MEMORY_TOTAL = 1024
_FAKE_MEMORY_FREE = 512
_FAKE_DISK_SIZE = 1024
_FAKE_DISK_FREE = 512
_FAKE_VERSION_GOOD = '6.2.0'
_FAKE_VERSION_BAD = '6.1.9'

8
hyperv/tests/unit/test_ioutils.py
View File

@ -14,6 +14,8 @@
# under the License.
import ctypes
import six
import mock
from hyperv.nova import constants
@ -36,14 +38,14 @@ class IOUtilsTestCase(test_base.HyperVBaseTestCase):
@mock.patch.object(ioutils.IOUtils, 'handle_last_error')
def test_run_and_check_output(self, mock_handle_last_error):
mock_func = mock.Mock()
mock_func.__name__ = mock.sentinel.func_name
mock_func.__name__ = mock.sentinel.__name__
ret_val = self._ioutils._run_and_check_output(
mock_func, error_codes=[mock_func()],
ignored_error_codes=mock.sentinel.ignored_error_codes)
mock_handle_last_error.assert_called_once_with(
func_name=mock.sentinel.func_name,
func_name=mock.sentinel.__name__,
ignored_error_codes=mock.sentinel.ignored_error_codes)
self.assertEqual(mock_func(), ret_val)
@ -73,7 +75,7 @@ class IOUtilsTestCase(test_base.HyperVBaseTestCase):
self._ioutils.write_buffer_data(fake_buffer, fake_data)
buff_data = self._ioutils.get_buffer_data(fake_buffer, len(fake_data))
self.assertEqual(fake_data, buff_data)
self.assertEqual(six.b(fake_data), buff_data)
class IOQueueTestCase(test_base.HyperVBaseTestCase):

5
hyperv/tests/unit/test_namedpipe.py
View File

@ -15,6 +15,7 @@
import errno
import mock
from six.moves import builtins
from hyperv.nova import constants
from hyperv.nova import namedpipe
@ -56,7 +57,7 @@ class NamedPipeTestCase(test_base.HyperVBaseTestCase):
self._handler._r_completion_routine = mock.Mock()
self._handler._w_completion_routine = mock.Mock()
@mock.patch('__builtin__.open')
@mock.patch.object(builtins, 'open')
@mock.patch.object(namedpipe.NamedPipeHandler, '_open_pipe')
def test_start_pipe_handler(self, mock_open_pipe, mock_open):
self._handler.start()
@ -190,7 +191,7 @@ class NamedPipeTestCase(test_base.HyperVBaseTestCase):
self._test_write_to_log(size_exceeded=True)
@mock.patch.object(namedpipe.NamedPipeHandler, '_retry_if_file_in_use')
@mock.patch('__builtin__.open')
@mock.patch.object(builtins, 'open')
@mock.patch.object(namedpipe, 'os')
def test_rotate_logs(self, mock_os, mock_open, mock_exec_retry):
fake_archived_log_path = self._FAKE_LOG_PATH + '.1'

9
hyperv/tests/unit/test_pathutils.py
View File

@ -15,6 +15,7 @@
import os
import mock
from six.moves import builtins
from hyperv.nova import constants
from hyperv.nova import pathutils
@ -178,8 +179,8 @@ class PathUtilsTestCase(test_base.HyperVBaseTestCase):
mock_rmtree.side_effect = [WindowsError(
pathutils.ERROR_DIR_IS_NOT_EMPTY), True]
fake_windows_error = WindowsError
with mock.patch('__builtin__.WindowsError',
fake_windows_error, create=True):
with mock.patch.object(builtins, 'WindowsError',
fake_windows_error, create=True):
self._pathutils.rmtree(mock.sentinel.FAKE_PATH)
mock_rmtree.assert_has_calls([mock.call(mock.sentinel.FAKE_PATH),
@ -196,8 +197,8 @@ class PathUtilsTestCase(test_base.HyperVBaseTestCase):
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):
with mock.patch.object(builtins, 'WindowsError',
fake_windows_error, create=True):
self.assertRaises(vmutils.HyperVException,
self._pathutils._get_instances_sub_dir,
fake_dir_name)

2
hyperv/tests/unit/test_serialconsolehandler.py
View File

@ -160,7 +160,7 @@ class SerialConsoleHandlerTestCase(test_base.HyperVBaseTestCase):
mock.call(mock.sentinel.rw_pipe_path,
pipe_type=constants.SERIAL_PORT_TYPE_RW,
enable_logging=False)]
mock_get_handler.assert_has_calls(expected_calls)
mock_get_handler.assert_has_calls(expected_calls, any_order=True)
@mock.patch.object(namedpipe, 'NamedPipeHandler')
def _test_get_named_pipe_handler(self, mock_pipe_handler_class,

3
hyperv/tests/unit/test_serialconsoleops.py
View File

@ -14,6 +14,7 @@
# under the License.
import mock
from six.moves import builtins
from nova import exception
@ -89,7 +90,7 @@ class SerialConsoleOpsTestCase(test_base.HyperVBaseTestCase):
self._serialops.get_serial_console,
mock.sentinel.instance_name)
@mock.patch("__builtin__.open")
@mock.patch.object(builtins, 'open')
@mock.patch("os.path.exists")
def test_get_console_output_exception(self, fake_path_exists, fake_open):
self._serialops._pathutils.get_vm_console_log_paths.return_value = [

8
hyperv/tests/unit/test_vhdutils.py
View File

@ -29,7 +29,7 @@ class VHDUtilsBaseTestCase(test.NoDBTestCase):
_FAKE_FORMAT = 3
_FAKE_TYPE = 3
_FAKE_MAX_INTERNAL_SIZE = units.Gi
_FAKE_DYNAMIC_BLK_SIZE = 2097152L
_FAKE_DYNAMIC_BLK_SIZE = 2097152
_FAKE_BAD_TYPE = 5
_FAKE_JOB_PATH = 'fake_job_path'
@ -234,8 +234,10 @@ class VHDUtilsTestCase(VHDUtilsBaseTestCase):
def test_get_vhd_format_vhdx(self):
with mock.patch('hyperv.nova.vhdutils.open',
mock.mock_open(read_data=vhdutils.VHDX_SIGNATURE),
create=True):
mock.mock_open(),
create=True) as mock_open:
mock_file = mock_open.return_value
mock_file.read.return_value = vhdutils.VHDX_SIGNATURE
format = self._vhdutils.get_vhd_format(self._FAKE_VHD_PATH)

25
hyperv/tests/unit/test_vhdutilsv2.py
View File

@ -13,6 +13,7 @@
# under the License.
import mock
from six.moves import builtins
from hyperv.nova import constants
from hyperv.nova import vhdutilsv2
@ -23,11 +24,11 @@ from hyperv.tests.unit import test_vhdutils
class VHDUtilsV2TestCase(test_vhdutils.VHDUtilsBaseTestCase):
"""Unit tests for the Hyper-V VHDUtilsV2 class."""
_FAKE_BLOCK_SIZE = 33554432L
_FAKE_BLOCK_SIZE = 33554432
_FAKE_LOG_SIZE = 1048576
_FAKE_LOGICAL_SECTOR_SIZE = 4096
_FAKE_METADATA_SIZE = 1048576
_FAKE_PHYSICAL_SECTOR_SIZE = 4096L
_FAKE_PHYSICAL_SECTOR_SIZE = 4096
def setUp(self):
super(VHDUtilsV2TestCase, self).setUp()
@ -50,7 +51,8 @@ class VHDUtilsV2TestCase(test_vhdutils.VHDUtilsBaseTestCase):
def _mock_get_vhd_info(self):
mock_img_svc = self._vhdutils._conn.Msvm_ImageManagementService()[0]
mock_img_svc.GetVirtualHardDiskSettingData.return_value = (
self._FAKE_JOB_PATH, self._FAKE_RET_VAL, self._FAKE_VHD_INFO_XML)
self._FAKE_JOB_PATH, self._FAKE_RET_VAL,
self._FAKE_VHD_INFO_XML)
def test_get_vhd_info(self):
self._mock_get_vhd_info()
@ -124,7 +126,7 @@ class VHDUtilsV2TestCase(test_vhdutils.VHDUtilsBaseTestCase):
expected_virt_disk_data = self._FAKE_VHD_INFO_XML.replace(
self._FAKE_PARENT_PATH, fake_new_parent_path)
mock_img_svc.SetVirtualHardDiskSettingData.assert_called_once_with(
VirtualDiskSettingData=expected_virt_disk_data)
VirtualDiskSettingData=expected_virt_disk_data.encode())
def test_reconnect_parent_vhd_exception(self):
# Test that reconnect_parent_vhd raises an exception if the
@ -180,7 +182,7 @@ class VHDUtilsV2TestCase(test_vhdutils.VHDUtilsBaseTestCase):
return_value=self._FAKE_BLOCK_SIZE)
file_mock = mock.MagicMock()
with mock.patch('__builtin__.open', file_mock):
with mock.patch.object(builtins, 'open', file_mock):
internal_size = (
self._vhdutils.get_internal_vhd_size_by_file_size(
self._FAKE_VHD_PATH, self._FAKE_MAX_INTERNAL_SIZE))
@ -196,8 +198,9 @@ class VHDUtilsV2TestCase(test_vhdutils.VHDUtilsBaseTestCase):
def test_get_vhdx_current_header(self):
VHDX_HEADER_OFFSETS = [64 * 1024, 128 * 1024]
fake_sequence_numbers = ['\x01\x00\x00\x00\x00\x00\x00\x00',
'\x02\x00\x00\x00\x00\x00\x00\x00']
fake_sequence_numbers = [
bytearray(b'\x01\x00\x00\x00\x00\x00\x00\x00'),
bytearray(b'\x02\x00\x00\x00\x00\x00\x00\x00')]
self._fake_file_handle.read = mock.MagicMock(
side_effect=fake_sequence_numbers)
@ -206,8 +209,8 @@ class VHDUtilsV2TestCase(test_vhdutils.VHDUtilsBaseTestCase):
self.assertEqual(offset, VHDX_HEADER_OFFSETS[1])
def test_get_vhdx_metadata_size(self):
fake_metadata_offset = '\x01\x00\x00\x00\x00\x00\x00\x00'
fake_metadata_size = '\x01\x00\x00\x00'
fake_metadata_offset = bytearray(b'\x01\x00\x00\x00\x00\x00\x00\x00')
fake_metadata_size = bytearray(b'\x01\x00\x00\x00')
self._fake_file_handle.read = mock.MagicMock(
side_effect=[fake_metadata_offset, fake_metadata_size])
@ -220,7 +223,7 @@ class VHDUtilsV2TestCase(test_vhdutils.VHDUtilsBaseTestCase):
def test_get_block_size(self):
self._vhdutils._get_vhdx_metadata_size_and_offset = mock.MagicMock(
return_value=(self._FAKE_METADATA_SIZE, 1024))
fake_block_size = '\x01\x00\x00\x00'
fake_block_size = bytearray(b'\x01\x00\x00\x00')
self._fake_file_handle.read = mock.MagicMock(
return_value=fake_block_size)
@ -232,7 +235,7 @@ class VHDUtilsV2TestCase(test_vhdutils.VHDUtilsBaseTestCase):
fake_current_header_offset = 64 * 1024
self._vhdutils._get_vhdx_current_header_offset = mock.MagicMock(
return_value=fake_current_header_offset)
fake_log_size = '\x01\x00\x00\x00'
fake_log_size = bytearray(b'\x01\x00\x00\x00')
self._fake_file_handle.read = mock.MagicMock(
return_value=fake_log_size)

3
hyperv/tests/unit/test_vmops.py
View File

@ -26,6 +26,7 @@ from oslo_concurrency import processutils
from oslo_config import cfg
from oslo_utils import fileutils
from oslo_utils import units
import six
from hyperv.nova import constants
from hyperv.nova import vmops
@ -1060,7 +1061,7 @@ class VMOpsTestCase(test_base.HyperVBaseTestCase):
self._vmops._create_vm_com_port_pipes(mock_instance,
mock_serial_ports)
expected_calls = []
for port_number, port_type in mock_serial_ports.iteritems():
for port_number, port_type in six.iteritems(mock_serial_ports):
expected_pipe = r'\\.\pipe\%s_%s' % (mock_instance.uuid,
port_type)
expected_calls.append(mock.call(mock_instance.name,

7
hyperv/tests/unit/test_vmutils.py
View File

@ -15,6 +15,7 @@
import mock
from nova import exception
import six
from hyperv.nova import constants
from hyperv.nova import vmutils
@ -91,7 +92,7 @@ class VMUtilsTestCase(test.NoDBTestCase):
mock_svc.GetSummaryInformation.return_value = (self._FAKE_RET_VAL,
[mock_summary])
for (key, val) in self._FAKE_SUMMARY_INFO.items():
for key, val in six.iteritems(self._FAKE_SUMMARY_INFO):
setattr(mock_summary, key, val)
summary = self._vmutils.get_vm_summary_info(self._FAKE_VM_NAME)
@ -270,8 +271,8 @@ class VMUtilsTestCase(test.NoDBTestCase):
def test_get_free_controller_slot_exception(self):
mock_get_address = mock.Mock()
mock_get_address.side_effect = range(
constants.SCSI_CONTROLLER_SLOTS_NUMBER)
mock_get_address.side_effect = list(range(
constants.SCSI_CONTROLLER_SLOTS_NUMBER))
mock_get_attached_disks = mock.Mock()
mock_get_attached_disks.return_value = (

37
hyperv/tests/unit/test_volumeops.py
View File

@ -16,7 +16,6 @@
import os
import contextlib
import mock
from oslo_config import cfg
@ -88,13 +87,11 @@ class VolumeOpsTestCase(test_base.HyperVBaseTestCase):
fake_vol_conn_info = (
block_device_info['block_device_mapping'][0]['connection_info'])
with contextlib.nested(
mock.patch.object(self._volumeops,
'_get_volume_driver'),
mock.patch.object(self._volumeops,
'ebs_root_in_block_devices')
) as (mock_get_volume_driver,
mock_ebs_in_block_devices):
mock_get_volume_driver = mock.MagicMock()
mock_ebs_in_block_devices = mock.MagicMock()
with mock.patch.multiple(self._volumeops,
_get_volume_driver=mock_get_volume_driver,
ebs_root_in_block_devices=mock_ebs_in_block_devices):
fake_vol_driver = mock_get_volume_driver.return_value
mock_ebs_in_block_devices.return_value = False
@ -368,22 +365,18 @@ class ISCSIVolumeDriverTestCase(test_base.HyperVBaseTestCase):
mock.sentinel.fake_iqn)
def test_get_mounted_disk_from_lun(self):
with contextlib.nested(
mock.patch.object(self._volume_driver._volutils,
'get_device_number_for_target'),
mock.patch.object(self._volume_driver._vmutils,
'get_mounted_disk_by_drive_number')
) as (mock_get_device_number_for_target,
mock_get_mounted_disk_by_drive_number):
mock_get_device_number_for_target = (
self._volume_driver._volutils.get_device_number_for_target)
mock_get_device_number_for_target.return_value = 0
mock_get_device_number_for_target.return_value = 0
mock_get_mounted_disk_by_drive_number.return_value = (
mock.sentinel.disk_path)
mock_get_mounted_disk = (
self._volume_driver._vmutils.get_mounted_disk_by_drive_number)
mock_get_mounted_disk.return_value = mock.sentinel.disk_path
disk = self._volume_driver._get_mounted_disk_from_lun(
mock.sentinel.target_iqn,
mock.sentinel.target_lun)
self.assertEqual(mock.sentinel.disk_path, disk)
disk = self._volume_driver._get_mounted_disk_from_lun(
mock.sentinel.target_iqn,
mock.sentinel.target_lun)
self.assertEqual(mock.sentinel.disk_path, disk)
def test_get_target_from_disk_path(self):
result = self._volume_driver.get_target_from_disk_path(